arch/ppc64/kernel/udbg.c

   1 /*
   2  * NS16550 Serial Port (uart) debugging stuff.
   3  *
   4  * c 2001 PPC 64 Team, IBM Corp
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License
   8  *      as published by the Free Software Foundation; either version
   9  *      2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <stdarg.h>
  13 #define WANT_PPCDBG_TAB /* Only defined here */
  14 #include <asm/ppcdebug.h>
  15 #include <asm/processor.h>
  16 #include <asm/naca.h>
  17 #include <asm/uaccess.h>
  18 #include <asm/machdep.h>
  19 #include <asm/io.h>
  20 #include <asm/prom.h>
  21 #include <asm/pmac_feature.h>
  22
  23 struct NS16550 {
  24         /* this struct must be packed */
  25         unsigned char rbr;  /* 0 */
  26         unsigned char ier;  /* 1 */
  27         unsigned char fcr;  /* 2 */
  28         unsigned char lcr;  /* 3 */
  29         unsigned char mcr;  /* 4 */
  30         unsigned char lsr;  /* 5 */
  31         unsigned char msr;  /* 6 */
  32         unsigned char scr;  /* 7 */
  33 };
  34
  35 #define thr rbr
  36 #define iir fcr
  37 #define dll rbr
  38 #define dlm ier
  39 #define dlab lcr
  40
  41 #define LSR_DR   0x01  /* Data ready */
  42 #define LSR_OE   0x02  /* Overrun */
  43 #define LSR_PE   0x04  /* Parity error */
  44 #define LSR_FE   0x08  /* Framing error */
  45 #define LSR_BI   0x10  /* Break */
  46 #define LSR_THRE 0x20  /* Xmit holding register empty */
  47 #define LSR_TEMT 0x40  /* Xmitter empty */
  48 #define LSR_ERR  0x80  /* Error */
  49
  50 static volatile struct NS16550 *udbg_comport;
  51
  52 void udbg_init_uart(void *comport)
  53 {
  54         if (comport) {
  55                 udbg_comport = (struct NS16550 *)comport;
  56                 udbg_comport->lcr = 0x00; eieio();
  57                 udbg_comport->ier = 0xFF; eieio();
  58                 udbg_comport->ier = 0x00; eieio();
  59                 udbg_comport->lcr = 0x80; eieio();      /* Access baud rate */
  60                 udbg_comport->dll = 12;   eieio();      /* 1 = 115200,  2 = 57600, 3 = 38400, 12 = 9600 baud */
  61                 udbg_comport->dlm = 0;    eieio();      /* dll >> 8 which should be zero for fast rates; */
  62                 udbg_comport->lcr = 0x03; eieio();      /* 8 data, 1 stop, no parity */
  63                 udbg_comport->mcr = 0x03; eieio();      /* RTS/DTR */
  64                 udbg_comport->fcr = 0x07; eieio();      /* Clear & enable FIFOs */
  65         }
  66 }
  67
  68 #ifdef CONFIG_PPC_PMAC
  69
  70 #define SCC_TXRDY       4
  71 #define SCC_RXRDY       1
  72
  73 static volatile u8 *sccc, *sccd;
  74
  75 static unsigned char scc_inittab[] = {
  76     13, 0,              /* set baud rate divisor */
  77     12, 0,
  78     14, 1,              /* baud rate gen enable, src=rtxc */
  79     11, 0x50,           /* clocks = br gen */
  80     5,  0xea,           /* tx 8 bits, assert DTR & RTS */
  81     4,  0x46,           /* x16 clock, 1 stop */
  82     3,  0xc1,           /* rx enable, 8 bits */
  83 };
  84
  85 void udbg_init_scc(struct device_node *np)
  86 {
  87         u32 *reg;
  88         unsigned long addr;
  89         int i, x;
  90
  91         if (np == NULL)
  92                 np = of_find_node_by_name(NULL, "escc");
  93         if (np == NULL || np->parent == NULL)
  94                 return;
  95
  96         udbg_printf("found SCC...\n");
  97         /* Get address within mac-io ASIC */
  98         reg = (u32 *)get_property(np, "reg", NULL);
  99         if (reg == NULL)
 100                 return;
 101         addr = reg[0];
 102         udbg_printf("local addr: %lx\n", addr);
 103         /* Get address of mac-io PCI itself */
 104         reg = (u32 *)get_property(np->parent, "assigned-addresses", NULL);
 105         if (reg == NULL)
 106                 return;
 107         addr += reg[2];
 108         udbg_printf("final addr: %lx\n", addr);
 109
 110         /* Setup for 57600 8N1 */
 111         addr += 0x20;
 112         sccc = (volatile u8 *) ioremap(addr & PAGE_MASK, PAGE_SIZE) ;
 113         sccc += addr & ~PAGE_MASK;
 114         sccd = sccc + 0x10;
 115
 116         udbg_printf("ioremap result sccc: %p\n", sccc);
 117         mb();
 118
 119         for (i = 20000; i != 0; --i)
 120                 x = *sccc; eieio();
 121         *sccc = 9; eieio();             /* reset A or B side */
 122         *sccc = 0xc0; eieio();
 123         for (i = 0; i < sizeof(scc_inittab); ++i) {
 124                 *sccc = scc_inittab[i];
 125                 eieio();
 126         }
 127
 128         ppc_md.udbg_putc = udbg_putc;
 129         ppc_md.udbg_getc = udbg_getc;
 130         ppc_md.udbg_getc_poll = udbg_getc_poll;
 131
 132         udbg_puts("Hello World !\n");
 133 }
 134
 135 #endif /* CONFIG_PPC_PMAC */
 136
 137 #if CONFIG_PPC_PMAC
 138 extern u8 real_readb(volatile u8 *addr);
 139 extern void real_writeb(u8 data, volatile u8 *addr);
 140
 141 static void udbg_real_putc(unsigned char c)
 142 {
 143         while ((real_readb(sccc) & SCC_TXRDY) == 0)
 144                 ;
 145         real_writeb(c, sccd);
 146         if (c == '\n')
 147                 udbg_real_putc('\r');
 148 }
 149
 150 void udbg_init_pmac_realmode(void)
 151 {
 152         sccc = (volatile u8 *)0x80013020ul;
 153         sccd = (volatile u8 *)0x80013030ul;
 154
 155         ppc_md.udbg_putc = udbg_real_putc;
 156         ppc_md.udbg_getc = NULL;
 157         ppc_md.udbg_getc_poll = NULL;
 158 }
 159 #endif /* CONFIG_PPC_PMAC */
 160
 161 void udbg_putc(unsigned char c)
 162 {
 163         if (udbg_comport) {
 164                 while ((udbg_comport->lsr & LSR_THRE) == 0)
 165                         /* wait for idle */;
 166                 udbg_comport->thr = c; eieio();
 167                 if (c == '\n') {
 168                         /* Also put a CR.  This is for convenience. */
 169                         while ((udbg_comport->lsr & LSR_THRE) == 0)
 170                                 /* wait for idle */;
 171                         udbg_comport->thr = '\r'; eieio();
 172                 }
 173         }
 174 #ifdef CONFIG_PPC_PMAC
 175         else if (sccc) {
 176                 while ((*sccc & SCC_TXRDY) == 0)
 177                         eieio();
 178                 *sccd = c;
 179                 eieio();
 180                 if (c == '\n')
 181                         udbg_putc('\r');
 182         }
 183 #endif /* CONFIG_PPC_PMAC */
 184 }
 185
 186 int udbg_getc_poll(void)
 187 {
 188         if (udbg_comport) {
 189                 if ((udbg_comport->lsr & LSR_DR) != 0)
 190                         return udbg_comport->rbr;
 191                 else
 192                         return -1;
 193         }
 194 #ifdef CONFIG_PPC_PMAC
 195         else if (sccc) {
 196                 eieio();
 197                 if ((*sccc & SCC_RXRDY) != 0)
 198                         return *sccd;
 199                 else
 200                         return -1;
 201         }
 202 #endif /* CONFIG_PPC_PMAC */
 203         return -1;
 204 }
 205
 206 unsigned char udbg_getc(void)
 207 {
 208         if (udbg_comport) {
 209                 while ((udbg_comport->lsr & LSR_DR) == 0)
 210                         /* wait for char */;
 211                 return udbg_comport->rbr;
 212         }
 213 #ifdef CONFIG_PPC_PMAC
 214         else if (sccc) {
 215                 eieio();
 216                 while ((*sccc & SCC_RXRDY) == 0)
 217                         eieio();
 218                 return *sccd;
 219         }
 220 #endif /* CONFIG_PPC_PMAC */
 221         return 0;
 222 }
 223
 224 void udbg_puts(const char *s)
 225 {
 226         if (ppc_md.udbg_putc) {
 227                 char c;
 228
 229                 if (s && *s != '\0') {
 230                         while ((c = *s++) != '\0')
 231                                 ppc_md.udbg_putc(c);
 232                 }
 233         }
 234 #if 0
 235         else {
 236                 printk("%s", s);
 237         }
 238 #endif
 239 }
 240
 241 int udbg_write(const char *s, int n)
 242 {
 243         int remain = n;
 244         char c;
 245
 246         if (!ppc_md.udbg_putc)
 247                 return 0;
 248
 249         if (s && *s != '\0') {
 250                 while (((c = *s++) != '\0') && (remain-- > 0)) {
 251                         ppc_md.udbg_putc(c);
 252                 }
 253         }
 254
 255         return n - remain;
 256 }
 257
 258 int udbg_read(char *buf, int buflen)
 259 {
 260         char c, *p = buf;
 261         int i;
 262
 263         if (!ppc_md.udbg_getc)
 264                 return 0;
 265
 266         for (i = 0; i < buflen; ++i) {
 267                 do {
 268                         c = ppc_md.udbg_getc();
 269                 } while (c == 0x11 || c == 0x13);
 270                 if (c == 0)
 271                         break;
 272                 *p++ = c;
 273         }
 274
 275         return i;
 276 }
 277
 278 void udbg_console_write(struct console *con, const char *s, unsigned int n)
 279 {
 280         udbg_write(s, n);
 281 }
 282
 283 #define UDBG_BUFSIZE 256
 284 void udbg_printf(const char *fmt, ...)
 285 {
 286         unsigned char buf[UDBG_BUFSIZE];
 287         va_list args;
 288
 289         va_start(args, fmt);
 290         vsnprintf(buf, UDBG_BUFSIZE, fmt, args);
 291         udbg_puts(buf);
 292         va_end(args);
 293 }
 294
 295 /* Special print used by PPCDBG() macro */
 296 void udbg_ppcdbg(unsigned long debug_flags, const char *fmt, ...)
 297 {
 298         unsigned long active_debugs = debug_flags & naca->debug_switch;
 299
 300         if (active_debugs) {
 301                 va_list ap;
 302                 unsigned char buf[UDBG_BUFSIZE];
 303                 unsigned long i, len = 0;
 304
 305                 for (i=0; i < PPCDBG_NUM_FLAGS; i++) {
 306                         if (((1U << i) & active_debugs) &&
 307                             trace_names[i]) {
 308                                 len += strlen(trace_names[i]);
 309                                 udbg_puts(trace_names[i]);
 310                                 break;
 311                         }
 312                 }
 313
 314                 snprintf(buf, UDBG_BUFSIZE, " [%s]: ", current->comm);
 315                 len += strlen(buf);
 316                 udbg_puts(buf);
 317
 318                 while (len < 18) {
 319                         udbg_puts(" ");
 320                         len++;
 321                 }
 322
 323                 va_start(ap, fmt);
 324                 vsnprintf(buf, UDBG_BUFSIZE, fmt, ap);
 325                 udbg_puts(buf);
 326                 va_end(ap);
 327         }
 328 }
 329
 330 unsigned long udbg_ifdebug(unsigned long flags)
 331 {
 332         return (flags & naca->debug_switch);
 333 }