release/src-rt-6.x/linux/linux-2.6/arch/cris/arch-v32/kernel/debugport.c

   1 /*
   2  * Copyright (C) 2003, Axis Communications AB.
   3  */
   4
   5 #include <linux/console.h>
   6 #include <linux/init.h>
   7 #include <linux/major.h>
   8 #include <linux/delay.h>
   9 #include <linux/tty.h>
  10 #include <asm/system.h>
  11 #include <asm/io.h>
  12 #include <asm/arch/hwregs/ser_defs.h>
  13 #include <asm/arch/hwregs/dma_defs.h>
  14 #include <asm/arch/pinmux.h>
  15
  16 #include <asm/irq.h>
  17 #include <asm/arch/hwregs/intr_vect_defs.h>
  18
  19 struct dbg_port
  20 {
  21         unsigned char nbr;
  22         unsigned long instance;
  23         unsigned int started;
  24         unsigned long baudrate;
  25         unsigned char parity;
  26         unsigned int bits;
  27 };
  28
  29 struct dbg_port ports[] =
  30 {
  31   {
  32     0,
  33     regi_ser0,
  34     0,
  35     115200,
  36     'N',
  37     8
  38   },
  39   {
  40     1,
  41     regi_ser1,
  42     0,
  43     115200,
  44     'N',
  45     8
  46   },
  47   {
  48     2,
  49     regi_ser2,
  50     0,
  51     115200,
  52     'N',
  53     8
  54   },
  55   {
  56     3,
  57     regi_ser3,
  58     0,
  59     115200,
  60     'N',
  61     8
  62   }
  63 };
  64 static struct dbg_port *port =
  65 #if defined(CONFIG_ETRAX_DEBUG_PORT0)
  66 &ports[0];
  67 #elif defined(CONFIG_ETRAX_DEBUG_PORT1)
  68 &ports[1];
  69 #elif defined(CONFIG_ETRAX_DEBUG_PORT2)
  70 &ports[2];
  71 #elif defined(CONFIG_ETRAX_DEBUG_PORT3)
  72 &ports[3];
  73 #else
  74 NULL;
  75 #endif
  76
  77 #ifdef CONFIG_ETRAX_KGDB
  78 static struct dbg_port *kgdb_port =
  79 #if defined(CONFIG_ETRAX_KGDB_PORT0)
  80 &ports[0];
  81 #elif defined(CONFIG_ETRAX_KGDB_PORT1)
  82 &ports[1];
  83 #elif defined(CONFIG_ETRAX_KGDB_PORT2)
  84 &ports[2];
  85 #elif defined(CONFIG_ETRAX_KGDB_PORT3)
  86 &ports[3];
  87 #else
  88 NULL;
  89 #endif
  90 #endif
  91
  92 #ifdef CONFIG_ETRAXFS_SIM
  93 extern void print_str( const char *str );
  94 static char buffer[1024];
  95 static char msg[] = "Debug: ";
  96 static int buffer_pos = sizeof(msg) - 1;
  97 #endif
  98
  99 extern struct tty_driver *serial_driver;
 100
 101 static void
 102 start_port(struct dbg_port* p)
 103 {
 104         if (!p)
 105                 return;
 106
 107         if (p->started)
 108                 return;
 109         p->started = 1;
 110
 111         if (p->nbr == 1)
 112                 crisv32_pinmux_alloc_fixed(pinmux_ser1);
 113         else if (p->nbr == 2)
 114                 crisv32_pinmux_alloc_fixed(pinmux_ser2);
 115         else if (p->nbr == 3)
 116                 crisv32_pinmux_alloc_fixed(pinmux_ser3);
 117
 118         /* Set up serial port registers */
 119         reg_ser_rw_tr_ctrl tr_ctrl = {0};
 120         reg_ser_rw_tr_dma_en tr_dma_en = {0};
 121
 122         reg_ser_rw_rec_ctrl rec_ctrl = {0};
 123         reg_ser_rw_tr_baud_div tr_baud_div = {0};
 124         reg_ser_rw_rec_baud_div rec_baud_div = {0};
 125
 126         tr_ctrl.base_freq = rec_ctrl.base_freq = regk_ser_f29_493;
 127         tr_dma_en.en = rec_ctrl.dma_mode = regk_ser_no;
 128         tr_baud_div.div = rec_baud_div.div = 29493000 / p->baudrate / 8;
 129         tr_ctrl.en = rec_ctrl.en = 1;
 130
 131         if (p->parity == 'O')
 132         {
 133                 tr_ctrl.par_en = regk_ser_yes;
 134                 tr_ctrl.par = regk_ser_odd;
 135                 rec_ctrl.par_en = regk_ser_yes;
 136                 rec_ctrl.par = regk_ser_odd;
 137         }
 138         else if (p->parity == 'E')
 139         {
 140                 tr_ctrl.par_en = regk_ser_yes;
 141                 tr_ctrl.par = regk_ser_even;
 142                 rec_ctrl.par_en = regk_ser_yes;
 143                 rec_ctrl.par = regk_ser_odd;
 144         }
 145
 146         if (p->bits == 7)
 147         {
 148                 tr_ctrl.data_bits = regk_ser_bits7;
 149                 rec_ctrl.data_bits = regk_ser_bits7;
 150         }
 151
 152         REG_WR (ser, p->instance, rw_tr_baud_div, tr_baud_div);
 153         REG_WR (ser, p->instance, rw_rec_baud_div, rec_baud_div);
 154         REG_WR (ser, p->instance, rw_tr_dma_en, tr_dma_en);
 155         REG_WR (ser, p->instance, rw_tr_ctrl, tr_ctrl);
 156         REG_WR (ser, p->instance, rw_rec_ctrl, rec_ctrl);
 157 }
 158
 159 /* No debug */
 160 #ifdef CONFIG_ETRAX_DEBUG_PORT_NULL
 161
 162 static void
 163 console_write(struct console *co, const char *buf, unsigned int len)
 164 {
 165         return;
 166 }
 167
 168 /* Target debug */
 169 #elif !defined(CONFIG_ETRAXFS_SIM)
 170
 171 static void
 172 console_write_direct(struct console *co, const char *buf, unsigned int len)
 173 {
 174         int i;
 175         reg_ser_r_stat_din stat;
 176         reg_ser_rw_tr_dma_en tr_dma_en, old;
 177
 178         /* Switch to manual mode */
 179         tr_dma_en = old = REG_RD (ser, port->instance, rw_tr_dma_en);
 180         if (tr_dma_en.en == regk_ser_yes) {
 181                 tr_dma_en.en = regk_ser_no;
 182                 REG_WR(ser, port->instance, rw_tr_dma_en, tr_dma_en);
 183         }
 184
 185         /* Send data */
 186         for (i = 0; i < len; i++) {
 187                 /* LF -> CRLF */
 188                 if (buf[i] == '\n') {
 189                         do {
 190                                 stat = REG_RD (ser, port->instance, r_stat_din);
 191                         } while (!stat.tr_rdy);
 192                         REG_WR_INT (ser, port->instance, rw_dout, '\r');
 193                 }
 194                 /* Wait until transmitter is ready and send.*/
 195                 do {
 196                         stat = REG_RD (ser, port->instance, r_stat_din);
 197                 } while (!stat.tr_rdy);
 198                 REG_WR_INT (ser, port->instance, rw_dout, buf[i]);
 199         }
 200
 201         /* Restore mode */
 202         if (tr_dma_en.en != old.en)
 203                 REG_WR(ser, port->instance, rw_tr_dma_en, old);
 204 }
 205
 206 static void
 207 console_write(struct console *co, const char *buf, unsigned int len)
 208 {
 209         if (!port)
 210                 return;
 211         console_write_direct(co, buf, len);
 212 }
 213
 214
 215
 216 #else
 217
 218 /* VCS debug */
 219
 220 static void
 221 console_write(struct console *co, const char *buf, unsigned int len)
 222 {
 223         char* pos;
 224         pos = memchr(buf, '\n', len);
 225         if (pos) {
 226                 int l = ++pos - buf;
 227                 memcpy(buffer + buffer_pos, buf, l);
 228                 memcpy(buffer, msg, sizeof(msg) - 1);
 229                 buffer[buffer_pos + l] = '\0';
 230                 print_str(buffer);
 231                 buffer_pos = sizeof(msg) - 1;
 232                 if (pos - buf != len) {
 233                         memcpy(buffer + buffer_pos, pos, len - l);
 234                         buffer_pos += len - l;
 235                 }
 236         } else {
 237                 memcpy(buffer + buffer_pos, buf, len);
 238                 buffer_pos += len;
 239         }
 240 }
 241
 242 #endif
 243
 244 int raw_printk(const char *fmt, ...)
 245 {
 246         static char buf[1024];
 247         int printed_len;
 248         va_list args;
 249         va_start(args, fmt);
 250         printed_len = vsnprintf(buf, sizeof(buf), fmt, args);
 251         va_end(args);
 252         console_write(NULL, buf, strlen(buf));
 253         return printed_len;
 254 }
 255
 256 void
 257 stupid_debug(char* buf)
 258 {
 259   console_write(NULL, buf, strlen(buf));
 260 }
 261
 262 #ifdef CONFIG_ETRAX_KGDB
 263 /* Use polling to get a single character from the kernel debug port */
 264 int
 265 getDebugChar(void)
 266 {
 267         reg_ser_rs_status_data stat;
 268         reg_ser_rw_ack_intr ack_intr = { 0 };
 269
 270         do {
 271                 stat = REG_RD(ser, kgdb_instance, rs_status_data);
 272         } while (!stat.data_avail);
 273
 274         /* Ack the data_avail interrupt. */
 275         ack_intr.data_avail = 1;
 276         REG_WR(ser, kgdb_instance, rw_ack_intr, ack_intr);
 277
 278         return stat.data;
 279 }
 280
 281 /* Use polling to put a single character to the kernel debug port */
 282 void
 283 putDebugChar(int val)
 284 {
 285         reg_ser_r_status_data stat;
 286         do {
 287                 stat = REG_RD (ser, kgdb_instance, r_status_data);
 288         } while (!stat.tr_ready);
 289         REG_WR (ser, kgdb_instance, rw_data_out, REG_TYPE_CONV(reg_ser_rw_data_out, int, val));
 290 }
 291 #endif /* CONFIG_ETRAX_KGDB */
 292
 293 static int __init
 294 console_setup(struct console *co, char *options)
 295 {
 296         char* s;
 297
 298         if (options) {
 299                 port = &ports[co->index];
 300                 port->baudrate = 115200;
 301                 port->parity = 'N';
 302                 port->bits = 8;
 303                 port->baudrate = simple_strtoul(options, NULL, 10);
 304                 s = options;
 305                 while(*s >= '0' && *s <= '9')
 306                         s++;
 307                 if (*s) port->parity = *s++;
 308                 if (*s) port->bits   = *s++ - '0';
 309                 port->started = 0;
 310                 start_port(port);
 311         }
 312         return 0;
 313 }
 314
 315 /* This is a dummy serial device that throws away anything written to it.
 316  * This is used when no debug output is wanted.
 317  */
 318 static struct tty_driver dummy_driver;
 319
 320 static int dummy_open(struct tty_struct *tty, struct file * filp)
 321 {
 322         return 0;
 323 }
 324
 325 static void dummy_close(struct tty_struct *tty, struct file * filp)
 326 {
 327 }
 328
 329 static int dummy_write(struct tty_struct * tty,
 330                        const unsigned char *buf, int count)
 331 {
 332         return count;
 333 }
 334
 335 static int
 336 dummy_write_room(struct tty_struct *tty)
 337 {
 338         return 8192;
 339 }
 340
 341 void __init
 342 init_dummy_console(void)
 343 {
 344         memset(&dummy_driver, 0, sizeof(struct tty_driver));
 345         dummy_driver.driver_name = "serial";
 346         dummy_driver.name = "ttyS";
 347         dummy_driver.major = TTY_MAJOR;
 348         dummy_driver.minor_start = 68;
 349         dummy_driver.num = 1;       /* etrax100 has 4 serial ports */
 350         dummy_driver.type = TTY_DRIVER_TYPE_SERIAL;
 351         dummy_driver.subtype = SERIAL_TYPE_NORMAL;
 352         dummy_driver.init_termios = tty_std_termios;
 353         dummy_driver.init_termios.c_cflag =
 354                 B115200 | CS8 | CREAD | HUPCL | CLOCAL; /* is normally B9600 default... */
 355         dummy_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
 356
 357         dummy_driver.open = dummy_open;
 358         dummy_driver.close = dummy_close;
 359         dummy_driver.write = dummy_write;
 360         dummy_driver.write_room = dummy_write_room;
 361         if (tty_register_driver(&dummy_driver))
 362                 panic("Couldn't register dummy serial driver\n");
 363 }
 364
 365 static struct tty_driver*
 366 crisv32_console_device(struct console* co, int *index)
 367 {
 368         if (port)
 369                 *index = port->nbr;
 370         return port ? serial_driver : &dummy_driver;
 371 }
 372
 373 static struct console sercons = {
 374         name : "ttyS",
 375         write: console_write,
 376         read : NULL,
 377         device : crisv32_console_device,
 378         unblank : NULL,
 379         setup : console_setup,
 380         flags : CON_PRINTBUFFER,
 381         index : -1,
 382         cflag : 0,
 383         next : NULL
 384 };
 385 static struct console sercons0 = {
 386         name : "ttyS",
 387         write: console_write,
 388         read : NULL,
 389         device : crisv32_console_device,
 390         unblank : NULL,
 391         setup : console_setup,
 392         flags : CON_PRINTBUFFER,
 393         index : 0,
 394         cflag : 0,
 395         next : NULL
 396 };
 397
 398 static struct console sercons1 = {
 399         name : "ttyS",
 400         write: console_write,
 401         read : NULL,
 402         device : crisv32_console_device,
 403         unblank : NULL,
 404         setup : console_setup,
 405         flags : CON_PRINTBUFFER,
 406         index : 1,
 407         cflag : 0,
 408         next : NULL
 409 };
 410 static struct console sercons2 = {
 411         name : "ttyS",
 412         write: console_write,
 413         read : NULL,
 414         device : crisv32_console_device,
 415         unblank : NULL,
 416         setup : console_setup,
 417         flags : CON_PRINTBUFFER,
 418         index : 2,
 419         cflag : 0,
 420         next : NULL
 421 };
 422 static struct console sercons3 = {
 423         name : "ttyS",
 424         write: console_write,
 425         read : NULL,
 426         device : crisv32_console_device,
 427         unblank : NULL,
 428         setup : console_setup,
 429         flags : CON_PRINTBUFFER,
 430         index : 3,
 431         cflag : 0,
 432         next : NULL
 433 };
 434
 435 /* Register console for printk's, etc. */
 436 int __init
 437 init_etrax_debug(void)
 438 {
 439         static int first = 1;
 440
 441         if (!first) {
 442                 unregister_console(&sercons);
 443                 register_console(&sercons0);
 444                 register_console(&sercons1);
 445                 register_console(&sercons2);
 446                 register_console(&sercons3);
 447                 init_dummy_console();
 448                 return 0;
 449         }
 450         first = 0;
 451         register_console(&sercons);
 452         start_port(port);
 453
 454 #ifdef CONFIG_ETRAX_KGDB
 455         start_port(kgdb_port);
 456 #endif /* CONFIG_ETRAX_KGDB */
 457         return 0;
 458 }
 459
 460 __initcall(init_etrax_debug);