arch/cris/arch-v10/kernel/debugport.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Serialport functions for debugging
   3  *
   4  * Copyright (c) 2000-2007 Axis Communications AB
   5  *
   6  * Authors:  Bjorn Wesen
   7  *
   8  * Exports:
   9  *    console_print_etrax(char *buf)
  10  *    int getDebugChar()
  11  *    putDebugChar(int)
  12  *    enableDebugIRQ()
  13  *    init_etrax_debug()
  14  *
  15  */
  16
  17 #include <linux/console.h>
  18 #include <linux/init.h>
  19 #include <linux/major.h>
  20 #include <linux/delay.h>
  21 #include <linux/tty.h>
  22 #include <arch/svinto.h>
  23
  24 extern void reset_watchdog(void);
  25
  26 struct dbg_port
  27 {
  28   unsigned int index;
  29   const volatile unsigned* read;
  30   volatile char* write;
  31   volatile unsigned* xoff;
  32   volatile char* baud;
  33   volatile char* tr_ctrl;
  34   volatile char* rec_ctrl;
  35   unsigned long irq;
  36   unsigned int started;
  37   unsigned long baudrate;
  38   unsigned char parity;
  39   unsigned int bits;
  40 };
  41
  42 struct dbg_port ports[]=
  43 {
  44   {
  45     0,
  46     R_SERIAL0_READ,
  47     R_SERIAL0_TR_DATA,
  48     R_SERIAL0_XOFF,
  49     R_SERIAL0_BAUD,
  50     R_SERIAL0_TR_CTRL,
  51     R_SERIAL0_REC_CTRL,
  52     IO_STATE(R_IRQ_MASK1_SET, ser0_data, set),
  53     0,
  54     115200,
  55     'N',
  56     8
  57   },
  58   {
  59     1,
  60     R_SERIAL1_READ,
  61     R_SERIAL1_TR_DATA,
  62     R_SERIAL1_XOFF,
  63     R_SERIAL1_BAUD,
  64     R_SERIAL1_TR_CTRL,
  65     R_SERIAL1_REC_CTRL,
  66     IO_STATE(R_IRQ_MASK1_SET, ser1_data, set),
  67     0,
  68     115200,
  69     'N',
  70     8
  71   },
  72   {
  73     2,
  74     R_SERIAL2_READ,
  75     R_SERIAL2_TR_DATA,
  76     R_SERIAL2_XOFF,
  77     R_SERIAL2_BAUD,
  78     R_SERIAL2_TR_CTRL,
  79     R_SERIAL2_REC_CTRL,
  80     IO_STATE(R_IRQ_MASK1_SET, ser2_data, set),
  81     0,
  82     115200,
  83     'N',
  84     8
  85   },
  86   {
  87     3,
  88     R_SERIAL3_READ,
  89     R_SERIAL3_TR_DATA,
  90     R_SERIAL3_XOFF,
  91     R_SERIAL3_BAUD,
  92     R_SERIAL3_TR_CTRL,
  93     R_SERIAL3_REC_CTRL,
  94     IO_STATE(R_IRQ_MASK1_SET, ser3_data, set),
  95     0,
  96     115200,
  97     'N',
  98     8
  99   }
 100 };
 101
 102 #ifdef CONFIG_ETRAX_SERIAL
 103 extern struct tty_driver *serial_driver;
 104 #endif
 105
 106 struct dbg_port* port =
 107 #if defined(CONFIG_ETRAX_DEBUG_PORT0)
 108   &ports[0];
 109 #elif defined(CONFIG_ETRAX_DEBUG_PORT1)
 110   &ports[1];
 111 #elif defined(CONFIG_ETRAX_DEBUG_PORT2)
 112   &ports[2];
 113 #elif defined(CONFIG_ETRAX_DEBUG_PORT3)
 114   &ports[3];
 115 #else
 116   NULL;
 117 #endif
 118
 119 static struct dbg_port* kgdb_port =
 120 #if defined(CONFIG_ETRAX_KGDB_PORT0)
 121   &ports[0];
 122 #elif defined(CONFIG_ETRAX_KGDB_PORT1)
 123   &ports[1];
 124 #elif defined(CONFIG_ETRAX_KGDB_PORT2)
 125   &ports[2];
 126 #elif defined(CONFIG_ETRAX_KGDB_PORT3)
 127   &ports[3];
 128 #else
 129   NULL;
 130 #endif
 131
 132 static void
 133 start_port(struct dbg_port* p)
 134 {
 135         unsigned long rec_ctrl = 0;
 136         unsigned long tr_ctrl = 0;
 137
 138         if (!p)
 139                 return;
 140
 141         if (p->started)
 142                 return;
 143         p->started = 1;
 144
 145         if (p->index == 0)
 146         {
 147                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma6);
 148                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma6, unused);
 149         }
 150         else if (p->index == 1)
 151         {
 152                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma8);
 153                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma8, usb);
 154         }
 155         else if (p->index == 2)
 156         {
 157                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma2);
 158                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma2, par0);
 159                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma3);
 160                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma3, par0);
 161                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, ser2, select);
 162         }
 163         else
 164         {
 165                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma4);
 166                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma4, par1);
 167                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma5);
 168                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma5, par1);
 169                 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, ser3, select);
 170         }
 171
 172         *R_GEN_CONFIG = genconfig_shadow;
 173
 174         *p->xoff =
 175                 IO_STATE(R_SERIAL0_XOFF, tx_stop, enable) |
 176                 IO_STATE(R_SERIAL0_XOFF, auto_xoff, disable) |
 177                 IO_FIELD(R_SERIAL0_XOFF, xoff_char, 0);
 178
 179         switch (p->baudrate)
 180         {
 181         case 0:
 182         case 115200:
 183                 *p->baud =
 184                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) |
 185                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
 186                 break;
 187         case 1200:
 188                 *p->baud =
 189                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c1200Hz) |
 190                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c1200Hz);
 191                 break;
 192         case 2400:
 193                 *p->baud =
 194                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c2400Hz) |
 195                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c2400Hz);
 196                 break;
 197         case 4800:
 198                 *p->baud =
 199                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c4800Hz) |
 200                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c4800Hz);
 201                 break;
 202         case 9600:
 203                 *p->baud =
 204                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c9600Hz) |
 205                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c9600Hz);
 206                   break;
 207         case 19200:
 208                 *p->baud =
 209                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c19k2Hz) |
 210                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c19k2Hz);
 211                  break;
 212         case 38400:
 213                 *p->baud =
 214                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c38k4Hz) |
 215                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c38k4Hz);
 216                 break;
 217         case 57600:
 218                 *p->baud =
 219                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c57k6Hz) |
 220                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c57k6Hz);
 221                 break;
 222         default:
 223                 *p->baud =
 224                   IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) |
 225                   IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
 226                   break;
 227         }
 228
 229         if (p->parity == 'E') {
 230                 rec_ctrl =
 231                   IO_STATE(R_SERIAL0_REC_CTRL, rec_par, even) |
 232                   IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
 233                 tr_ctrl =
 234                   IO_STATE(R_SERIAL0_TR_CTRL, tr_par, even) |
 235                   IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
 236         } else if (p->parity == 'O') {
 237                 rec_ctrl =
 238                   IO_STATE(R_SERIAL0_REC_CTRL, rec_par, odd) |
 239                   IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
 240                 tr_ctrl =
 241                   IO_STATE(R_SERIAL0_TR_CTRL, tr_par, odd) |
 242                   IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
 243         } else {
 244                 rec_ctrl =
 245                   IO_STATE(R_SERIAL0_REC_CTRL, rec_par, even) |
 246                   IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, disable);
 247                 tr_ctrl =
 248                   IO_STATE(R_SERIAL0_TR_CTRL, tr_par, even) |
 249                   IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, disable);
 250         }
 251         if (p->bits == 7)
 252         {
 253                 rec_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_7bit);
 254                 tr_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_7bit);
 255         }
 256         else
 257         {
 258                 rec_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_8bit);
 259                 tr_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_8bit);
 260         }
 261
 262         *p->rec_ctrl =
 263                 IO_STATE(R_SERIAL0_REC_CTRL, dma_err, stop) |
 264                 IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable) |
 265                 IO_STATE(R_SERIAL0_REC_CTRL, rts_, active) |
 266                 IO_STATE(R_SERIAL0_REC_CTRL, sampling, middle) |
 267                 IO_STATE(R_SERIAL0_REC_CTRL, rec_stick_par, normal) |
 268                 rec_ctrl;
 269
 270         *p->tr_ctrl =
 271                 IO_FIELD(R_SERIAL0_TR_CTRL, txd, 0) |
 272                 IO_STATE(R_SERIAL0_TR_CTRL, tr_enable, enable) |
 273                 IO_STATE(R_SERIAL0_TR_CTRL, auto_cts, disabled) |
 274                 IO_STATE(R_SERIAL0_TR_CTRL, stop_bits, one_bit) |
 275                 IO_STATE(R_SERIAL0_TR_CTRL, tr_stick_par, normal) |
 276                 tr_ctrl;
 277 }
 278
 279 static void
 280 console_write_direct(struct console *co, const char *buf, unsigned int len)
 281 {
 282         int i;
 283         unsigned long flags;
 284
 285         if (!port)
 286                 return;
 287
 288         local_irq_save(flags);
 289
 290         /* Send data */
 291         for (i = 0; i < len; i++) {
 292                 /* LF -> CRLF */
 293                 if (buf[i] == '\n') {
 294                         while (!(*port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
 295                         ;
 296                         *port->write = '\r';
 297                 }
 298                 /* Wait until transmitter is ready and send.*/
 299                 while (!(*port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
 300                         ;
 301                 *port->write = buf[i];
 302         }
 303
 304         /*
 305          * Feed the watchdog, otherwise it will reset the chip during boot.
 306          * The time to send an ordinary boot message line (10-90 chars)
 307          * varies between 1-8ms at 115200. What makes up for the additional
 308          * 90ms that allows the watchdog to bite?
 309         */
 310         reset_watchdog();
 311
 312         local_irq_restore(flags);
 313 }
 314
 315 static void
 316 console_write(struct console *co, const char *buf, unsigned int len)
 317 {
 318         if (!port)
 319                 return;
 320
 321         console_write_direct(co, buf, len);
 322 }
 323
 324 /* legacy function */
 325
 326 void
 327 console_print_etrax(const char *buf)
 328 {
 329         console_write(NULL, buf, strlen(buf));
 330 }
 331
 332 /* Use polling to get a single character FROM the debug port */
 333
 334 int
 335 getDebugChar(void)
 336 {
 337         unsigned long readval;
 338
 339         if (!kgdb_port)
 340                 return 0;
 341
 342         do {
 343                 readval = *kgdb_port->read;
 344         } while (!(readval & IO_MASK(R_SERIAL0_READ, data_avail)));
 345
 346         return (readval & IO_MASK(R_SERIAL0_READ, data_in));
 347 }
 348
 349 /* Use polling to put a single character to the debug port */
 350
 351 void
 352 putDebugChar(int val)
 353 {
 354         if (!kgdb_port)
 355                 return;
 356
 357         while (!(*kgdb_port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
 358                 ;
 359         *kgdb_port->write = val;
 360 }
 361
 362 /* Enable irq for receiving chars on the debug port, used by kgdb */
 363
 364 void
 365 enableDebugIRQ(void)
 366 {
 367         if (!kgdb_port)
 368                 return;
 369
 370         *R_IRQ_MASK1_SET = kgdb_port->irq;
 371         /* use R_VECT_MASK directly, since we really bypass Linux normal
 372          * IRQ handling in kgdb anyway, we don't need to use enable_irq
 373          */
 374         *R_VECT_MASK_SET = IO_STATE(R_VECT_MASK_SET, serial, set);
 375
 376         *kgdb_port->rec_ctrl = IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable);
 377 }
 378
 379 static int __init
 380 console_setup(struct console *co, char *options)
 381 {
 382         char* s;
 383
 384         if (options) {
 385                 port = &ports[co->index];
 386                 port->baudrate = 115200;
 387                 port->parity = 'N';
 388                 port->bits = 8;
 389                 port->baudrate = simple_strtoul(options, NULL, 10);
 390                 s = options;
 391                 while(*s >= '0' && *s <= '9')
 392                         s++;
 393                 if (*s) port->parity = *s++;
 394                 if (*s) port->bits   = *s++ - '0';
 395                 port->started = 0;
 396                 start_port(0);
 397         }
 398         return 0;
 399 }
 400
 401
 402 /* This is a dummy serial device that throws away anything written to it.
 403  * This is used when no debug output is wanted.
 404  */
 405 static struct tty_driver dummy_driver;
 406
 407 static int dummy_open(struct tty_struct *tty, struct file * filp)
 408 {
 409         return 0;
 410 }
 411
 412 static void dummy_close(struct tty_struct *tty, struct file * filp)
 413 {
 414 }
 415
 416 static int dummy_write(struct tty_struct * tty,
 417                        const unsigned char *buf, int count)
 418 {
 419         return count;
 420 }
 421
 422 static int dummy_write_room(struct tty_struct *tty)
 423 {
 424         return 8192;
 425 }
 426
 427 static const struct tty_operations dummy_ops = {
 428         .open = dummy_open,
 429         .close = dummy_close,
 430         .write = dummy_write,
 431         .write_room = dummy_write_room,
 432 };
 433
 434 void __init
 435 init_dummy_console(void)
 436 {
 437         memset(&dummy_driver, 0, sizeof(struct tty_driver));
 438         dummy_driver.driver_name = "serial";
 439         dummy_driver.name = "ttyS";
 440         dummy_driver.major = TTY_MAJOR;
 441         dummy_driver.minor_start = 68;
 442         dummy_driver.num = 1;       /* etrax100 has 4 serial ports */
 443         dummy_driver.type = TTY_DRIVER_TYPE_SERIAL;
 444         dummy_driver.subtype = SERIAL_TYPE_NORMAL;
 445         dummy_driver.init_termios = tty_std_termios;
 446         /* Normally B9600 default... */
 447         dummy_driver.init_termios.c_cflag =
 448                 B115200 | CS8 | CREAD | HUPCL | CLOCAL;
 449         dummy_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
 450         dummy_driver.init_termios.c_ispeed = 115200;
 451         dummy_driver.init_termios.c_ospeed = 115200;
 452
 453         dummy_driver.ops = &dummy_ops;
 454         if (tty_register_driver(&dummy_driver))
 455                 panic("Couldn't register dummy serial driver\n");
 456 }
 457
 458 static struct tty_driver*
 459 etrax_console_device(struct console* co, int *index)
 460 {
 461         if (port)
 462                 *index = port->index;
 463         else
 464                 *index = 0;
 465 #ifdef CONFIG_ETRAX_SERIAL
 466         return port ? serial_driver : &dummy_driver;
 467 #else
 468         return &dummy_driver;
 469 #endif
 470 }
 471
 472 static struct console ser_console = {
 473         name : "ttyS",
 474         write: console_write,
 475         read : NULL,
 476         device : etrax_console_device,
 477         unblank : NULL,
 478         setup : console_setup,
 479         flags : CON_PRINTBUFFER,
 480         index : -1,
 481         cflag : 0,
 482         next : NULL
 483 };
 484 static struct console ser0_console = {
 485         name : "ttyS",
 486         write: console_write,
 487         read : NULL,
 488         device : etrax_console_device,
 489         unblank : NULL,
 490         setup : console_setup,
 491         flags : CON_PRINTBUFFER,
 492         index : 0,
 493         cflag : 0,
 494         next : NULL
 495 };
 496
 497 static struct console ser1_console = {
 498         name : "ttyS",
 499         write: console_write,
 500         read : NULL,
 501         device : etrax_console_device,
 502         unblank : NULL,
 503         setup : console_setup,
 504         flags : CON_PRINTBUFFER,
 505         index : 1,
 506         cflag : 0,
 507         next : NULL
 508 };
 509 static struct console ser2_console = {
 510         name : "ttyS",
 511         write: console_write,
 512         read : NULL,
 513         device : etrax_console_device,
 514         unblank : NULL,
 515         setup : console_setup,
 516         flags : CON_PRINTBUFFER,
 517         index : 2,
 518         cflag : 0,
 519         next : NULL
 520 };
 521 static struct console ser3_console = {
 522         name : "ttyS",
 523         write: console_write,
 524         read : NULL,
 525         device : etrax_console_device,
 526         unblank : NULL,
 527         setup : console_setup,
 528         flags : CON_PRINTBUFFER,
 529         index : 3,
 530         cflag : 0,
 531         next : NULL
 532 };
 533 /*
 534  *      Register console (for printk's etc)
 535  */
 536
 537 int __init
 538 init_etrax_debug(void)
 539 {
 540         static int first = 1;
 541
 542         if (!first) {
 543                 unregister_console(&ser_console);
 544                 register_console(&ser0_console);
 545                 register_console(&ser1_console);
 546                 register_console(&ser2_console);
 547                 register_console(&ser3_console);
 548                 init_dummy_console();
 549                 return 0;
 550         }
 551
 552         first = 0;
 553         register_console(&ser_console);
 554         start_port(port);
 555 #ifdef CONFIG_ETRAX_KGDB
 556         start_port(kgdb_port);
 557 #endif
 558         return 0;
 559 }
 560 __initcall(init_etrax_debug);