drivers/tty/serial/mux.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3 ** mux.c:
   4 **      serial driver for the Mux console found in some PA-RISC servers.
   5 **
   6 **      (c) Copyright 2002 Ryan Bradetich
   7 **      (c) Copyright 2002 Hewlett-Packard Company
   8 **
   9 ** This Driver currently only supports the console (port 0) on the MUX.
  10 ** Additional work will be needed on this driver to enable the full
  11 ** functionality of the MUX.
  12 **
  13 */
  14
  15 #include <linux/module.h>
  16 #include <linux/ioport.h>
  17 #include <linux/init.h>
  18 #include <linux/serial.h>
  19 #include <linux/tty.h>
  20 #include <linux/tty_flip.h>
  21 #include <linux/console.h>
  22 #include <linux/delay.h> /* for udelay */
  23 #include <linux/device.h>
  24 #include <asm/io.h>
  25 #include <asm/irq.h>
  26 #include <asm/parisc-device.h>
  27
  28 #if defined(CONFIG_SERIAL_MUX_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  29 #include <linux/sysrq.h>
  30 #define SUPPORT_SYSRQ
  31 #endif
  32
  33 #include <linux/serial_core.h>
  34
  35 #define MUX_OFFSET 0x800
  36 #define MUX_LINE_OFFSET 0x80
  37
  38 #define MUX_FIFO_SIZE 255
  39 #define MUX_POLL_DELAY (30 * HZ / 1000)
  40
  41 #define IO_DATA_REG_OFFSET 0x3c
  42 #define IO_DCOUNT_REG_OFFSET 0x40
  43
  44 #define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
  45 #define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
  46 #define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
  47
  48 #define MUX_NR 256
  49 static unsigned int port_cnt __read_mostly;
  50 struct mux_port {
  51         struct uart_port port;
  52         int enabled;
  53 };
  54 static struct mux_port mux_ports[MUX_NR];
  55
  56 static struct uart_driver mux_driver = {
  57         .owner = THIS_MODULE,
  58         .driver_name = "ttyB",
  59         .dev_name = "ttyB",
  60         .major = MUX_MAJOR,
  61         .minor = 0,
  62         .nr = MUX_NR,
  63 };
  64
  65 static struct timer_list mux_timer;
  66
  67 #define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)
  68 #define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)
  69
  70 /**
  71  * get_mux_port_count - Get the number of available ports on the Mux.
  72  * @dev: The parisc device.
  73  *
  74  * This function is used to determine the number of ports the Mux
  75  * supports.  The IODC data reports the number of ports the Mux
  76  * can support, but there are cases where not all the Mux ports
  77  * are connected.  This function can override the IODC and
  78  * return the true port count.
  79  */
  80 static int __init get_mux_port_count(struct parisc_device *dev)
  81 {
  82         int status;
  83         u8 iodc_data[32];
  84         unsigned long bytecnt;
  85
  86         /* If this is the built-in Mux for the K-Class (Eole CAP/MUX),
  87          * we only need to allocate resources for 1 port since the
  88          * other 7 ports are not connected.
  89          */
  90         if(dev->id.hversion == 0x15)
  91                 return 1;
  92
  93         status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
  94         BUG_ON(status != PDC_OK);
  95
  96         /* Return the number of ports specified in the iodc data. */
  97         return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8;
  98 }
  99
 100 /**
 101  * mux_tx_empty - Check if the transmitter fifo is empty.
 102  * @port: Ptr to the uart_port.
 103  *
 104  * This function test if the transmitter fifo for the port
 105  * described by 'port' is empty.  If it is empty, this function
 106  * should return TIOCSER_TEMT, otherwise return 0.
 107  */
 108 static unsigned int mux_tx_empty(struct uart_port *port)
 109 {
 110         return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
 111 }
 112
 113 /**
 114  * mux_set_mctrl - Set the current state of the modem control inputs.
 115  * @ports: Ptr to the uart_port.
 116  * @mctrl: Modem control bits.
 117  *
 118  * The Serial MUX does not support CTS, DCD or DSR so this function
 119  * is ignored.
 120  */
 121 static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
 122 {
 123 }
 124
 125 /**
 126  * mux_get_mctrl - Returns the current state of modem control inputs.
 127  * @port: Ptr to the uart_port.
 128  *
 129  * The Serial MUX does not support CTS, DCD or DSR so these lines are
 130  * treated as permanently active.
 131  */
 132 static unsigned int mux_get_mctrl(struct uart_port *port)
 133 {
 134         return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
 135 }
 136
 137 /**
 138  * mux_stop_tx - Stop transmitting characters.
 139  * @port: Ptr to the uart_port.
 140  *
 141  * The Serial MUX does not support this function.
 142  */
 143 static void mux_stop_tx(struct uart_port *port)
 144 {
 145 }
 146
 147 /**
 148  * mux_start_tx - Start transmitting characters.
 149  * @port: Ptr to the uart_port.
 150  *
 151  * The Serial Mux does not support this function.
 152  */
 153 static void mux_start_tx(struct uart_port *port)
 154 {
 155 }
 156
 157 /**
 158  * mux_stop_rx - Stop receiving characters.
 159  * @port: Ptr to the uart_port.
 160  *
 161  * The Serial Mux does not support this function.
 162  */
 163 static void mux_stop_rx(struct uart_port *port)
 164 {
 165 }
 166
 167 /**
 168  * mux_break_ctl - Control the transmitssion of a break signal.
 169  * @port: Ptr to the uart_port.
 170  * @break_state: Raise/Lower the break signal.
 171  *
 172  * The Serial Mux does not support this function.
 173  */
 174 static void mux_break_ctl(struct uart_port *port, int break_state)
 175 {
 176 }
 177
 178 /**
 179  * mux_write - Write chars to the mux fifo.
 180  * @port: Ptr to the uart_port.
 181  *
 182  * This function writes all the data from the uart buffer to
 183  * the mux fifo.
 184  */
 185 static void mux_write(struct uart_port *port)
 186 {
 187         int count;
 188         struct circ_buf *xmit = &port->state->xmit;
 189
 190         if(port->x_char) {
 191                 UART_PUT_CHAR(port, port->x_char);
 192                 port->icount.tx++;
 193                 port->x_char = 0;
 194                 return;
 195         }
 196
 197         if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 198                 mux_stop_tx(port);
 199                 return;
 200         }
 201
 202         count = (port->fifosize) - UART_GET_FIFO_CNT(port);
 203         do {
 204                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
 205                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 206                 port->icount.tx++;
 207                 if(uart_circ_empty(xmit))
 208                         break;
 209
 210         } while(--count > 0);
 211
 212         while(UART_GET_FIFO_CNT(port))
 213                 udelay(1);
 214
 215         if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 216                 uart_write_wakeup(port);
 217
 218         if (uart_circ_empty(xmit))
 219                 mux_stop_tx(port);
 220 }
 221
 222 /**
 223  * mux_read - Read chars from the mux fifo.
 224  * @port: Ptr to the uart_port.
 225  *
 226  * This reads all available data from the mux's fifo and pushes
 227  * the data to the tty layer.
 228  */
 229 static void mux_read(struct uart_port *port)
 230 {
 231         struct tty_port *tport = &port->state->port;
 232         int data;
 233         __u32 start_count = port->icount.rx;
 234
 235         while(1) {
 236                 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
 237
 238                 if (MUX_STATUS(data))
 239                         continue;
 240
 241                 if (MUX_EOFIFO(data))
 242                         break;
 243
 244                 port->icount.rx++;
 245
 246                 if (MUX_BREAK(data)) {
 247                         port->icount.brk++;
 248                         if(uart_handle_break(port))
 249                                 continue;
 250                 }
 251
 252                 if (uart_handle_sysrq_char(port, data & 0xffu))
 253                         continue;
 254
 255                 tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL);
 256         }
 257
 258         if (start_count != port->icount.rx)
 259                 tty_flip_buffer_push(tport);
 260 }
 261
 262 /**
 263  * mux_startup - Initialize the port.
 264  * @port: Ptr to the uart_port.
 265  *
 266  * Grab any resources needed for this port and start the
 267  * mux timer.
 268  */
 269 static int mux_startup(struct uart_port *port)
 270 {
 271         mux_ports[port->line].enabled = 1;
 272         return 0;
 273 }
 274
 275 /**
 276  * mux_shutdown - Disable the port.
 277  * @port: Ptr to the uart_port.
 278  *
 279  * Release any resources needed for the port.
 280  */
 281 static void mux_shutdown(struct uart_port *port)
 282 {
 283         mux_ports[port->line].enabled = 0;
 284 }
 285
 286 /**
 287  * mux_set_termios - Chane port parameters.
 288  * @port: Ptr to the uart_port.
 289  * @termios: new termios settings.
 290  * @old: old termios settings.
 291  *
 292  * The Serial Mux does not support this function.
 293  */
 294 static void
 295 mux_set_termios(struct uart_port *port, struct ktermios *termios,
 296                 struct ktermios *old)
 297 {
 298 }
 299
 300 /**
 301  * mux_type - Describe the port.
 302  * @port: Ptr to the uart_port.
 303  *
 304  * Return a pointer to a string constant describing the
 305  * specified port.
 306  */
 307 static const char *mux_type(struct uart_port *port)
 308 {
 309         return "Mux";
 310 }
 311
 312 /**
 313  * mux_release_port - Release memory and IO regions.
 314  * @port: Ptr to the uart_port.
 315  *
 316  * Release any memory and IO region resources currently in use by
 317  * the port.
 318  */
 319 static void mux_release_port(struct uart_port *port)
 320 {
 321 }
 322
 323 /**
 324  * mux_request_port - Request memory and IO regions.
 325  * @port: Ptr to the uart_port.
 326  *
 327  * Request any memory and IO region resources required by the port.
 328  * If any fail, no resources should be registered when this function
 329  * returns, and it should return -EBUSY on failure.
 330  */
 331 static int mux_request_port(struct uart_port *port)
 332 {
 333         return 0;
 334 }
 335
 336 /**
 337  * mux_config_port - Perform port autoconfiguration.
 338  * @port: Ptr to the uart_port.
 339  * @type: Bitmask of required configurations.
 340  *
 341  * Perform any autoconfiguration steps for the port.  This function is
 342  * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
 343  * [Note: This is required for now because of a bug in the Serial core.
 344  *  rmk has already submitted a patch to linus, should be available for
 345  *  2.5.47.]
 346  */
 347 static void mux_config_port(struct uart_port *port, int type)
 348 {
 349         port->type = PORT_MUX;
 350 }
 351
 352 /**
 353  * mux_verify_port - Verify the port information.
 354  * @port: Ptr to the uart_port.
 355  * @ser: Ptr to the serial information.
 356  *
 357  * Verify the new serial port information contained within serinfo is
 358  * suitable for this port type.
 359  */
 360 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
 361 {
 362         if(port->membase == NULL)
 363                 return -EINVAL;
 364
 365         return 0;
 366 }
 367
 368 /**
 369  * mux_drv_poll - Mux poll function.
 370  * @unused: Unused variable
 371  *
 372  * This function periodically polls the Serial MUX to check for new data.
 373  */
 374 static void mux_poll(struct timer_list *unused)
 375 {
 376         int i;
 377
 378         for(i = 0; i < port_cnt; ++i) {
 379                 if(!mux_ports[i].enabled)
 380                         continue;
 381
 382                 mux_read(&mux_ports[i].port);
 383                 mux_write(&mux_ports[i].port);
 384         }
 385
 386         mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 387 }
 388
 389
 390 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 391 static void mux_console_write(struct console *co, const char *s, unsigned count)
 392 {
 393         /* Wait until the FIFO drains. */
 394         while(UART_GET_FIFO_CNT(&mux_ports[0].port))
 395                 udelay(1);
 396
 397         while(count--) {
 398                 if(*s == '\n') {
 399                         UART_PUT_CHAR(&mux_ports[0].port, '\r');
 400                 }
 401                 UART_PUT_CHAR(&mux_ports[0].port, *s++);
 402         }
 403
 404 }
 405
 406 static int mux_console_setup(struct console *co, char *options)
 407 {
 408         return 0;
 409 }
 410
 411 static struct console mux_console = {
 412         .name =         "ttyB",
 413         .write =        mux_console_write,
 414         .device =       uart_console_device,
 415         .setup =        mux_console_setup,
 416         .flags =        CON_ENABLED | CON_PRINTBUFFER,
 417         .index =        0,
 418         .data =         &mux_driver,
 419 };
 420
 421 #define MUX_CONSOLE     &mux_console
 422 #else
 423 #define MUX_CONSOLE     NULL
 424 #endif
 425
 426 static const struct uart_ops mux_pops = {
 427         .tx_empty =             mux_tx_empty,
 428         .set_mctrl =            mux_set_mctrl,
 429         .get_mctrl =            mux_get_mctrl,
 430         .stop_tx =              mux_stop_tx,
 431         .start_tx =             mux_start_tx,
 432         .stop_rx =              mux_stop_rx,
 433         .break_ctl =            mux_break_ctl,
 434         .startup =              mux_startup,
 435         .shutdown =             mux_shutdown,
 436         .set_termios =          mux_set_termios,
 437         .type =                 mux_type,
 438         .release_port =         mux_release_port,
 439         .request_port =         mux_request_port,
 440         .config_port =          mux_config_port,
 441         .verify_port =          mux_verify_port,
 442 };
 443
 444 /**
 445  * mux_probe - Determine if the Serial Mux should claim this device.
 446  * @dev: The parisc device.
 447  *
 448  * Deterimine if the Serial Mux should claim this chip (return 0)
 449  * or not (return 1).
 450  */
 451 static int __init mux_probe(struct parisc_device *dev)
 452 {
 453         int i, status;
 454
 455         int port_count = get_mux_port_count(dev);
 456         printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
 457
 458         dev_set_drvdata(&dev->dev, (void *)(long)port_count);
 459         request_mem_region(dev->hpa.start + MUX_OFFSET,
 460                            port_count * MUX_LINE_OFFSET, "Mux");
 461
 462         if(!port_cnt) {
 463                 mux_driver.cons = MUX_CONSOLE;
 464
 465                 status = uart_register_driver(&mux_driver);
 466                 if(status) {
 467                         printk(KERN_ERR "Serial mux: Unable to register driver.\n");
 468                         return 1;
 469                 }
 470         }
 471
 472         for(i = 0; i < port_count; ++i, ++port_cnt) {
 473                 struct uart_port *port = &mux_ports[port_cnt].port;
 474                 port->iobase    = 0;
 475                 port->mapbase   = dev->hpa.start + MUX_OFFSET +
 476                                                 (i * MUX_LINE_OFFSET);
 477                 port->membase   = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
 478                 port->iotype    = UPIO_MEM;
 479                 port->type      = PORT_MUX;
 480                 port->irq       = 0;
 481                 port->uartclk   = 0;
 482                 port->fifosize  = MUX_FIFO_SIZE;
 483                 port->ops       = &mux_pops;
 484                 port->flags     = UPF_BOOT_AUTOCONF;
 485                 port->line      = port_cnt;
 486
 487                 /* The port->timeout needs to match what is present in
 488                  * uart_wait_until_sent in serial_core.c.  Otherwise
 489                  * the time spent in msleep_interruptable will be very
 490                  * long, causing the appearance of a console hang.
 491                  */
 492                 port->timeout   = HZ / 50;
 493                 spin_lock_init(&port->lock);
 494
 495                 status = uart_add_one_port(&mux_driver, port);
 496                 BUG_ON(status);
 497         }
 498
 499         return 0;
 500 }
 501
 502 static int __exit mux_remove(struct parisc_device *dev)
 503 {
 504         int i, j;
 505         int port_count = (long)dev_get_drvdata(&dev->dev);
 506
 507         /* Find Port 0 for this card in the mux_ports list. */
 508         for(i = 0; i < port_cnt; ++i) {
 509                 if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
 510                         break;
 511         }
 512         BUG_ON(i + port_count > port_cnt);
 513
 514         /* Release the resources associated with each port on the device. */
 515         for(j = 0; j < port_count; ++j, ++i) {
 516                 struct uart_port *port = &mux_ports[i].port;
 517
 518                 uart_remove_one_port(&mux_driver, port);
 519                 if(port->membase)
 520                         iounmap(port->membase);
 521         }
 522
 523         release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
 524         return 0;
 525 }
 526
 527 /* Hack.  This idea was taken from the 8250_gsc.c on how to properly order
 528  * the serial port detection in the proper order.   The idea is we always
 529  * want the builtin mux to be detected before addin mux cards, so we
 530  * specifically probe for the builtin mux cards first.
 531  *
 532  * This table only contains the parisc_device_id of known builtin mux
 533  * devices.  All other mux cards will be detected by the generic mux_tbl.
 534  */
 535 static const struct parisc_device_id builtin_mux_tbl[] __initconst = {
 536         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
 537         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
 538         { 0, }
 539 };
 540
 541 static const struct parisc_device_id mux_tbl[] __initconst = {
 542         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
 543         { 0, }
 544 };
 545
 546 MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
 547 MODULE_DEVICE_TABLE(parisc, mux_tbl);
 548
 549 static struct parisc_driver builtin_serial_mux_driver __refdata = {
 550         .name =         "builtin_serial_mux",
 551         .id_table =     builtin_mux_tbl,
 552         .probe =        mux_probe,
 553         .remove =       __exit_p(mux_remove),
 554 };
 555
 556 static struct parisc_driver serial_mux_driver __refdata = {
 557         .name =         "serial_mux",
 558         .id_table =     mux_tbl,
 559         .probe =        mux_probe,
 560         .remove =       __exit_p(mux_remove),
 561 };
 562
 563 /**
 564  * mux_init - Serial MUX initialization procedure.
 565  *
 566  * Register the Serial MUX driver.
 567  */
 568 static int __init mux_init(void)
 569 {
 570         register_parisc_driver(&builtin_serial_mux_driver);
 571         register_parisc_driver(&serial_mux_driver);
 572
 573         if(port_cnt > 0) {
 574                 /* Start the Mux timer */
 575                 timer_setup(&mux_timer, mux_poll, 0);
 576                 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 577
 578 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 579                 register_console(&mux_console);
 580 #endif
 581         }
 582
 583         return 0;
 584 }
 585
 586 /**
 587  * mux_exit - Serial MUX cleanup procedure.
 588  *
 589  * Unregister the Serial MUX driver from the tty layer.
 590  */
 591 static void __exit mux_exit(void)
 592 {
 593         /* Delete the Mux timer. */
 594         if(port_cnt > 0) {
 595                 del_timer_sync(&mux_timer);
 596 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 597                 unregister_console(&mux_console);
 598 #endif
 599         }
 600
 601         unregister_parisc_driver(&builtin_serial_mux_driver);
 602         unregister_parisc_driver(&serial_mux_driver);
 603         uart_unregister_driver(&mux_driver);
 604 }
 605
 606 module_init(mux_init);
 607 module_exit(mux_exit);
 608
 609 MODULE_AUTHOR("Ryan Bradetich");
 610 MODULE_DESCRIPTION("Serial MUX driver");
 611 MODULE_LICENSE("GPL");
 612 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);