[people/ms/u-boot.git] / board / inka4x0 / inkadiag.c

/*
 * (C) Copyright 2008, 2009 Andreas Pfefferle,
 *     DENX Software Engineering, ap@denx.de.
 * (C) Copyright 2009 Detlev Zundel,
 *     DENX Software Engineering, dzu@denx.de.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <asm/io.h>
#include <common.h>
#include <config.h>
#include <console.h>
#include <mpc5xxx.h>
#include <pci.h>

#include <command.h>

/* This is needed for the includes in ns16550.h */
#define CONFIG_SYS_NS16550_REG_SIZE 1
#include <ns16550.h>

#define GPIO_BASE		((u_char *)CONFIG_SYS_CS3_START)

#define DIGIN_TOUCHSCR_MASK	0x00003000	/* Inputs 12-13 */
#define DIGIN_KEYB_MASK		0x00010000	/* Input 16 */

#define DIGIN_DRAWER_SW1	0x00400000	/* Input 22 */
#define DIGIN_DRAWER_SW2	0x00800000	/* Input 23 */

#define DIGIO_LED0		0x00000001	/* Output 0 */
#define DIGIO_LED1		0x00000002	/* Output 1 */
#define DIGIO_LED2		0x00000004	/* Output 2 */
#define DIGIO_LED3		0x00000008	/* Output 3 */
#define DIGIO_LED4		0x00000010	/* Output 4 */
#define DIGIO_LED5		0x00000020	/* Output 5 */

#define DIGIO_DRAWER1		0x00000100	/* Output 8 */
#define DIGIO_DRAWER2		0x00000200	/* Output 9 */

#define SERIAL_PORT_BASE	((u_char *)CONFIG_SYS_CS2_START)

#define PSC_OP1_RTS	0x01
#define PSC_OP0_RTS	0x01

/*
 * Table with supported baudrates (defined in inka4x0.h)
 */
static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
#define	N_BAUDRATES (sizeof(baudrate_table) / sizeof(baudrate_table[0]))

static unsigned int inka_digin_get_input(void)
{
	return in_8(GPIO_BASE + 0) << 0 | in_8(GPIO_BASE + 1) << 8 |
		in_8(GPIO_BASE + 2) << 16 | in_8(GPIO_BASE + 3) << 24;
}

