drivers/tty/serial/mux.c

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