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 static struct uart_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 #define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8
  70
  71 /**
  72  * mux_tx_empty - Check if the transmitter fifo is empty.
  73  * @port: Ptr to the uart_port.
  74  *
  75  * This function test if the transmitter fifo for the port
  76  * described by 'port' is empty.  If it is empty, this function
  77  * should return TIOCSER_TEMT, otherwise return 0.
  78  */
  79 static unsigned int mux_tx_empty(struct uart_port *port)
  80 {
  81         return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
  82 }
  83
  84 /**
  85  * mux_set_mctrl - Set the current state of the modem control inputs.
  86  * @ports: Ptr to the uart_port.
  87  * @mctrl: Modem control bits.
  88  *
  89  * The Serial MUX does not support CTS, DCD or DSR so this function
  90  * is ignored.
  91  */
  92 static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
  93 {
  94 }
  95
  96 /**
  97  * mux_get_mctrl - Returns the current state of modem control inputs.
  98  * @port: Ptr to the uart_port.
  99  *
 100  * The Serial MUX does not support CTS, DCD or DSR so these lines are
 101  * treated as permanently active.
 102  */
 103 static unsigned int mux_get_mctrl(struct uart_port *port)
 104 {
 105         return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
 106 }
 107
 108 /**
 109  * mux_stop_tx - Stop transmitting characters.
 110  * @port: Ptr to the uart_port.
 111  *
 112  * The Serial MUX does not support this function.
 113  */
 114 static void mux_stop_tx(struct uart_port *port)
 115 {
 116 }
 117
 118 /**
 119  * mux_start_tx - Start transmitting characters.
 120  * @port: Ptr to the uart_port.
 121  *
 122  * The Serial Mux does not support this function.
 123  */
 124 static void mux_start_tx(struct uart_port *port)
 125 {
 126 }
 127
 128 /**
 129  * mux_stop_rx - Stop receiving characters.
 130  * @port: Ptr to the uart_port.
 131  *
 132  * The Serial Mux does not support this function.
 133  */
 134 static void mux_stop_rx(struct uart_port *port)
 135 {
 136 }
 137
 138 /**
 139  * mux_enable_ms - Enable modum status interrupts.
 140  * @port: Ptr to the uart_port.
 141  *
 142  * The Serial Mux does not support this function.
 143  */
 144 static void mux_enable_ms(struct uart_port *port)
 145 {
 146 }
 147
 148 /**
 149  * mux_break_ctl - Control the transmitssion of a break signal.
 150  * @port: Ptr to the uart_port.
 151  * @break_state: Raise/Lower the break signal.
 152  *
 153  * The Serial Mux does not support this function.
 154  */
 155 static void mux_break_ctl(struct uart_port *port, int break_state)
 156 {
 157 }
 158
 159 /**
 160  * mux_write - Write chars to the mux fifo.
 161  * @port: Ptr to the uart_port.
 162  *
 163  * This function writes all the data from the uart buffer to
 164  * the mux fifo.
 165  */
 166 static void mux_write(struct uart_port *port)
 167 {
 168         int count;
 169         struct circ_buf *xmit = &port->info->xmit;
 170
 171         if(port->x_char) {
 172                 UART_PUT_CHAR(port, port->x_char);
 173                 port->icount.tx++;
 174                 port->x_char = 0;
 175                 return;
 176         }
 177
 178         if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 179                 mux_stop_tx(port);
 180                 return;
 181         }
 182
 183         count = (port->fifosize) - UART_GET_FIFO_CNT(port);
 184         do {
 185                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
 186                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 187                 port->icount.tx++;
 188                 if(uart_circ_empty(xmit))
 189                         break;
 190
 191         } while(--count > 0);
 192
 193         while(UART_GET_FIFO_CNT(port))
 194                 udelay(1);
 195
 196         if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 197                 uart_write_wakeup(port);
 198
 199         if (uart_circ_empty(xmit))
 200                 mux_stop_tx(port);
 201 }
 202
 203 /**
 204  * mux_read - Read chars from the mux fifo.
 205  * @port: Ptr to the uart_port.
 206  *
 207  * This reads all available data from the mux's fifo and pushes
 208  * the data to the tty layer.
 209  */
 210 static void mux_read(struct uart_port *port)
 211 {
 212         int data;
 213         struct tty_struct *tty = port->info->tty;
 214         __u32 start_count = port->icount.rx;
 215
 216         while(1) {
 217                 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
 218
 219                 if (MUX_STATUS(data))
 220                         continue;
 221
 222                 if (MUX_EOFIFO(data))
 223                         break;
 224
 225                 port->icount.rx++;
 226
 227                 if (MUX_BREAK(data)) {
 228                         port->icount.brk++;
 229                         if(uart_handle_break(port))
 230                                 continue;
 231                 }
 232
 233                 if (uart_handle_sysrq_char(port, data & 0xffu))
 234                         continue;
 235
 236                 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
 237         }
 238
 239         if (start_count != port->icount.rx) {
 240                 tty_flip_buffer_push(tty);
 241         }
 242 }
 243
 244 /**
 245  * mux_startup - Initialize the port.
 246  * @port: Ptr to the uart_port.
 247  *
 248  * Grab any resources needed for this port and start the
 249  * mux timer.
 250  */
 251 static int mux_startup(struct uart_port *port)
 252 {
 253         mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 254         return 0;
 255 }
 256
 257 /**
 258  * mux_shutdown - Disable the port.
 259  * @port: Ptr to the uart_port.
 260  *
 261  * Release any resources needed for the port.
 262  */
 263 static void mux_shutdown(struct uart_port *port)
 264 {
 265 }
 266
 267 /**
 268  * mux_set_termios - Chane port parameters.
 269  * @port: Ptr to the uart_port.
 270  * @termios: new termios settings.
 271  * @old: old termios settings.
 272  *
 273  * The Serial Mux does not support this function.
 274  */
 275 static void
 276 mux_set_termios(struct uart_port *port, struct ktermios *termios,
 277                 struct ktermios *old)
 278 {
 279 }
 280
 281 /**
 282  * mux_type - Describe the port.
 283  * @port: Ptr to the uart_port.
 284  *
 285  * Return a pointer to a string constant describing the
 286  * specified port.
 287  */
 288 static const char *mux_type(struct uart_port *port)
 289 {
 290         return "Mux";
 291 }
 292
 293 /**
 294  * mux_release_port - Release memory and IO regions.
 295  * @port: Ptr to the uart_port.
 296  *
 297  * Release any memory and IO region resources currently in use by
 298  * the port.
 299  */
 300 static void mux_release_port(struct uart_port *port)
 301 {
 302 }
 303
 304 /**
 305  * mux_request_port - Request memory and IO regions.
 306  * @port: Ptr to the uart_port.
 307  *
 308  * Request any memory and IO region resources required by the port.
 309  * If any fail, no resources should be registered when this function
 310  * returns, and it should return -EBUSY on failure.
 311  */
 312 static int mux_request_port(struct uart_port *port)
 313 {
 314         return 0;
 315 }
 316
 317 /**
 318  * mux_config_port - Perform port autoconfiguration.
 319  * @port: Ptr to the uart_port.
 320  * @type: Bitmask of required configurations.
 321  *
 322  * Perform any autoconfiguration steps for the port.  This functino is
 323  * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
 324  * [Note: This is required for now because of a bug in the Serial core.
 325  *  rmk has already submitted a patch to linus, should be available for
 326  *  2.5.47.]
 327  */
 328 static void mux_config_port(struct uart_port *port, int type)
 329 {
 330         port->type = PORT_MUX;
 331 }
 332
 333 /**
 334  * mux_verify_port - Verify the port information.
 335  * @port: Ptr to the uart_port.
 336  * @ser: Ptr to the serial information.
 337  *
 338  * Verify the new serial port information contained within serinfo is
 339  * suitable for this port type.
 340  */
 341 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
 342 {
 343         if(port->membase == NULL)
 344                 return -EINVAL;
 345
 346         return 0;
 347 }
 348
 349 /**
 350  * mux_drv_poll - Mux poll function.
 351  * @unused: Unused variable
 352  *
 353  * This function periodically polls the Serial MUX to check for new data.
 354  */
 355 static void mux_poll(unsigned long unused)
 356 {
 357         int i;
 358
 359         for(i = 0; i < port_cnt; ++i) {
 360                 if(!mux_ports[i].info)
 361                         continue;
 362
 363                 mux_read(&mux_ports[i]);
 364                 mux_write(&mux_ports[i]);
 365         }
 366
 367         mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 368 }
 369
 370
 371 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 372 static void mux_console_write(struct console *co, const char *s, unsigned count)
 373 {
 374         while(count--)
 375                 pdc_iodc_putc(*s++);
 376 }
 377
 378 static int mux_console_setup(struct console *co, char *options)
 379 {
 380         return 0;
 381 }
 382
 383 struct tty_driver *mux_console_device(struct console *co, int *index)
 384 {
 385         *index = co->index;
 386         return mux_driver.tty_driver;
 387 }
 388
 389 static struct console mux_console = {
 390         .name =         "ttyB",
 391         .write =        mux_console_write,
 392         .device =       mux_console_device,
 393         .setup =        mux_console_setup,
 394         .flags =        CON_ENABLED | CON_PRINTBUFFER,
 395         .index =        0,
 396 };
 397
 398 #define MUX_CONSOLE     &mux_console
 399 #else
 400 #define MUX_CONSOLE     NULL
 401 #endif
 402
 403 static struct uart_ops mux_pops = {
 404         .tx_empty =             mux_tx_empty,
 405         .set_mctrl =            mux_set_mctrl,
 406         .get_mctrl =            mux_get_mctrl,
 407         .stop_tx =              mux_stop_tx,
 408         .start_tx =             mux_start_tx,
 409         .stop_rx =              mux_stop_rx,
 410         .enable_ms =            mux_enable_ms,
 411         .break_ctl =            mux_break_ctl,
 412         .startup =              mux_startup,
 413         .shutdown =             mux_shutdown,
 414         .set_termios =          mux_set_termios,
 415         .type =                 mux_type,
 416         .release_port =         mux_release_port,
 417         .request_port =         mux_request_port,
 418         .config_port =          mux_config_port,
 419         .verify_port =          mux_verify_port,
 420 };
 421
 422 /**
 423  * mux_probe - Determine if the Serial Mux should claim this device.
 424  * @dev: The parisc device.
 425  *
 426  * Deterimine if the Serial Mux should claim this chip (return 0)
 427  * or not (return 1).
 428  */
 429 static int __init mux_probe(struct parisc_device *dev)
 430 {
 431         int i, status, ports;
 432         u8 iodc_data[32];
 433         unsigned long bytecnt;
 434         struct uart_port *port;
 435
 436         status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
 437         if(status != PDC_OK) {
 438                 printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
 439                 return 1;
 440         }
 441
 442         ports = GET_MUX_PORTS(iodc_data);
 443         printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);
 444
 445         if(!port_cnt) {
 446                 mux_driver.cons = MUX_CONSOLE;
 447
 448                 status = uart_register_driver(&mux_driver);
 449                 if(status) {
 450                         printk(KERN_ERR "Serial mux: Unable to register driver.\n");
 451                         return 1;
 452                 }
 453
 454                 init_timer(&mux_timer);
 455                 mux_timer.function = mux_poll;
 456         }
 457
 458         for(i = 0; i < ports; ++i, ++port_cnt) {
 459                 port = &mux_ports[port_cnt];
 460                 port->iobase    = 0;
 461                 port->mapbase   = dev->hpa.start + MUX_OFFSET +
 462                                                 (i * MUX_LINE_OFFSET);
 463                 port->membase   = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
 464                 port->iotype    = UPIO_MEM;
 465                 port->type      = PORT_MUX;
 466                 port->irq       = NO_IRQ;
 467                 port->uartclk   = 0;
 468                 port->fifosize  = MUX_FIFO_SIZE;
 469                 port->ops       = &mux_pops;
 470                 port->flags     = UPF_BOOT_AUTOCONF;
 471                 port->line      = port_cnt;
 472
 473                 /* The port->timeout needs to match what is present in
 474                  * uart_wait_until_sent in serial_core.c.  Otherwise
 475                  * the time spent in msleep_interruptable will be very
 476                  * long, causing the appearance of a console hang.
 477                  */
 478                 port->timeout   = HZ / 50;
 479                 spin_lock_init(&port->lock);
 480                 status = uart_add_one_port(&mux_driver, port);
 481                 BUG_ON(status);
 482         }
 483
 484 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 485         register_console(&mux_console);
 486 #endif
 487         return 0;
 488 }
 489
 490 static struct parisc_device_id mux_tbl[] = {
 491         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
 492         { 0, }
 493 };
 494
 495 MODULE_DEVICE_TABLE(parisc, mux_tbl);
 496
 497 static struct parisc_driver serial_mux_driver = {
 498         .name =         "serial_mux",
 499         .id_table =     mux_tbl,
 500         .probe =        mux_probe,
 501 };
 502
 503 /**
 504  * mux_init - Serial MUX initalization procedure.
 505  *
 506  * Register the Serial MUX driver.
 507  */
 508 static int __init mux_init(void)
 509 {
 510         return register_parisc_driver(&serial_mux_driver);
 511 }
 512
 513 /**
 514  * mux_exit - Serial MUX cleanup procedure.
 515  *
 516  * Unregister the Serial MUX driver from the tty layer.
 517  */
 518 static void __exit mux_exit(void)
 519 {
 520         int i;
 521
 522         for (i = 0; i < port_cnt; i++) {
 523                 uart_remove_one_port(&mux_driver, &mux_ports[i]);
 524                 if (mux_ports[i].membase)
 525                         iounmap(mux_ports[i].membase);
 526         }
 527
 528         uart_unregister_driver(&mux_driver);
 529 }
 530
 531 module_init(mux_init);
 532 module_exit(mux_exit);
 533
 534 MODULE_AUTHOR("Ryan Bradetich");
 535 MODULE_DESCRIPTION("Serial MUX driver");
 536 MODULE_LICENSE("GPL");
 537 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);