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