drivers/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/tty.h>
  21 #include <linux/ioport.h>
  22 #include <linux/init.h>
  23 #include <linux/serial.h>
  24 #include <linux/console.h>
  25 #include <linux/slab.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 #ifdef 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_enable_ms - Enable modum status interrupts.
 173  * @port: Ptr to the uart_port.
 174  *
 175  * The Serial Mux does not support this function.
 176  */
 177 static void mux_enable_ms(struct uart_port *port)
 178 {
 179 }
 180
 181 /**
 182  * mux_break_ctl - Control the transmitssion of a break signal.
 183  * @port: Ptr to the uart_port.
 184  * @break_state: Raise/Lower the break signal.
 185  *
 186  * The Serial Mux does not support this function.
 187  */
 188 static void mux_break_ctl(struct uart_port *port, int break_state)
 189 {
 190 }
 191
 192 /**
 193  * mux_write - Write chars to the mux fifo.
 194  * @port: Ptr to the uart_port.
 195  *
 196  * This function writes all the data from the uart buffer to
 197  * the mux fifo.
 198  */
 199 static void mux_write(struct uart_port *port)
 200 {
 201         int count;
 202         struct circ_buf *xmit = &port->info->xmit;
 203
 204         if(port->x_char) {
 205                 UART_PUT_CHAR(port, port->x_char);
 206                 port->icount.tx++;
 207                 port->x_char = 0;
 208                 return;
 209         }
 210
 211         if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 212                 mux_stop_tx(port);
 213                 return;
 214         }
 215
 216         count = (port->fifosize) - UART_GET_FIFO_CNT(port);
 217         do {
 218                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
 219                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 220                 port->icount.tx++;
 221                 if(uart_circ_empty(xmit))
 222                         break;
 223
 224         } while(--count > 0);
 225
 226         while(UART_GET_FIFO_CNT(port))
 227                 udelay(1);
 228
 229         if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 230                 uart_write_wakeup(port);
 231
 232         if (uart_circ_empty(xmit))
 233                 mux_stop_tx(port);
 234 }
 235
 236 /**
 237  * mux_read - Read chars from the mux fifo.
 238  * @port: Ptr to the uart_port.
 239  *
 240  * This reads all available data from the mux's fifo and pushes
 241  * the data to the tty layer.
 242  */
 243 static void mux_read(struct uart_port *port)
 244 {
 245         int data;
 246         struct tty_struct *tty = port->info->tty;
 247         __u32 start_count = port->icount.rx;
 248
 249         while(1) {
 250                 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
 251
 252                 if (MUX_STATUS(data))
 253                         continue;
 254
 255                 if (MUX_EOFIFO(data))
 256                         break;
 257
 258                 port->icount.rx++;
 259
 260                 if (MUX_BREAK(data)) {
 261                         port->icount.brk++;
 262                         if(uart_handle_break(port))
 263                                 continue;
 264                 }
 265
 266                 if (uart_handle_sysrq_char(port, data & 0xffu))
 267                         continue;
 268
 269                 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
 270         }
 271
 272         if (start_count != port->icount.rx) {
 273                 tty_flip_buffer_push(tty);
 274         }
 275 }
 276
 277 /**
 278  * mux_startup - Initialize the port.
 279  * @port: Ptr to the uart_port.
 280  *
 281  * Grab any resources needed for this port and start the
 282  * mux timer.
 283  */
 284 static int mux_startup(struct uart_port *port)
 285 {
 286         mux_ports[port->line].enabled = 1;
 287         return 0;
 288 }
 289
 290 /**
 291  * mux_shutdown - Disable the port.
 292  * @port: Ptr to the uart_port.
 293  *
 294  * Release any resources needed for the port.
 295  */
 296 static void mux_shutdown(struct uart_port *port)
 297 {
 298         mux_ports[port->line].enabled = 0;
 299 }
 300
 301 /**
 302  * mux_set_termios - Chane port parameters.
 303  * @port: Ptr to the uart_port.
 304  * @termios: new termios settings.
 305  * @old: old termios settings.
 306  *
 307  * The Serial Mux does not support this function.
 308  */
 309 static void
 310 mux_set_termios(struct uart_port *port, struct ktermios *termios,
 311                 struct ktermios *old)
 312 {
 313 }
 314
 315 /**
 316  * mux_type - Describe the port.
 317  * @port: Ptr to the uart_port.
 318  *
 319  * Return a pointer to a string constant describing the
 320  * specified port.
 321  */
 322 static const char *mux_type(struct uart_port *port)
 323 {
 324         return "Mux";
 325 }
 326
 327 /**
 328  * mux_release_port - Release memory and IO regions.
 329  * @port: Ptr to the uart_port.
 330  *
 331  * Release any memory and IO region resources currently in use by
 332  * the port.
 333  */
 334 static void mux_release_port(struct uart_port *port)
 335 {
 336 }
 337
 338 /**
 339  * mux_request_port - Request memory and IO regions.
 340  * @port: Ptr to the uart_port.
 341  *
 342  * Request any memory and IO region resources required by the port.
 343  * If any fail, no resources should be registered when this function
 344  * returns, and it should return -EBUSY on failure.
 345  */
 346 static int mux_request_port(struct uart_port *port)
 347 {
 348         return 0;
 349 }
 350
 351 /**
 352  * mux_config_port - Perform port autoconfiguration.
 353  * @port: Ptr to the uart_port.
 354  * @type: Bitmask of required configurations.
 355  *
 356  * Perform any autoconfiguration steps for the port.  This function is
 357  * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
 358  * [Note: This is required for now because of a bug in the Serial core.
 359  *  rmk has already submitted a patch to linus, should be available for
 360  *  2.5.47.]
 361  */
 362 static void mux_config_port(struct uart_port *port, int type)
 363 {
 364         port->type = PORT_MUX;
 365 }
 366
 367 /**
 368  * mux_verify_port - Verify the port information.
 369  * @port: Ptr to the uart_port.
 370  * @ser: Ptr to the serial information.
 371  *
 372  * Verify the new serial port information contained within serinfo is
 373  * suitable for this port type.
 374  */
 375 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
 376 {
 377         if(port->membase == NULL)
 378                 return -EINVAL;
 379
 380         return 0;
 381 }
 382
 383 /**
 384  * mux_drv_poll - Mux poll function.
 385  * @unused: Unused variable
 386  *
 387  * This function periodically polls the Serial MUX to check for new data.
 388  */
 389 static void mux_poll(unsigned long unused)
 390 {
 391         int i;
 392
 393         for(i = 0; i < port_cnt; ++i) {
 394                 if(!mux_ports[i].enabled)
 395                         continue;
 396
 397                 mux_read(&mux_ports[i].port);
 398                 mux_write(&mux_ports[i].port);
 399         }
 400
 401         mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 402 }
 403
 404
 405 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 406 static void mux_console_write(struct console *co, const char *s, unsigned count)
 407 {
 408         /* Wait until the FIFO drains. */
 409         while(UART_GET_FIFO_CNT(&mux_ports[0].port))
 410                 udelay(1);
 411
 412         while(count--) {
 413                 if(*s == '\n') {
 414                         UART_PUT_CHAR(&mux_ports[0].port, '\r');
 415                 }
 416                 UART_PUT_CHAR(&mux_ports[0].port, *s++);
 417         }
 418
 419 }
 420
 421 static int mux_console_setup(struct console *co, char *options)
 422 {
 423         return 0;
 424 }
 425
 426 struct tty_driver *mux_console_device(struct console *co, int *index)
 427 {
 428         *index = co->index;
 429         return mux_driver.tty_driver;
 430 }
 431
 432 static struct console mux_console = {
 433         .name =         "ttyB",
 434         .write =        mux_console_write,
 435         .device =       mux_console_device,
 436         .setup =        mux_console_setup,
 437         .flags =        CON_ENABLED | CON_PRINTBUFFER,
 438         .index =        0,
 439 };
 440
 441 #define MUX_CONSOLE     &mux_console
 442 #else
 443 #define MUX_CONSOLE     NULL
 444 #endif
 445
 446 static struct uart_ops mux_pops = {
 447         .tx_empty =             mux_tx_empty,
 448         .set_mctrl =            mux_set_mctrl,
 449         .get_mctrl =            mux_get_mctrl,
 450         .stop_tx =              mux_stop_tx,
 451         .start_tx =             mux_start_tx,
 452         .stop_rx =              mux_stop_rx,
 453         .enable_ms =            mux_enable_ms,
 454         .break_ctl =            mux_break_ctl,
 455         .startup =              mux_startup,
 456         .shutdown =             mux_shutdown,
 457         .set_termios =          mux_set_termios,
 458         .type =                 mux_type,
 459         .release_port =         mux_release_port,
 460         .request_port =         mux_request_port,
 461         .config_port =          mux_config_port,
 462         .verify_port =          mux_verify_port,
 463 };
 464
 465 /**
 466  * mux_probe - Determine if the Serial Mux should claim this device.
 467  * @dev: The parisc device.
 468  *
 469  * Deterimine if the Serial Mux should claim this chip (return 0)
 470  * or not (return 1).
 471  */
 472 static int __init mux_probe(struct parisc_device *dev)
 473 {
 474         int i, status;
 475
 476         int port_count = get_mux_port_count(dev);
 477         printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
 478
 479         dev_set_drvdata(&dev->dev, (void *)(long)port_count);
 480         request_mem_region(dev->hpa.start + MUX_OFFSET,
 481                            port_count * MUX_LINE_OFFSET, "Mux");
 482
 483         if(!port_cnt) {
 484                 mux_driver.cons = MUX_CONSOLE;
 485
 486                 status = uart_register_driver(&mux_driver);
 487                 if(status) {
 488                         printk(KERN_ERR "Serial mux: Unable to register driver.\n");
 489                         return 1;
 490                 }
 491         }
 492
 493         for(i = 0; i < port_count; ++i, ++port_cnt) {
 494                 struct uart_port *port = &mux_ports[port_cnt].port;
 495                 port->iobase    = 0;
 496                 port->mapbase   = dev->hpa.start + MUX_OFFSET +
 497                                                 (i * MUX_LINE_OFFSET);
 498                 port->membase   = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
 499                 port->iotype    = UPIO_MEM;
 500                 port->type      = PORT_MUX;
 501                 port->irq       = NO_IRQ;
 502                 port->uartclk   = 0;
 503                 port->fifosize  = MUX_FIFO_SIZE;
 504                 port->ops       = &mux_pops;
 505                 port->flags     = UPF_BOOT_AUTOCONF;
 506                 port->line      = port_cnt;
 507
 508                 /* The port->timeout needs to match what is present in
 509                  * uart_wait_until_sent in serial_core.c.  Otherwise
 510                  * the time spent in msleep_interruptable will be very
 511                  * long, causing the appearance of a console hang.
 512                  */
 513                 port->timeout   = HZ / 50;
 514                 spin_lock_init(&port->lock);
 515
 516                 status = uart_add_one_port(&mux_driver, port);
 517                 BUG_ON(status);
 518         }
 519
 520         return 0;
 521 }
 522
 523 static int __devexit mux_remove(struct parisc_device *dev)
 524 {
 525         int i, j;
 526         int port_count = (long)dev_get_drvdata(&dev->dev);
 527
 528         /* Find Port 0 for this card in the mux_ports list. */
 529         for(i = 0; i < port_cnt; ++i) {
 530                 if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
 531                         break;
 532         }
 533         BUG_ON(i + port_count > port_cnt);
 534
 535         /* Release the resources associated with each port on the device. */
 536         for(j = 0; j < port_count; ++j, ++i) {
 537                 struct uart_port *port = &mux_ports[i].port;
 538
 539                 uart_remove_one_port(&mux_driver, port);
 540                 if(port->membase)
 541                         iounmap(port->membase);
 542         }
 543
 544         release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
 545         return 0;
 546 }
 547
 548 /* Hack.  This idea was taken from the 8250_gsc.c on how to properly order
 549  * the serial port detection in the proper order.   The idea is we always
 550  * want the builtin mux to be detected before addin mux cards, so we
 551  * specifically probe for the builtin mux cards first.
 552  *
 553  * This table only contains the parisc_device_id of known builtin mux
 554  * devices.  All other mux cards will be detected by the generic mux_tbl.
 555  */
 556 static struct parisc_device_id builtin_mux_tbl[] = {
 557         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
 558         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
 559         { 0, }
 560 };
 561
 562 static struct parisc_device_id mux_tbl[] = {
 563         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
 564         { 0, }
 565 };
 566
 567 MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
 568 MODULE_DEVICE_TABLE(parisc, mux_tbl);
 569
 570 static struct parisc_driver builtin_serial_mux_driver = {
 571         .name =         "builtin_serial_mux",
 572         .id_table =     builtin_mux_tbl,
 573         .probe =        mux_probe,
 574         .remove =       __devexit_p(mux_remove),
 575 };
 576
 577 static struct parisc_driver serial_mux_driver = {
 578         .name =         "serial_mux",
 579         .id_table =     mux_tbl,
 580         .probe =        mux_probe,
 581         .remove =       __devexit_p(mux_remove),
 582 };
 583
 584 /**
 585  * mux_init - Serial MUX initialization procedure.
 586  *
 587  * Register the Serial MUX driver.
 588  */
 589 static int __init mux_init(void)
 590 {
 591         register_parisc_driver(&builtin_serial_mux_driver);
 592         register_parisc_driver(&serial_mux_driver);
 593
 594         if(port_cnt > 0) {
 595                 /* Start the Mux timer */
 596                 init_timer(&mux_timer);
 597                 mux_timer.function = mux_poll;
 598                 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 599
 600 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 601                 register_console(&mux_console);
 602 #endif
 603         }
 604
 605         return 0;
 606 }
 607
 608 /**
 609  * mux_exit - Serial MUX cleanup procedure.
 610  *
 611  * Unregister the Serial MUX driver from the tty layer.
 612  */
 613 static void __exit mux_exit(void)
 614 {
 615         /* Delete the Mux timer. */
 616         if(port_cnt > 0) {
 617                 del_timer(&mux_timer);
 618 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 619                 unregister_console(&mux_console);
 620 #endif
 621         }
 622
 623         unregister_parisc_driver(&builtin_serial_mux_driver);
 624         unregister_parisc_driver(&serial_mux_driver);
 625         uart_unregister_driver(&mux_driver);
 626 }
 627
 628 module_init(mux_init);
 629 module_exit(mux_exit);
 630
 631 MODULE_AUTHOR("Ryan Bradetich");
 632 MODULE_DESCRIPTION("Serial MUX driver");
 633 MODULE_LICENSE("GPL");
 634 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);