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