arch/mn10300/kernel/gdb-io-ttysm.c

   1 /* MN10300 On-chip serial driver for gdbstub I/O
   2  *
   3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public Licence
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the Licence, or (at your option) any later version.
  10  */
  11 #include <linux/string.h>
  12 #include <linux/kernel.h>
  13 #include <linux/signal.h>
  14 #include <linux/sched.h>
  15 #include <linux/mm.h>
  16 #include <linux/console.h>
  17 #include <linux/init.h>
  18 #include <linux/tty.h>
  19 #include <asm/pgtable.h>
  20 #include <asm/system.h>
  21 #include <asm/gdb-stub.h>
  22 #include <asm/exceptions.h>
  23 #include <unit/clock.h>
  24 #include "mn10300-serial.h"
  25
  26 #if defined(CONFIG_GDBSTUB_ON_TTYSM0)
  27 struct mn10300_serial_port *const gdbstub_port = &mn10300_serial_port_sif0;
  28 #elif defined(CONFIG_GDBSTUB_ON_TTYSM1)
  29 struct mn10300_serial_port *const gdbstub_port = &mn10300_serial_port_sif1;
  30 #else
  31 struct mn10300_serial_port *const gdbstub_port = &mn10300_serial_port_sif2;
  32 #endif
  33
  34
  35 /*
  36  * initialise the GDB stub I/O routines
  37  */
  38 void __init gdbstub_io_init(void)
  39 {
  40         uint16_t scxctr;
  41         int tmp;
  42
  43         switch (gdbstub_port->clock_src) {
  44         case MNSCx_CLOCK_SRC_IOCLK:
  45                 gdbstub_port->ioclk = MN10300_IOCLK;
  46                 break;
  47
  48 #ifdef MN10300_IOBCLK
  49         case MNSCx_CLOCK_SRC_IOBCLK:
  50                 gdbstub_port->ioclk = MN10300_IOBCLK;
  51                 break;
  52 #endif
  53         default:
  54                 BUG();
  55         }
  56
  57         /* set up the serial port */
  58         gdbstub_io_set_baud(115200);
  59
  60         /* we want to get serial receive interrupts */
  61         set_intr_level(gdbstub_port->rx_irq,
  62                 NUM2GxICR_LEVEL(CONFIG_GDBSTUB_IRQ_LEVEL));
  63         set_intr_level(gdbstub_port->tx_irq,
  64                 NUM2GxICR_LEVEL(CONFIG_GDBSTUB_IRQ_LEVEL));
  65         set_intr_stub(NUM2EXCEP_IRQ_LEVEL(CONFIG_GDBSTUB_IRQ_LEVEL),
  66                 gdbstub_io_rx_handler);
  67
  68         *gdbstub_port->rx_icr |= GxICR_ENABLE;
  69         tmp = *gdbstub_port->rx_icr;
  70
  71         /* enable the device */
  72         scxctr = SC01CTR_CLN_8BIT;      /* 1N8 */
  73         switch (gdbstub_port->div_timer) {
  74         case MNSCx_DIV_TIMER_16BIT:
  75                 scxctr |= SC0CTR_CK_TM8UFLOW_8; /* == SC1CTR_CK_TM9UFLOW_8
  76                                                    == SC2CTR_CK_TM10UFLOW_8 */
  77                 break;
  78
  79         case MNSCx_DIV_TIMER_8BIT:
  80                 scxctr |= SC0CTR_CK_TM2UFLOW_8;
  81                 break;
  82         }
  83
  84         scxctr |= SC01CTR_TXE | SC01CTR_RXE;
  85
  86         *gdbstub_port->_control = scxctr;
  87         tmp = *gdbstub_port->_control;
  88
  89         /* permit level 0 IRQs only */
  90         local_change_intr_mask_level(NUM2EPSW_IM(CONFIG_GDBSTUB_IRQ_LEVEL + 1));
  91 }
  92
  93 /*
  94  * set up the GDB stub serial port baud rate timers
  95  */
  96 void gdbstub_io_set_baud(unsigned baud)
  97 {
  98         const unsigned bits = 10; /* 1 [start] + 8 [data] + 0 [parity] +
  99                                    * 1 [stop] */
 100         unsigned long ioclk = gdbstub_port->ioclk;
 101         unsigned xdiv, tmp;
 102         uint16_t tmxbr;
 103         uint8_t tmxmd;
 104
 105         if (!baud) {
 106                 baud = 9600;
 107         } else if (baud == 134) {
 108                 baud = 269;     /* 134 is really 134.5 */
 109                 xdiv = 2;
 110         }
 111
 112 try_alternative:
 113         xdiv = 1;
 114
 115         switch (gdbstub_port->div_timer) {
 116         case MNSCx_DIV_TIMER_16BIT:
 117                 tmxmd = TM8MD_SRC_IOCLK;
 118                 tmxbr = tmp = (ioclk / (baud * xdiv) + 4) / 8 - 1;
 119                 if (tmp > 0 && tmp <= 65535)
 120                         goto timer_okay;
 121
 122                 tmxmd = TM8MD_SRC_IOCLK_8;
 123                 tmxbr = tmp = (ioclk / (baud * 8 * xdiv) + 4) / 8 - 1;
 124                 if (tmp > 0 && tmp <= 65535)
 125                         goto timer_okay;
 126
 127                 tmxmd = TM8MD_SRC_IOCLK_32;
 128                 tmxbr = tmp = (ioclk / (baud * 32 * xdiv) + 4) / 8 - 1;
 129                 if (tmp > 0 && tmp <= 65535)
 130                         goto timer_okay;
 131
 132                 break;
 133
 134         case MNSCx_DIV_TIMER_8BIT:
 135                 tmxmd = TM2MD_SRC_IOCLK;
 136                 tmxbr = tmp = (ioclk / (baud * xdiv) + 4) / 8 - 1;
 137                 if (tmp > 0 && tmp <= 255)
 138                         goto timer_okay;
 139
 140                 tmxmd = TM2MD_SRC_IOCLK_8;
 141                 tmxbr = tmp = (ioclk / (baud * 8 * xdiv) + 4) / 8 - 1;
 142                 if (tmp > 0 && tmp <= 255)
 143                         goto timer_okay;
 144
 145                 tmxmd = TM2MD_SRC_IOCLK_32;
 146                 tmxbr = tmp = (ioclk / (baud * 32 * xdiv) + 4) / 8 - 1;
 147                 if (tmp > 0 && tmp <= 255)
 148                         goto timer_okay;
 149                 break;
 150         }
 151
 152         /* as a last resort, if the quotient is zero, default to 9600 bps */
 153         baud = 9600;
 154         goto try_alternative;
 155
 156 timer_okay:
 157         gdbstub_port->uart.timeout = (2 * bits * HZ) / baud;
 158         gdbstub_port->uart.timeout += HZ / 50;
 159
 160         /* set the timer to produce the required baud rate */
 161         switch (gdbstub_port->div_timer) {
 162         case MNSCx_DIV_TIMER_16BIT:
 163                 *gdbstub_port->_tmxmd = 0;
 164                 *gdbstub_port->_tmxbr = tmxbr;
 165                 *gdbstub_port->_tmxmd = TM8MD_INIT_COUNTER;
 166                 *gdbstub_port->_tmxmd = tmxmd | TM8MD_COUNT_ENABLE;
 167                 break;
 168
 169         case MNSCx_DIV_TIMER_8BIT:
 170                 *gdbstub_port->_tmxmd = 0;
 171                 *(volatile u8 *) gdbstub_port->_tmxbr = (u8)tmxbr;
 172                 *gdbstub_port->_tmxmd = TM2MD_INIT_COUNTER;
 173                 *gdbstub_port->_tmxmd = tmxmd | TM2MD_COUNT_ENABLE;
 174                 break;
 175         }
 176 }
 177
 178 /*
 179  * wait for a character to come from the debugger
 180  */
 181 int gdbstub_io_rx_char(unsigned char *_ch, int nonblock)
 182 {
 183         unsigned ix;
 184         u8 ch, st;
 185 #if defined(CONFIG_MN10300_WD_TIMER)
 186         int cpu;
 187 #endif
 188
 189         *_ch = 0xff;
 190
 191         if (gdbstub_rx_unget) {
 192                 *_ch = gdbstub_rx_unget;
 193                 gdbstub_rx_unget = 0;
 194                 return 0;
 195         }
 196
 197 try_again:
 198         /* pull chars out of the buffer */
 199         ix = gdbstub_rx_outp;
 200         barrier();
 201         if (ix == gdbstub_rx_inp) {
 202                 if (nonblock)
 203                         return -EAGAIN;
 204 #ifdef CONFIG_MN10300_WD_TIMER
 205         for (cpu = 0; cpu < NR_CPUS; cpu++)
 206                 watchdog_alert_counter[cpu] = 0;
 207 #endif
 208                 goto try_again;
 209         }
 210
 211         ch = gdbstub_rx_buffer[ix++];
 212         st = gdbstub_rx_buffer[ix++];
 213         barrier();
 214         gdbstub_rx_outp = ix & (PAGE_SIZE - 1);
 215
 216         st &= SC01STR_RXF | SC01STR_RBF | SC01STR_FEF | SC01STR_PEF |
 217                 SC01STR_OEF;
 218
 219         /* deal with what we've got
 220          * - note that the UART doesn't do BREAK-detection for us
 221          */
 222         if (st & SC01STR_FEF && ch == 0) {
 223                 switch (gdbstub_port->rx_brk) {
 224                 case 0: gdbstub_port->rx_brk = 1;       goto try_again;
 225                 case 1: gdbstub_port->rx_brk = 2;       goto try_again;
 226                 case 2:
 227                         gdbstub_port->rx_brk = 3;
 228                         gdbstub_proto("### GDB MNSERIAL Rx Break Detected"
 229                                       " ###\n");
 230                         return -EINTR;
 231                 default:
 232                         goto try_again;
 233                 }
 234         } else if (st & SC01STR_FEF) {
 235                 if (gdbstub_port->rx_brk)
 236                         goto try_again;
 237
 238                 gdbstub_proto("### GDB MNSERIAL Framing Error ###\n");
 239                 return -EIO;
 240         } else if (st & SC01STR_OEF) {
 241                 if (gdbstub_port->rx_brk)
 242                         goto try_again;
 243
 244                 gdbstub_proto("### GDB MNSERIAL Overrun Error ###\n");
 245                 return -EIO;
 246         } else if (st & SC01STR_PEF) {
 247                 if (gdbstub_port->rx_brk)
 248                         goto try_again;
 249
 250                 gdbstub_proto("### GDB MNSERIAL Parity Error ###\n");
 251                 return -EIO;
 252         } else {
 253                 /* look for the tail-end char on a break run */
 254                 if (gdbstub_port->rx_brk == 3) {
 255                         switch (ch) {
 256                         case 0xFF:
 257                         case 0xFE:
 258                         case 0xFC:
 259                         case 0xF8:
 260                         case 0xF0:
 261                         case 0xE0:
 262                         case 0xC0:
 263                         case 0x80:
 264                         case 0x00:
 265                                 gdbstub_port->rx_brk = 0;
 266                                 goto try_again;
 267                         default:
 268                                 break;
 269                         }
 270                 }
 271
 272                 gdbstub_port->rx_brk = 0;
 273                 gdbstub_io("### GDB Rx %02x (st=%02x) ###\n", ch, st);
 274                 *_ch = ch & 0x7f;
 275                 return 0;
 276         }
 277 }
 278
 279 /*
 280  * send a character to the debugger
 281  */
 282 void gdbstub_io_tx_char(unsigned char ch)
 283 {
 284         while (*gdbstub_port->_status & SC01STR_TBF)
 285                 continue;
 286
 287         if (ch == 0x0a) {
 288                 *(u8 *) gdbstub_port->_txb = 0x0d;
 289                 while (*gdbstub_port->_status & SC01STR_TBF)
 290                         continue;
 291         }
 292
 293         *(u8 *) gdbstub_port->_txb = ch;
 294 }
 295
 296 /*
 297  * flush the transmission buffers
 298  */
 299 void gdbstub_io_tx_flush(void)
 300 {
 301         while (*gdbstub_port->_status & (SC01STR_TBF | SC01STR_TXF))
 302                 continue;
 303 }