inka4x0: Add hardware diagnosis functions for inka4x0
authorDetlev Zundel <dzu@denx.de>
Sun, 29 Mar 2009 22:31:34 +0000 (00:31 +0200)
committerWolfgang Denk <wd@denx.de>
Mon, 30 Mar 2009 07:41:28 +0000 (09:41 +0200)
This patch adds advanced diagnosis functions for the inka4x0 board.

Signed-off-by: Andreas Pfefferle <ap@denx.de>
Signed-off-by: Detlev Zundel <dzu@denx.de>
board/inka4x0/Makefile
board/inka4x0/inka4x0.c
board/inka4x0/inkadiag.c [new file with mode: 0644]
include/configs/inka4x0.h
include/ns16550.h

index 442e2d0df25c1719bc48681008793e7f697ff541..82aa950017223e0247237246923e451822d91946 100644 (file)
@@ -1,5 +1,5 @@
 #
-# (C) Copyright 2003-2006
+# (C) Copyright 2003-2009
 # Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 #
 # See file CREDITS for list of people who contributed to this
@@ -25,7 +25,7 @@ include $(TOPDIR)/config.mk
 
 LIB    = $(obj)lib$(BOARD).a
 
-COBJS  := $(BOARD).o
+COBJS  := $(BOARD).o inkadiag.o
 
 SRCS   := $(SOBJS:.o=.S) $(COBJS:.o=.c)
 OBJS   := $(addprefix $(obj),$(COBJS))
index 507196bb2f8f0a965e6491cdeba8541d7e25889a..bb5c25d3b69acaea4ed52169fd2e5d4f08dfe435 100644 (file)
@@ -1,6 +1,9 @@
 /*
- * (C) Copyright 2003-2004
- * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ * (C) Copyright 2008-2009
+ * Andreas Pfefferle, DENX Software Engineering, ap@denx.de.
+ *
+ * (C) Copyright 2009
+ * Detlev Zundel, DENX Software Engineering, dzu@denx.de.
  *
  * (C) Copyright 2004
  * Mark Jonas, Freescale Semiconductor, mark.jonas@motorola.com.
@@ -8,6 +11,9 @@
  * (C) Copyright 2004
  * Martin Krause, TQ-Systems GmbH, martin.krause@tqs.de
  *
+ * (C) Copyright 2003-2004
+ * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ *
  * See file CREDITS for list of people who contributed to this
  * project.
  *
@@ -171,6 +177,16 @@ void flash_preinit(void)
        *(vu_long *)MPC5XXX_BOOTCS_CFG &= ~0x1; /* clear RO */
 }
 