#define LED_HIGH(NUM)							\
	do {								\
		setbits_be32((unsigned *)MPC5XXX_GPT##NUM##_ENABLE, 0x10); \
	} while (0)

#define LED_LOW(NUM)							\
	do {								\
		clrbits_be32((unsigned *)MPC5XXX_GPT##NUM##_ENABLE, 0x10); \
	} while (0)

#define CHECK_LED(NUM) \
    do { \
	    if (state & (1 << NUM)) {		\
		    LED_HIGH(NUM);		\
	    } else {				\
		    LED_LOW(NUM);		\
	    }					\
    } while (0)

static void inka_digio_set_output(unsigned int state, int which)
{
	volatile struct mpc5xxx_gpio *gpio = (struct mpc5xxx_gpio *)MPC5XXX_GPIO;

	if (which == 0) {
		/* other */
		CHECK_LED(0);
		CHECK_LED(1);
		CHECK_LED(2);
		CHECK_LED(3);
		CHECK_LED(4);
		CHECK_LED(5);
	} else {
		if (which == 1) {
			/* drawer1 */
			if (state) {
				clrbits_be32(&gpio->simple_dvo, 0x1000);
				udelay(1);
				setbits_be32(&gpio->simple_dvo, 0x1000);
			} else {
				setbits_be32(&gpio->simple_dvo, 0x1000);
				udelay(1);
				clrbits_be32(&gpio->simple_dvo, 0x1000);
			}
		}
		if (which == 2) {
			/* drawer 2 */
			if (state) {
				clrbits_be32(&gpio->simple_dvo, 0x2000);
				udelay(1);
				setbits_be32(&gpio->simple_dvo, 0x2000);
			} else {
				setbits_be32(&gpio->simple_dvo, 0x2000);
				udelay(1);
				clrbits_be32(&gpio->simple_dvo, 0x2000);
			}
		}
	}
	udelay(1);
}

static int do_inkadiag_io(cmd_tbl_t *cmdtp, int flag, int argc,
			  char * const argv[]) {
	unsigned int state, val;

	switch (argc) {
	case 3:
		/* Write a value */
		val = simple_strtol(argv[2], NULL, 16);

		if (strcmp(argv[1], "drawer1") == 0) {
			inka_digio_set_output(val, 1);
		} else if (strcmp(argv[1], "drawer2") == 0) {
			inka_digio_set_output(val, 2);
		} else if (strcmp(argv[1], "other") == 0)
			inka_digio_set_output(val, 0);
		else {
			printf("Invalid argument: %s\n", argv[1]);
			return -1;
		}
		/* fall through */
	case 2:
		/* Read a value */
		state = inka_digin_get_input();

		if (strcmp(argv[1], "drawer1") == 0) {
			val = (state & DIGIN_DRAWER_SW1) >> (ffs(DIGIN_DRAWER_SW1) - 1);
		} else if (strcmp(argv[1], "drawer2") == 0) {
			val = (state & DIGIN_DRAWER_SW2) >> (ffs(DIGIN_DRAWER_SW2) - 1);
		} else if (strcmp(argv[1], "other") == 0) {
			val = ((state & DIGIN_KEYB_MASK) >> (ffs(DIGIN_KEYB_MASK) - 1))
				| (state & DIGIN_TOUCHSCR_MASK) >> (ffs(DIGIN_TOUCHSCR_MASK) - 2);
		} else {
			printf("Invalid argument: %s\n", argv[1]);
			return -1;
		}
		printf("exit code: 0x%X\n", val);
		return 0;
	default:
		return cmd_usage(cmdtp);
	}

	return -1;
}

DECLARE_GLOBAL_DATA_PTR;

static int ser_init(volatile struct mpc5xxx_psc *psc, int baudrate)
{
	unsigned long baseclk;
	int div;

	/* reset PSC */
	out_8(&psc->command, PSC_SEL_MODE_REG_1);

	/* select clock sources */

	out_be16(&psc->psc_clock_select, 0);
	baseclk = (gd->arch.ipb_clk + 16) / 32;

	/* switch to UART mode */
	out_be32(&psc->sicr, 0);

	/* configure parity, bit length and so on */

	out_8(&psc->mode, PSC_MODE_8_BITS | PSC_MODE_PARNONE);
	out_8(&psc->mode, PSC_MODE_ONE_STOP);

	/* set up UART divisor */
	div = (baseclk + (baudrate / 2)) / baudrate;
	out_8(&psc->ctur, (div >> 8) & 0xff);
	out_8(&psc->ctlr, div & 0xff);

	/* disable all interrupts */
	out_be16(&psc->psc_imr, 0);

	/* reset and enable Rx/Tx */
	out_8(&psc->command, PSC_RST_RX);
	out_8(&psc->command, PSC_RST_TX);
	out_8(&psc->command, PSC_RX_ENABLE | PSC_TX_ENABLE);

	return 0;
}

static void ser_putc(volatile struct mpc5xxx_psc *psc, const char c)
{
	/* Wait 1 second for last character to go. */
	int i = 0;

	while (!(psc->psc_status & PSC_SR_TXEMP) && (i++ < 1000000/10))
		udelay(10);
	psc->psc_buffer_8 = c;

}

static int ser_getc(volatile struct mpc5xxx_psc *psc)
{
	/* Wait for a character to arrive. */
	int i = 0;

	while (!(in_be16(&psc->psc_status) & PSC_SR_RXRDY) && (i++ < 1000000/10))
		udelay(10);

	return in_8(&psc->psc_buffer_8);
}

static int do_inkadiag_serial(cmd_tbl_t *cmdtp, int flag, int argc,
			      char * const argv[]) {
	volatile struct NS16550 *uart;
	volatile struct mpc5xxx_psc *psc;
	unsigned int num, mode;
	int combrd, baudrate, i, j, len;
	int address;

	if (argc < 5)
		return cmd_usage(cmdtp);

	argc--;
	argv++;

	num = simple_strtol(argv[0], NULL, 0);
	if (num < 0 || num > 11) {
		printf("invalid argument for num: %d\n", num);
		return -1;
	}

	mode = simple_strtol(argv[1], NULL, 0);

	combrd = 0;
	baudrate = simple_strtoul(argv[2], NULL, 10);
	for (i=0; i<N_BAUDRATES; ++i) {
		if (baudrate == baudrate_table[i])
			break;
	}
	if (i == N_BAUDRATES) {
		printf("## Baudrate %d bps not supported\n",
		       baudrate);
		return 1;
	}
	combrd = 115200 / baudrate;

	uart = (struct NS16550 *)(SERIAL_PORT_BASE + (num << 3));

	printf("Testing uart %d.\n\n", num);

	if ((num >= 0) && (num <= 7)) {
		if (mode & 1) {
			/* turn on 'loopback' mode */
			out_8(&uart->mcr, UART_MCR_LOOP);
		} else {
			/*
			 * establish the UART's operational parameters
			 * set DLAB=1, so rbr accesses DLL
			 */
			out_8(&uart->lcr, UART_LCR_DLAB);
			/* set baudrate */
			out_8(&uart->rbr, combrd);
			/* set data-format: 8-N-1 */
			out_8(&uart->lcr, UART_LCR_WLS_8);
		}

		if (mode & 2) {
			/* set request to send */
			out_8(&uart->mcr, UART_MCR_RTS);
			udelay(10);
			/* check clear to send */
			if ((in_8(&uart->msr) & UART_MSR_CTS) == 0x00)
				return -1;
		}
		if (mode & 4) {
			/* set data terminal ready */
			out_8(&uart->mcr, UART_MCR_DTR);
			udelay(10);
			/* check data set ready and carrier detect */
			if ((in_8(&uart->msr) & (UART_MSR_DSR | UART_MSR_DCD))
			    != (UART_MSR_DSR | UART_MSR_DCD))
				return -1;
		}

		/* write each message-character, read it back, and display it */
		for (i = 0, len = strlen(argv[3]); i < len; ++i) {
			j = 0;
			while ((in_8(&uart->lsr) & UART_LSR_THRE) ==	0x00) {
				if (j++ > CONFIG_SYS_HZ)
					break;
				udelay(10);
			}
			out_8(&uart->rbr, argv[3][i]);
			j = 0;
			while ((in_8(&uart->lsr) & UART_LSR_DR) == 0x00) {
				if (j++ > CONFIG_SYS_HZ)
					break;
				udelay(10);
			}
			printf("%c", in_8(&uart->rbr));
		}
		printf("\n\n");
		out_8(&uart->mcr, 0x00);
	} else {
		address = 0;

		switch (num) {
		case 8:
			address = MPC5XXX_PSC6;
			break;
		case 9:
			address = MPC5XXX_PSC3;
			break;
		case 10:
			address = MPC5XXX_PSC2;
			break;
		case 11:
			address = MPC5XXX_PSC1;
			break;
		}
		psc = (struct mpc5xxx_psc *)address;
		ser_init(psc, simple_strtol(argv[2], NULL, 0));
		if (mode & 2) {
			/* set request to send */
			out_8(&psc->op0, PSC_OP0_RTS);
			udelay(10);
			/* check clear to send */
			if ((in_8(&psc->ip) & PSC_IPCR_CTS) == 0)
				return -1;
		}
		len = strlen(argv[3]);
		for (i = 0; i < len; ++i) {
			ser_putc(psc, argv[3][i]);
			printf("%c", ser_getc(psc));
		}
		printf("\n\n");
	}
	return 0;
}

#define BUZZER_GPT	(MPC5XXX_GPT + 0x60)	/* GPT6 */
static void buzzer_turn_on(unsigned int freq)
{
	volatile struct mpc5xxx_gpt *gpt = (struct mpc5xxx_gpt *)(BUZZER_GPT);

	const u32 prescale = gd->arch.ipb_clk / freq / 128;
	const u32 count = 128;
	const u32 width = 64;

	gpt->cir = (prescale << 16) | count;
	gpt->pwmcr = width << 16;
	gpt->emsr = 3;		/* Timer enabled for PWM */
}

static void buzzer_turn_off(void)
{
	volatile struct mpc5xxx_gpt *gpt = (struct mpc5xxx_gpt *)(BUZZER_GPT);

	gpt->emsr = 0;
}

static int do_inkadiag_buzzer(cmd_tbl_t *cmdtp, int flag, int argc,
			      char * const argv[]) {

	unsigned int period, freq;
	int prev, i;

	if (argc != 3)
		return cmd_usage(cmdtp);

	argc--;
	argv++;

	period = simple_strtol(argv[0], NULL, 0);
	if (!period)
		printf("Zero period is senseless\n");
	argc--;
	argv++;

	freq = simple_strtol(argv[0], NULL, 0);
	/* avoid zero prescale in buzzer_turn_on() */
	if (freq > gd->arch.ipb_clk / 128) {
		printf("%dHz exceeds maximum (%ldHz)\n", freq,
		       gd->arch.ipb_clk / 128);
	} else if (!freq)
		printf("Zero frequency is senseless\n");
	else
		buzzer_turn_on(freq);

	clear_ctrlc();
	prev = disable_ctrlc(0);

	printf("Buzzing for %d ms. Type ^C to abort!\n\n", period);

	i = 0;
	while (!ctrlc() && (i++ < CONFIG_SYS_HZ))
		udelay(period);

	clear_ctrlc();
	disable_ctrlc(prev);

	buzzer_turn_off();

	return 0;
}

static int do_inkadiag_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);

cmd_tbl_t cmd_inkadiag_sub[] = {
	U_BOOT_CMD_MKENT(io, 1, 1, do_inkadiag_io, "read digital input",
	 "<drawer1|drawer2|other> [value] - get or set specified signal"),
	U_BOOT_CMD_MKENT(serial, 4, 1, do_inkadiag_serial, "test serial port",
	 "<num> <mode> <baudrate> <msg>  - test uart num [0..11] in mode\n"
	 "and baudrate with msg"),
	U_BOOT_CMD_MKENT(buzzer, 2, 1, do_inkadiag_buzzer, "activate buzzer",
	 "<period> <freq> - turn buzzer on for period ms with freq hz"),
	U_BOOT_CMD_MKENT(help, 4, 1, do_inkadiag_help, "get help",
	 "[command] - get help for command"),
};

static int do_inkadiag_help(cmd_tbl_t *cmdtp, int flag,
			    int argc, char * const argv[]) {
	extern int _do_help (cmd_tbl_t *cmd_start, int cmd_items,
			     cmd_tbl_t *cmdtp, int flag,
			     int argc, char * const argv[]);
	/* do_help prints command name - we prepend inkadiag to our subcommands! */
#ifdef CONFIG_SYS_LONGHELP
	puts ("inkadiag ");
#endif
	return _do_help(&cmd_inkadiag_sub[0],
		ARRAY_SIZE(cmd_inkadiag_sub), cmdtp, flag, argc, argv);
}

static int do_inkadiag(cmd_tbl_t *cmdtp, int flag, int argc,
		       char * const argv[]) {
	cmd_tbl_t *c;

	c = find_cmd_tbl(argv[1], &cmd_inkadiag_sub[0], ARRAY_SIZE(cmd_inkadiag_sub));

	if (c) {
		argc--;
		argv++;
		return c->cmd(c, flag, argc, argv);
	} else {
		/* Unrecognized command */
		return cmd_usage(cmdtp);
	}
}

U_BOOT_CMD(inkadiag, 6, 1, do_inkadiag,
	   "inkadiag - inka diagnosis\n",
	   "[inkadiag what ...]\n"
	   "    - perform a diagnosis on inka hardware\n"
	   "'inkadiag' performs hardware tests.");
Commit	Line	Data
7b5611cd DZ	1	/*
	2	* (C) Copyright 2008, 2009 Andreas Pfefferle,
	3	* DENX Software Engineering, ap@denx.de.
	4	* (C) Copyright 2009 Detlev Zundel,
	5	* DENX Software Engineering, dzu@denx.de.
	6	*
1a459660	7	* SPDX-License-Identifier: GPL-2.0+
7b5611cd DZ	8	*/
	9
	10	#include <asm/io.h>
	11	#include <common.h>
	12	#include <config.h>
24b852a7	13	#include <console.h>
7b5611cd DZ	14	#include <mpc5xxx.h>
	15	#include <pci.h>
	16
	17	#include <command.h>
	18
	19	/* This is needed for the includes in ns16550.h */
	20	#define CONFIG_SYS_NS16550_REG_SIZE 1
	21	#include <ns16550.h>
	22
	23	#define GPIO_BASE ((u_char *)CONFIG_SYS_CS3_START)
	24
	25	#define DIGIN_TOUCHSCR_MASK 0x00003000 /* Inputs 12-13 */
	26	#define DIGIN_KEYB_MASK 0x00010000 /* Input 16 */
	27
	28	#define DIGIN_DRAWER_SW1 0x00400000 /* Input 22 */
	29	#define DIGIN_DRAWER_SW2 0x00800000 /* Input 23 */
	30
	31	#define DIGIO_LED0 0x00000001 /* Output 0 */
	32	#define DIGIO_LED1 0x00000002 /* Output 1 */
	33	#define DIGIO_LED2 0x00000004 /* Output 2 */
	34	#define DIGIO_LED3 0x00000008 /* Output 3 */
	35	#define DIGIO_LED4 0x00000010 /* Output 4 */
	36	#define DIGIO_LED5 0x00000020 /* Output 5 */
	37
	38	#define DIGIO_DRAWER1 0x00000100 /* Output 8 */
	39	#define DIGIO_DRAWER2 0x00000200 /* Output 9 */
	40
	41	#define SERIAL_PORT_BASE ((u_char *)CONFIG_SYS_CS2_START)
	42
	43	#define PSC_OP1_RTS 0x01
	44	#define PSC_OP0_RTS 0x01
	45
	46	/*
	47	* Table with supported baudrates (defined in inka4x0.h)
	48	*/
	49	static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
	50	#define N_BAUDRATES (sizeof(baudrate_table) / sizeof(baudrate_table[0]))
	51
	52	static unsigned int inka_digin_get_input(void)
	53	{
	54	return in_8(GPIO_BASE + 0) << 0 \| in_8(GPIO_BASE + 1) << 8 \|
	55	in_8(GPIO_BASE + 2) << 16 \| in_8(GPIO_BASE + 3) << 24;
	56	}
	57
	58	#define LED_HIGH(NUM) \
	59	do { \
	60	setbits_be32((unsigned *)MPC5XXX_GPT##NUM##_ENABLE, 0x10); \
	61	} while (0)
	62
	63	#define LED_LOW(NUM) \
	64	do { \
	65	clrbits_be32((unsigned *)MPC5XXX_GPT##NUM##_ENABLE, 0x10); \
	66	} while (0)
	67
	68	#define CHECK_LED(NUM) \
	69	do { \
	70	if (state & (1 << NUM)) { \
	71	LED_HIGH(NUM); \
	72	} else { \
	73	LED_LOW(NUM); \
	74	} \
	75	} while (0)
	76
	77	static void inka_digio_set_output(unsigned int state, int which)
78	{
79	volatile struct mpc5xxx_gpio gpio = (struct mpc5xxx_gpio )MPC5XXX_GPIO;
80
81	if (which == 0) {
82	/* other */
83	CHECK_LED(0);
84	CHECK_LED(1);
85	CHECK_LED(2);
86	CHECK_LED(3);
87	CHECK_LED(4);
88	CHECK_LED(5);
89	} else {
90	if (which == 1) {
91	/* drawer1 */
92	if (state) {
93	clrbits_be32(&gpio->simple_dvo, 0x1000);
94	udelay(1);
95	setbits_be32(&gpio->simple_dvo, 0x1000);
96	} else {
97	setbits_be32(&gpio->simple_dvo, 0x1000);
98	udelay(1);
99	clrbits_be32(&gpio->simple_dvo, 0x1000);
100	}
101	}
102	if (which == 2) {
103	/* drawer 2 */
104	if (state) {
105	clrbits_be32(&gpio->simple_dvo, 0x2000);
106	udelay(1);
107	setbits_be32(&gpio->simple_dvo, 0x2000);
108	} else {
109	setbits_be32(&gpio->simple_dvo, 0x2000);
110	udelay(1);
111	clrbits_be32(&gpio->simple_dvo, 0x2000);
112	}
113	}
114	}
115	udelay(1);
116	}
117
118	static int do_inkadiag_io(cmd_tbl_t *cmdtp, int flag, int argc,
54841ab5	119	char * const argv[]) {
7b5611cd DZ	120	unsigned int state, val;
	121
	122	switch (argc) {
	123	case 3:
	124	/* Write a value */
	125	val = simple_strtol(argv[2], NULL, 16);
	126
	127	if (strcmp(argv[1], "drawer1") == 0) {
	128	inka_digio_set_output(val, 1);
	129	} else if (strcmp(argv[1], "drawer2") == 0) {
	130	inka_digio_set_output(val, 2);
	131	} else if (strcmp(argv[1], "other") == 0)
	132	inka_digio_set_output(val, 0);
	133	else {
	134	printf("Invalid argument: %s\n", argv[1]);
	135	return -1;
	136	}
	137	/* fall through */
	138	case 2:
	139	/* Read a value */
	140	state = inka_digin_get_input();
	141
	142	if (strcmp(argv[1], "drawer1") == 0) {
	143	val = (state & DIGIN_DRAWER_SW1) >> (ffs(DIGIN_DRAWER_SW1) - 1);
	144	} else if (strcmp(argv[1], "drawer2") == 0) {
	145	val = (state & DIGIN_DRAWER_SW2) >> (ffs(DIGIN_DRAWER_SW2) - 1);
	146	} else if (strcmp(argv[1], "other") == 0) {
	147	val = ((state & DIGIN_KEYB_MASK) >> (ffs(DIGIN_KEYB_MASK) - 1))
	148	\| (state & DIGIN_TOUCHSCR_MASK) >> (ffs(DIGIN_TOUCHSCR_MASK) - 2);
	149	} else {
	150	printf("Invalid argument: %s\n", argv[1]);
	151	return -1;
	152	}
	153	printf("exit code: 0x%X\n", val);
	154	return 0;
	155	default:
47e26b1b	156	return cmd_usage(cmdtp);
7b5611cd DZ	157	}
	158
	159	return -1;
	160	}
	161
	162	DECLARE_GLOBAL_DATA_PTR;
	163
	164	static int ser_init(volatile struct mpc5xxx_psc *psc, int baudrate)
	165	{
	166	unsigned long baseclk;
	167	int div;
	168
	169	/* reset PSC */
	170	out_8(&psc->command, PSC_SEL_MODE_REG_1);
	171
	172	/* select clock sources */
	173
	174	out_be16(&psc->psc_clock_select, 0);
b2877496	175	baseclk = (gd->arch.ipb_clk + 16) / 32;
7b5611cd DZ	176
	177	/* switch to UART mode */
	178	out_be32(&psc->sicr, 0);
	179
	180	/* configure parity, bit length and so on */
	181
	182	out_8(&psc->mode, PSC_MODE_8_BITS \| PSC_MODE_PARNONE);
	183	out_8(&psc->mode, PSC_MODE_ONE_STOP);
	184
	185	/* set up UART divisor */
	186	div = (baseclk + (baudrate / 2)) / baudrate;
	187	out_8(&psc->ctur, (div >> 8) & 0xff);
	188	out_8(&psc->ctlr, div & 0xff);
	189
	190	/* disable all interrupts */
	191	out_be16(&psc->psc_imr, 0);
	192
	193	/* reset and enable Rx/Tx */
	194	out_8(&psc->command, PSC_RST_RX);
	195	out_8(&psc->command, PSC_RST_TX);
	196	out_8(&psc->command, PSC_RX_ENABLE \| PSC_TX_ENABLE);
	197
	198	return 0;
	199	}
	200
	201	static void ser_putc(volatile struct mpc5xxx_psc *psc, const char c)
	202	{
	203	/* Wait 1 second for last character to go. */
	204	int i = 0;
	205
	206	while (!(psc->psc_status & PSC_SR_TXEMP) && (i++ < 1000000/10))
	207	udelay(10);
	208	psc->psc_buffer_8 = c;
	209
	210	}
	211
	212	static int ser_getc(volatile struct mpc5xxx_psc *psc)
	213	{
	214	/* Wait for a character to arrive. */
	215	int i = 0;
	216
	217	while (!(in_be16(&psc->psc_status) & PSC_SR_RXRDY) && (i++ < 1000000/10))
	218	udelay(10);
	219
	220	return in_8(&psc->psc_buffer_8);
	221	}
	222
	223	static int do_inkadiag_serial(cmd_tbl_t *cmdtp, int flag, int argc,
54841ab5	224	char * const argv[]) {
7b5611cd DZ	225	volatile struct NS16550 *uart;
	226	volatile struct mpc5xxx_psc *psc;
	227	unsigned int num, mode;
	228	int combrd, baudrate, i, j, len;
	229	int address;
	230
47e26b1b WD	231	if (argc < 5)
47e26b1b WD	232	return cmd_usage(cmdtp);
7b5611cd DZ	233
	234	argc--;
	235	argv++;
	236
	237	num = simple_strtol(argv[0], NULL, 0);
	238	if (num < 0 \|\| num > 11) {
	239	printf("invalid argument for num: %d\n", num);
	240	return -1;
	241	}
	242
	243	mode = simple_strtol(argv[1], NULL, 0);
	244
	245	combrd = 0;
	246	baudrate = simple_strtoul(argv[2], NULL, 10);
	247	for (i=0; i<N_BAUDRATES; ++i) {
	248	if (baudrate == baudrate_table[i])
	249	break;
	250	}
	251	if (i == N_BAUDRATES) {
	252	printf("## Baudrate %d bps not supported\n",
	253	baudrate);
	254	return 1;
	255	}
	256	combrd = 115200 / baudrate;
	257
	258	uart = (struct NS16550 *)(SERIAL_PORT_BASE + (num << 3));
	259
	260	printf("Testing uart %d.\n\n", num);
	261
	262	if ((num >= 0) && (num <= 7)) {
	263	if (mode & 1) {
	264	/* turn on 'loopback' mode */
200779e3	265	out_8(&uart->mcr, UART_MCR_LOOP);
7b5611cd DZ	266	} else {
	267	/*
	268	* establish the UART's operational parameters
	269	* set DLAB=1, so rbr accesses DLL
	270	*/
200779e3	271	out_8(&uart->lcr, UART_LCR_DLAB);
7b5611cd DZ	272	/* set baudrate */
	273	out_8(&uart->rbr, combrd);
	274	/* set data-format: 8-N-1 */
200779e3	275	out_8(&uart->lcr, UART_LCR_WLS_8);
7b5611cd DZ	276	}
	277
	278	if (mode & 2) {
	279	/* set request to send */
200779e3	280	out_8(&uart->mcr, UART_MCR_RTS);
7b5611cd DZ	281	udelay(10);
7b5611cd DZ	282	/* check clear to send */
200779e3	283	if ((in_8(&uart->msr) & UART_MSR_CTS) == 0x00)
7b5611cd DZ	284	return -1;
	285	}
	286	if (mode & 4) {
	287	/* set data terminal ready */
200779e3	288	out_8(&uart->mcr, UART_MCR_DTR);
7b5611cd DZ	289	udelay(10);
7b5611cd DZ	290	/* check data set ready and carrier detect */
200779e3 DZ	291	if ((in_8(&uart->msr) & (UART_MSR_DSR \| UART_MSR_DCD))
200779e3 DZ	292	!= (UART_MSR_DSR \| UART_MSR_DCD))
7b5611cd DZ	293	return -1;
	294	}
	295
	296	/* write each message-character, read it back, and display it */
	297	for (i = 0, len = strlen(argv[3]); i < len; ++i) {
	298	j = 0;
200779e3	299	while ((in_8(&uart->lsr) & UART_LSR_THRE) == 0x00) {
7b5611cd DZ	300	if (j++ > CONFIG_SYS_HZ)
	301	break;
	302	udelay(10);
	303	}
	304	out_8(&uart->rbr, argv[3][i]);
	305	j = 0;
200779e3	306	while ((in_8(&uart->lsr) & UART_LSR_DR) == 0x00) {
7b5611cd DZ	307	if (j++ > CONFIG_SYS_HZ)
	308	break;
	309	udelay(10);
	310	}
	311	printf("%c", in_8(&uart->rbr));
	312	}
	313	printf("\n\n");
	314	out_8(&uart->mcr, 0x00);
	315	} else {
	316	address = 0;
	317
	318	switch (num) {
	319	case 8:
	320	address = MPC5XXX_PSC6;
	321	break;
	322	case 9:
	323	address = MPC5XXX_PSC3;
	324	break;
	325	case 10:
	326	address = MPC5XXX_PSC2;
	327	break;
	328	case 11:
	329	address = MPC5XXX_PSC1;
	330	break;
	331	}
	332	psc = (struct mpc5xxx_psc *)address;
	333	ser_init(psc, simple_strtol(argv[2], NULL, 0));
	334	if (mode & 2) {
	335	/* set request to send */
	336	out_8(&psc->op0, PSC_OP0_RTS);
	337	udelay(10);
	338	/* check clear to send */
	339	if ((in_8(&psc->ip) & PSC_IPCR_CTS) == 0)
	340	return -1;
	341	}
	342	len = strlen(argv[3]);
	343	for (i = 0; i < len; ++i) {
	344	ser_putc(psc, argv[3][i]);
	345	printf("%c", ser_getc(psc));
	346	}
	347	printf("\n\n");
	348	}
	349	return 0;
	350	}
	351
	352	#define BUZZER_GPT (MPC5XXX_GPT + 0x60) /* GPT6 */
	353	static void buzzer_turn_on(unsigned int freq)
	354	{
	355	volatile struct mpc5xxx_gpt gpt = (struct mpc5xxx_gpt )(BUZZER_GPT);
	356
b2877496	357	const u32 prescale = gd->arch.ipb_clk / freq / 128;
7b5611cd DZ	358	const u32 count = 128;
	359	const u32 width = 64;
	360
	361	gpt->cir = (prescale << 16) \| count;
	362	gpt->pwmcr = width << 16;
	363	gpt->emsr = 3; /* Timer enabled for PWM */
	364	}
	365
	366	static void buzzer_turn_off(void)
	367	{
	368	volatile struct mpc5xxx_gpt gpt = (struct mpc5xxx_gpt )(BUZZER_GPT);
	369
	370	gpt->emsr = 0;
	371	}
	372
	373	static int do_inkadiag_buzzer(cmd_tbl_t *cmdtp, int flag, int argc,
54841ab5	374	char * const argv[]) {
7b5611cd DZ	375
	376	unsigned int period, freq;
	377	int prev, i;
	378
47e26b1b WD	379	if (argc != 3)
47e26b1b WD	380	return cmd_usage(cmdtp);
7b5611cd DZ	381
	382	argc--;
	383	argv++;
	384
	385	period = simple_strtol(argv[0], NULL, 0);
	386	if (!period)
	387	printf("Zero period is senseless\n");
	388	argc--;
	389	argv++;
	390
	391	freq = simple_strtol(argv[0], NULL, 0);
	392	/* avoid zero prescale in buzzer_turn_on() */
b2877496	393	if (freq > gd->arch.ipb_clk / 128) {
7b5611cd	394	printf("%dHz exceeds maximum (%ldHz)\n", freq,
b2877496	395	gd->arch.ipb_clk / 128);
7b5611cd DZ	396	} else if (!freq)
	397	printf("Zero frequency is senseless\n");
	398	else
	399	buzzer_turn_on(freq);
	400
	401	clear_ctrlc();
	402	prev = disable_ctrlc(0);
	403
	404	printf("Buzzing for %d ms. Type ^C to abort!\n\n", period);
	405
	406	i = 0;
	407	while (!ctrlc() && (i++ < CONFIG_SYS_HZ))
	408	udelay(period);
	409
	410	clear_ctrlc();
	411	disable_ctrlc(prev);
	412
	413	buzzer_turn_off();
	414
	415	return 0;
	416	}
	417
54841ab5	418	static int do_inkadiag_help(cmd_tbl_t cmdtp, int flag, int argc, char const argv[]);
7b5611cd DZ	419
	420	cmd_tbl_t cmd_inkadiag_sub[] = {
	421	U_BOOT_CMD_MKENT(io, 1, 1, do_inkadiag_io, "read digital input",
a89c33db	422	"<drawer1\|drawer2\|other> [value] - get or set specified signal"),
7b5611cd DZ	423	U_BOOT_CMD_MKENT(serial, 4, 1, do_inkadiag_serial, "test serial port",
7b5611cd DZ	424	"<num> <mode> <baudrate> <msg> - test uart num [0..11] in mode\n"
a89c33db	425	"and baudrate with msg"),
7b5611cd	426	U_BOOT_CMD_MKENT(buzzer, 2, 1, do_inkadiag_buzzer, "activate buzzer",
a89c33db	427	"<period> <freq> - turn buzzer on for period ms with freq hz"),
7b5611cd	428	U_BOOT_CMD_MKENT(help, 4, 1, do_inkadiag_help, "get help",
a89c33db	429	"[command] - get help for command"),
7b5611cd DZ	430	};
	431
	432	static int do_inkadiag_help(cmd_tbl_t *cmdtp, int flag,
54841ab5	433	int argc, char * const argv[]) {
7b5611cd DZ	434	extern int _do_help (cmd_tbl_t *cmd_start, int cmd_items,
7b5611cd DZ	435	cmd_tbl_t *cmdtp, int flag,
54841ab5	436	int argc, char * const argv[]);
7b5611cd DZ	437	/* do_help prints command name - we prepend inkadiag to our subcommands! */
	438	#ifdef CONFIG_SYS_LONGHELP
	439	puts ("inkadiag ");
	440	#endif
	441	return _do_help(&cmd_inkadiag_sub[0],
	442	ARRAY_SIZE(cmd_inkadiag_sub), cmdtp, flag, argc, argv);
	443	}
	444
	445	static int do_inkadiag(cmd_tbl_t *cmdtp, int flag, int argc,
54841ab5	446	char * const argv[]) {
7b5611cd DZ	447	cmd_tbl_t *c;
	448
	449	c = find_cmd_tbl(argv[1], &cmd_inkadiag_sub[0], ARRAY_SIZE(cmd_inkadiag_sub));
	450
	451	if (c) {
	452	argc--;
	453	argv++;
	454	return c->cmd(c, flag, argc, argv);
	455	} else {
	456	/* Unrecognized command */
47e26b1b	457	return cmd_usage(cmdtp);
7b5611cd DZ	458	}
	459	}
	460
	461	U_BOOT_CMD(inkadiag, 6, 1, do_inkadiag,
	462	"inkadiag - inka diagnosis\n",
	463	"[inkadiag what ...]\n"
	464	" - perform a diagnosis on inka hardware\n"
a89c33db	465	"'inkadiag' performs hardware tests.");