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         unsigned long addr;
  88         int i, x;
  89
  90         if (np == NULL)
  91                 np = of_find_node_by_name(NULL, "escc");
  92         if (np == NULL)
  93                 return;
  94
  95         /* Lock-enable the SCC channel */
  96         pmac_call_feature(PMAC_FTR_SCC_ENABLE, np, PMAC_SCC_ASYNC | PMAC_SCC_FLAG_XMON, 1);
  97
  98         /* Setup for 57600 8N1 */
  99         addr = np->addrs[0].address + 0x20;
 100         sccc = (volatile u8 *) ioremap(addr & PAGE_MASK, PAGE_SIZE) ;
 101         sccc += addr & ~PAGE_MASK;
 102         sccd = sccc + 0x10;
 103
 104         for (i = 20000; i != 0; --i)
 105                 x = *sccc; eieio();
 106         *sccc = 9; eieio();             /* reset A or B side */
 107         *sccc = 0xc0; eieio();
 108         for (i = 0; i < sizeof(scc_inittab); ++i) {
 109                 *sccc = scc_inittab[i];
 110                 eieio();
 111         }
 112
 113         ppc_md.udbg_putc = udbg_putc;
 114         ppc_md.udbg_getc = udbg_getc;
 115         ppc_md.udbg_getc_poll = udbg_getc_poll;
 116
 117         udbg_puts("Hello World !\n");
 118 }
 119
 120 #endif /* CONFIG_PPC_PMAC */
 121
 122 void udbg_putc(unsigned char c)
 123 {
 124         if (udbg_comport) {
 125                 while ((udbg_comport->lsr & LSR_THRE) == 0)
 126                         /* wait for idle */;
 127                 udbg_comport->thr = c; eieio();
 128                 if (c == '\n') {
 129                         /* Also put a CR.  This is for convenience. */
 130                         while ((udbg_comport->lsr & LSR_THRE) == 0)
 131                                 /* wait for idle */;
 132                         udbg_comport->thr = '\r'; eieio();
 133                 }
 134         }
 135 #ifdef CONFIG_PPC_PMAC
 136         else if (sccc) {
 137                 while ((*sccc & SCC_TXRDY) == 0)
 138                         eieio();
 139                 *sccd = c;
 140                 eieio();
 141                 if (c == '\n')
 142                         udbg_putc('\r');
 143         }
 144 #endif /* CONFIG_PPC_PMAC */
 145 }
 146
 147 int udbg_getc_poll(void)
 148 {
 149         if (udbg_comport) {
 150                 if ((udbg_comport->lsr & LSR_DR) != 0)
 151                         return udbg_comport->rbr;
 152                 else
 153                         return -1;
 154         }
 155 #ifdef CONFIG_PPC_PMAC
 156         else if (sccc) {
 157                 eieio();
 158                 if ((*sccc & SCC_RXRDY) != 0)
 159                         return *sccd;
 160                 else
 161                         return -1;
 162         }
 163 #endif /* CONFIG_PPC_PMAC */
 164         return -1;
 165 }
 166
 167 unsigned char udbg_getc(void)
 168 {
 169         if (udbg_comport) {
 170                 while ((udbg_comport->lsr & LSR_DR) == 0)
 171                         /* wait for char */;
 172                 return udbg_comport->rbr;
 173         }
 174 #ifdef CONFIG_PPC_PMAC
 175         else if (sccc) {
 176                 eieio();
 177                 while ((*sccc & SCC_RXRDY) == 0)
 178                         eieio();
 179                 return *sccd;
 180         }
 181 #endif /* CONFIG_PPC_PMAC */
 182         return 0;
 183 }
 184
 185 void udbg_puts(const char *s)
 186 {
 187         if (ppc_md.udbg_putc) {
 188                 char c;
 189
 190                 if (s && *s != '\0') {
 191                         while ((c = *s++) != '\0')
 192                                 ppc_md.udbg_putc(c);
 193                 }
 194         } else {
 195                 printk("%s", s);
 196         }
 197 }
 198
 199 int udbg_write(const char *s, int n)
 200 {
 201         int remain = n;
 202         char c;
 203
 204         if (!ppc_md.udbg_putc)
 205                 return 0;
 206
 207         if (s && *s != '\0') {
 208                 while (((c = *s++) != '\0') && (remain-- > 0)) {
 209                         ppc_md.udbg_putc(c);
 210                 }
 211         }
 212
 213         return n - remain;
 214 }
 215
 216 int udbg_read(char *buf, int buflen)
 217 {
 218         char c, *p = buf;
 219         int i;
 220
 221         if (!ppc_md.udbg_putc)
 222                 return 0;
 223
 224         for (i = 0; i < buflen; ++i) {
 225                 do {
 226                         c = ppc_md.udbg_getc();
 227                 } while (c == 0x11 || c == 0x13);
 228                 if (c == 0)
 229                         break;
 230                 *p++ = c;
 231         }
 232
 233         return i;
 234 }
 235
 236 void udbg_console_write(struct console *con, const char *s, unsigned int n)
 237 {
 238         udbg_write(s, n);
 239 }
 240
 241 #define UDBG_BUFSIZE 256
 242 void udbg_printf(const char *fmt, ...)
 243 {
 244         unsigned char buf[UDBG_BUFSIZE];
 245         va_list args;
 246
 247         va_start(args, fmt);
 248         vsnprintf(buf, UDBG_BUFSIZE, fmt, args);
 249         udbg_puts(buf);
 250         va_end(args);
 251 }
 252
 253 /* Special print used by PPCDBG() macro */
 254 void udbg_ppcdbg(unsigned long debug_flags, const char *fmt, ...)
 255 {
 256         unsigned long active_debugs = debug_flags & naca->debug_switch;
 257
 258         if (active_debugs) {
 259                 va_list ap;
 260                 unsigned char buf[UDBG_BUFSIZE];
 261                 unsigned long i, len = 0;
 262
 263                 for (i=0; i < PPCDBG_NUM_FLAGS; i++) {
 264                         if (((1U << i) & active_debugs) &&
 265                             trace_names[i]) {
 266                                 len += strlen(trace_names[i]);
 267                                 udbg_puts(trace_names[i]);
 268                                 break;
 269                         }
 270                 }
 271
 272                 snprintf(buf, UDBG_BUFSIZE, " [%s]: ", current->comm);
 273                 len += strlen(buf);
 274                 udbg_puts(buf);
 275
 276                 while (len < 18) {
 277                         udbg_puts(" ");
 278                         len++;
 279                 }
 280
 281                 va_start(ap, fmt);
 282                 vsnprintf(buf, UDBG_BUFSIZE, fmt, ap);
 283                 udbg_puts(buf);
 284                 va_end(ap);
 285         }
 286 }
 287
 288 unsigned long udbg_ifdebug(unsigned long flags)
 289 {
 290         return (flags & naca->debug_switch);
 291 }