+int misc_init_r (void) {
+       extern int inkadiag_init_r (void);
+
+       /*
+        * The command table used for the subcommands of inkadiag
+        * needs to be relocated manually.
+        */
+       return inkadiag_init_r();
+}
+
 int misc_init_f (void)
 {
        char tmp[10];
diff --git a/board/inka4x0/inkadiag.c b/board/inka4x0/inkadiag.c
new file mode 100644 (file)
index 0000000..06c9807
--- /dev/null
@@ -0,0 +1,514 @@
+/*
+ * (C) Copyright 2008, 2009 Andreas Pfefferle,
+ *     DENX Software Engineering, ap@denx.de.
+ * (C) Copyright 2009 Detlev Zundel,
+ *     DENX Software Engineering, dzu@denx.de.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <asm/io.h>
+#include <common.h>
+#include <config.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 *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:
+               cmd_usage(cmdtp);
+               break;
+       }
+
+       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->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 *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) {
+               cmd_usage(cmdtp);
+               return 1;
+       }
+
+       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, MCR_LOOP);
+               } else {
+                       /*
+                        * establish the UART's operational parameters
+                        * set DLAB=1, so rbr accesses DLL
+                        */
+                       out_8(&uart->lcr, LCR_DLAB);
+                       /* set baudrate */
+                       out_8(&uart->rbr, combrd);
+                       /* set data-format: 8-N-1 */
+                       out_8(&uart->lcr, LCR_WLS_8);
+               }
+
+               if (mode & 2) {
+                       /* set request to send */
+                       out_8(&uart->mcr, MCR_RTS);
+                       udelay(10);
+                       /* check clear to send */
+                       if ((in_8(&uart->msr) & MSR_CTS) == 0x00)
+                               return -1;
+               }
+               if (mode & 4) {
+                       /* set data terminal ready */
+                       out_8(&uart->mcr, MCR_DTR);
+                       udelay(10);
+                       /* check data set ready and carrier detect */
+                       if ((in_8(&uart->msr) & (MSR_DSR | MSR_DCD))
+                           != (MSR_DSR | 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) & 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) & 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->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 *argv[]) {
+
+       unsigned int period, freq;
+       int prev, i;
+
+       if (argc != 3) {
+               cmd_usage(cmdtp);
+               return 1;
+       }
+
+       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->ipb_clk / 128) {
+               printf("%dHz exceeds maximum (%ldHz)\n", freq,
+                      gd->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 *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\n"),
+       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\n"),
+       U_BOOT_CMD_MKENT(buzzer, 2, 1, do_inkadiag_buzzer, "activate buzzer",
+        "<period> <freq> - turn buzzer on for period ms with freq hz\n"),
+       U_BOOT_CMD_MKENT(help, 4, 1, do_inkadiag_help, "get help",
+        "[command] - get help for command\n"),
+};
+
+static int do_inkadiag_help(cmd_tbl_t *cmdtp, int flag,
+                           int argc, char *argv[]) {
+       extern int _do_help (cmd_tbl_t *cmd_start, int cmd_items,
+                            cmd_tbl_t *cmdtp, int flag,
+                            int argc, char *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 *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 */
+               cmd_usage(cmdtp);
+               return 1;
+       }
+}
+
+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.\n\n");
+
+/* Relocate the command table function pointers when running in RAM */
+int inkadiag_init_r (void) {
+       cmd_tbl_t *cmdtp;
+
+       for (cmdtp = &cmd_inkadiag_sub[0]; cmdtp !=
+                    &cmd_inkadiag_sub[ARRAY_SIZE(cmd_inkadiag_sub)]; cmdtp++) {
+               ulong addr;
+
+               addr = (ulong) (cmdtp->cmd) + gd->reloc_off;
+               cmdtp->cmd = (int (*)(struct cmd_tbl_s *, int, int, char *[]))addr;
+
+               addr = (ulong)(cmdtp->name) + gd->reloc_off;
+               cmdtp->name = (char *)addr;
+
+               if (cmdtp->usage) {
+                       addr = (ulong)(cmdtp->usage) + gd->reloc_off;
+                       cmdtp->usage = (char *)addr;
+               }
+#ifdef CONFIG_SYS_LONGHELP
+               if (cmdtp->help) {
+                       addr = (ulong)(cmdtp->help) + gd->reloc_off;
+                       cmdtp->help = (char *)addr;
+               }
+#endif
+       }
+       return 0;
+}
index e42fa6dcc82b99fc99e13265a1bd43e397f86f5f..b80796d023305f52352827ffbb966a006f6e0cec 100644 (file)
@@ -39,6 +39,7 @@
 #define BOOTFLAG_WARM          0x02    /* Software reboot                      */
 
 #define CONFIG_MISC_INIT_F     1       /* Use misc_init_f()                    */
+#define CONFIG_MISC_INIT_R     1       /* Use misc_init_r()                    */
 
 #define CONFIG_HIGH_BATS       1       /* High BATs supported                  */
 
index e6ade61a226beab883488376c53ae513c599785f..edfbc53a521e402e8baf678a3f8d0985c9f8bd2e 100644 (file)
@@ -123,6 +123,7 @@ typedef volatile struct NS16550 *NS16550_t;
 #define MCR_RTS         0x02
 #define MCR_DMA_EN      0x04
 #define MCR_TX_DFR      0x08
+#define MCR_LOOP       0x10            /* Enable loopback test mode */
 
 #define LCR_WLS_MSK    0x03            /* character length select mask */
 #define LCR_WLS_5      0x00            /* 5 bit character length */
@@ -135,6 +136,7 @@ typedef volatile struct NS16550 *NS16550_t;
 #define LCR_STKP       0x20            /* Stick Parity */
 #define LCR_SBRK       0x40            /* Set Break */
 #define LCR_BKSE       0x80            /* Bank select enable */
+#define LCR_DLAB       0x80            /* Divisor latch access bit */
 
 #define LSR_DR         0x01            /* Data ready */
 #define LSR_OE         0x02            /* Overrun */
@@ -145,6 +147,15 @@ typedef volatile struct NS16550 *NS16550_t;
 #define LSR_TEMT       0x40            /* Xmitter empty */
 #define LSR_ERR                0x80            /* Error */
 
+#define MSR_DCD                0x80            /* Data Carrier Detect */
+#define MSR_RI         0x40            /* Ring Indicator */
+#define MSR_DSR                0x20            /* Data Set Ready */
+#define MSR_CTS                0x10            /* Clear to Send */
+#define MSR_DDCD       0x08            /* Delta DCD */
+#define MSR_TERI       0x04            /* Trailing edge ring indicator */
+#define MSR_DDSR       0x02            /* Delta DSR */
+#define MSR_DCTS       0x01            /* Delta CTS */
+
 #ifdef CONFIG_OMAP1510
 #define OSC_12M_SEL    0x01            /* selects 6.5 * current clk div */
 #endif