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