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