OSCL-LXR linux-6.0.1/​drivers/​tty/​serial/​mux.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: GPL-2.0+
 /*
 ** mux.c:
 **  serial driver for the Mux console found in some PA-RISC servers.
 **
 **  (c) Copyright 2002 Ryan Bradetich
 **  (c) Copyright 2002 Hewlett-Packard Company
 **
 ** This Driver currently only supports the console (port 0) on the MUX.
 ** Additional work will be needed on this driver to enable the full
 ** functionality of the MUX.
 **
 */
 
 #include <linux/module.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/console.h>
 #include <linux/delay.h> /* for udelay */
 #include <linux/device.h>
 #include <linux/io.h>
 #include <asm/irq.h>
 #include <asm/parisc-device.h>
 
 #include <linux/sysrq.h>
 #include <linux/serial_core.h>
 
 #define MUX_OFFSET 0x800
 #define MUX_LINE_OFFSET 0x80
 
 #define MUX_FIFO_SIZE 255
 #define MUX_POLL_DELAY (30 * HZ / 1000)
 
 #define IO_DATA_REG_OFFSET 0x3c
 #define IO_DCOUNT_REG_OFFSET 0x40
 
 #define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
 #define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
 #define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
 
 #define MUX_NR 256
 static unsigned int port_cnt __read_mostly;
 struct mux_port {
     struct uart_port port;
     int enabled;
 };
 static struct mux_port mux_ports[MUX_NR];
 
 static struct uart_driver mux_driver = {
     .owner = THIS_MODULE,
     .driver_name = "ttyB",
     .dev_name = "ttyB",
     .major = MUX_MAJOR,
     .minor = 0,
     .nr = MUX_NR,
 };
 
 static struct timer_list mux_timer;
 
 #define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)
 #define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)
 
 /**
  * get_mux_port_count - Get the number of available ports on the Mux.
  * @dev: The parisc device.
  *
  * This function is used to determine the number of ports the Mux
  * supports.  The IODC data reports the number of ports the Mux
  * can support, but there are cases where not all the Mux ports
  * are connected.  This function can override the IODC and
  * return the true port count.
  */
 static int __init get_mux_port_count(struct parisc_device *dev)
 {
     int status;
     u8 iodc_data[32];
     unsigned long bytecnt;
 
     /* If this is the built-in Mux for the K-Class (Eole CAP/MUX),
      * we only need to allocate resources for 1 port since the
      * other 7 ports are not connected.
      */
     if(dev->id.hversion == 0x15)
         return 1;
 
     status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
     BUG_ON(status != PDC_OK);
 
     /* Return the number of ports specified in the iodc data. */
     return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8;
 }
 
 /**
  * mux_tx_empty - Check if the transmitter fifo is empty.
  * @port: Ptr to the uart_port.
  *
  * This function test if the transmitter fifo for the port
  * described by 'port' is empty.  If it is empty, this function
  * should return TIOCSER_TEMT, otherwise return 0.
  */
 static unsigned int mux_tx_empty(struct uart_port *port)
 {
     return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
 } 
 
 /**
  * mux_set_mctrl - Set the current state of the modem control inputs.
  * @ports: Ptr to the uart_port.
  * @mctrl: Modem control bits.
  *
  * The Serial MUX does not support CTS, DCD or DSR so this function
  * is ignored.
  */
 static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
 }
 
 /**
  * mux_get_mctrl - Returns the current state of modem control inputs.
  * @port: Ptr to the uart_port.
  *
  * The Serial MUX does not support CTS, DCD or DSR so these lines are
  * treated as permanently active.
  */
 static unsigned int mux_get_mctrl(struct uart_port *port)
 { 
     return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
 }
 
 /**
  * mux_stop_tx - Stop transmitting characters.
  * @port: Ptr to the uart_port.
  *
  * The Serial MUX does not support this function.
  */
 static void mux_stop_tx(struct uart_port *port)
 {
 }
 
 /**
  * mux_start_tx - Start transmitting characters.
  * @port: Ptr to the uart_port.
  *
  * The Serial Mux does not support this function.
  */
 static void mux_start_tx(struct uart_port *port)
 {
 }
 
 /**
  * mux_stop_rx - Stop receiving characters.
  * @port: Ptr to the uart_port.
  *
  * The Serial Mux does not support this function.
  */
 static void mux_stop_rx(struct uart_port *port)
 {
 }
 
 /**
  * mux_break_ctl - Control the transmitssion of a break signal.
  * @port: Ptr to the uart_port.
  * @break_state: Raise/Lower the break signal.
  *
  * The Serial Mux does not support this function.
  */
 static void mux_break_ctl(struct uart_port *port, int break_state)
 {
 }
 
 /**
  * mux_write - Write chars to the mux fifo.
  * @port: Ptr to the uart_port.
  *
  * This function writes all the data from the uart buffer to
  * the mux fifo.
  */
 static void mux_write(struct uart_port *port)
 {
     int count;
     struct circ_buf *xmit = &port->state->xmit;
 
     if(port->x_char) {
         UART_PUT_CHAR(port, port->x_char);
         port->icount.tx++;
         port->x_char = 0;
         return;
     }
 
     if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
         mux_stop_tx(port);
         return;
     }
 
     count = (port->fifosize) - UART_GET_FIFO_CNT(port);
     do {
         UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
         xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
         port->icount.tx++;
         if(uart_circ_empty(xmit))
             break;
 
     } while(--count > 0);
 
     while(UART_GET_FIFO_CNT(port)) 
         udelay(1);
 
     if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
         uart_write_wakeup(port);
 
     if (uart_circ_empty(xmit))
         mux_stop_tx(port);
 }
 
 /**
  * mux_read - Read chars from the mux fifo.
  * @port: Ptr to the uart_port.
  *
  * This reads all available data from the mux's fifo and pushes
  * the data to the tty layer.
  */
 static void mux_read(struct uart_port *port)
 {
     struct tty_port *tport = &port->state->port;
     int data;
     __u32 start_count = port->icount.rx;
 
     while(1) {
         data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
 
         if (MUX_STATUS(data))
             continue;
 
         if (MUX_EOFIFO(data))
             break;
 
         port->icount.rx++;
 
         if (MUX_BREAK(data)) {
             port->icount.brk++;
             if(uart_handle_break(port))
                 continue;
         }
 
         if (uart_handle_sysrq_char(port, data & 0xffu))
             continue;
 
         tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL);
     }
     
     if (start_count != port->icount.rx)
         tty_flip_buffer_push(tport);
 }
 
 /**
  * mux_startup - Initialize the port.
  * @port: Ptr to the uart_port.
  *
  * Grab any resources needed for this port and start the
  * mux timer.
  */
 static int mux_startup(struct uart_port *port)
 {
     mux_ports[port->line].enabled = 1;
     return 0;
 }
 
 /**
  * mux_shutdown - Disable the port.
  * @port: Ptr to the uart_port.
  *
  * Release any resources needed for the port.
  */
 static void mux_shutdown(struct uart_port *port)
 {
     mux_ports[port->line].enabled = 0;
 }
 
 /**
  * mux_set_termios - Chane port parameters.
  * @port: Ptr to the uart_port.
  * @termios: new termios settings.
  * @old: old termios settings.
  *
  * The Serial Mux does not support this function.
  */
 static void
 mux_set_termios(struct uart_port *port, struct ktermios *termios,
             struct ktermios *old)
 {
 }
 
 /**
  * mux_type - Describe the port.
  * @port: Ptr to the uart_port.
  *
  * Return a pointer to a string constant describing the
  * specified port.
  */
 static const char *mux_type(struct uart_port *port)
 {
     return "Mux";
 }
 
 /**
  * mux_release_port - Release memory and IO regions.
  * @port: Ptr to the uart_port.
  * 
  * Release any memory and IO region resources currently in use by
  * the port.
  */
 static void mux_release_port(struct uart_port *port)
 {
 }
 
 /**
  * mux_request_port - Request memory and IO regions.
  * @port: Ptr to the uart_port.
  *
  * Request any memory and IO region resources required by the port.
  * If any fail, no resources should be registered when this function
  * returns, and it should return -EBUSY on failure.
  */
 static int mux_request_port(struct uart_port *port)
 {
     return 0;
 }
 
 /**
  * mux_config_port - Perform port autoconfiguration.
  * @port: Ptr to the uart_port.
  * @type: Bitmask of required configurations.
  *
  * Perform any autoconfiguration steps for the port.  This function is
  * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
  * [Note: This is required for now because of a bug in the Serial core.
  *  rmk has already submitted a patch to linus, should be available for
  *  2.5.47.]
  */
 static void mux_config_port(struct uart_port *port, int type)
 {
     port->type = PORT_MUX;
 }
 
 /**
  * mux_verify_port - Verify the port information.
  * @port: Ptr to the uart_port.
  * @ser: Ptr to the serial information.
  *
  * Verify the new serial port information contained within serinfo is
  * suitable for this port type.
  */
 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
     if(port->membase == NULL)
         return -EINVAL;
 
     return 0;
 }
 
 /**
  * mux_drv_poll - Mux poll function.
  * @unused: Unused variable
  *
  * This function periodically polls the Serial MUX to check for new data.
  */
 static void mux_poll(struct timer_list *unused)
 {  
     int i;
 
     for(i = 0; i < port_cnt; ++i) {
         if(!mux_ports[i].enabled)
             continue;
 
         mux_read(&mux_ports[i].port);
         mux_write(&mux_ports[i].port);
     }
 
     mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 }
 
 
 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 static void mux_console_write(struct console *co, const char *s, unsigned count)
 {
     /* Wait until the FIFO drains. */
     while(UART_GET_FIFO_CNT(&mux_ports[0].port))
         udelay(1);
 
     while(count--) {
         if(*s == '\n') {
             UART_PUT_CHAR(&mux_ports[0].port, '\r');
         }
         UART_PUT_CHAR(&mux_ports[0].port, *s++);
     }
 
 }
 
 static int mux_console_setup(struct console *co, char *options)
 {
         return 0;
 }
 
 static struct console mux_console = {
     .name =     "ttyB",
     .write =    mux_console_write,
     .device =   uart_console_device,
     .setup =    mux_console_setup,
     .flags =    CON_ENABLED | CON_PRINTBUFFER,
     .index =    0,
     .data =     &mux_driver,
 };
 
 #define MUX_CONSOLE &mux_console
 #else
 #define MUX_CONSOLE NULL
 #endif
 
 static const struct uart_ops mux_pops = {
     .tx_empty =     mux_tx_empty,
     .set_mctrl =        mux_set_mctrl,
     .get_mctrl =        mux_get_mctrl,
     .stop_tx =      mux_stop_tx,
     .start_tx =     mux_start_tx,
     .stop_rx =      mux_stop_rx,
     .break_ctl =        mux_break_ctl,
     .startup =      mux_startup,
     .shutdown =     mux_shutdown,
     .set_termios =      mux_set_termios,
     .type =         mux_type,
     .release_port =     mux_release_port,
     .request_port =     mux_request_port,
     .config_port =      mux_config_port,
     .verify_port =      mux_verify_port,
 };
 
 /**
  * mux_probe - Determine if the Serial Mux should claim this device.
  * @dev: The parisc device.
  *
  * Deterimine if the Serial Mux should claim this chip (return 0)
  * or not (return 1).
  */
 static int __init mux_probe(struct parisc_device *dev)
 {
     int i, status;
 
     int port_count = get_mux_port_count(dev);
     printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
 
     dev_set_drvdata(&dev->dev, (void *)(long)port_count);
     request_mem_region(dev->hpa.start + MUX_OFFSET,
                            port_count * MUX_LINE_OFFSET, "Mux");
 
     if(!port_cnt) {
         mux_driver.cons = MUX_CONSOLE;
 
         status = uart_register_driver(&mux_driver);
         if(status) {
             printk(KERN_ERR "Serial mux: Unable to register driver.\n");
             return 1;
         }
     }
 
     for(i = 0; i < port_count; ++i, ++port_cnt) {
         struct uart_port *port = &mux_ports[port_cnt].port;
         port->iobase    = 0;
         port->mapbase   = dev->hpa.start + MUX_OFFSET +
                         (i * MUX_LINE_OFFSET);
         port->membase   = ioremap(port->mapbase, MUX_LINE_OFFSET);
         port->iotype    = UPIO_MEM;
         port->type  = PORT_MUX;
         port->irq   = 0;
         port->uartclk   = 0;
         port->fifosize  = MUX_FIFO_SIZE;
         port->ops   = &mux_pops;
         port->flags = UPF_BOOT_AUTOCONF;
         port->line  = port_cnt;
         port->has_sysrq = IS_ENABLED(CONFIG_SERIAL_MUX_CONSOLE);
 
         spin_lock_init(&port->lock);
 
         status = uart_add_one_port(&mux_driver, port);
         BUG_ON(status);
     }
 
     return 0;
 }
 
 static void __exit mux_remove(struct parisc_device *dev)
 {
     int i, j;
     int port_count = (long)dev_get_drvdata(&dev->dev);
 
     /* Find Port 0 for this card in the mux_ports list. */
     for(i = 0; i < port_cnt; ++i) {
         if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
             break;
     }
     BUG_ON(i + port_count > port_cnt);
 
     /* Release the resources associated with each port on the device. */
     for(j = 0; j < port_count; ++j, ++i) {
         struct uart_port *port = &mux_ports[i].port;
 
         uart_remove_one_port(&mux_driver, port);
         if(port->membase)
             iounmap(port->membase);
     }
 
     release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
 }
 
 /* Hack.  This idea was taken from the 8250_gsc.c on how to properly order
  * the serial port detection in the proper order.   The idea is we always
  * want the builtin mux to be detected before addin mux cards, so we
  * specifically probe for the builtin mux cards first.
  *
  * This table only contains the parisc_device_id of known builtin mux
  * devices.  All other mux cards will be detected by the generic mux_tbl.
  */
 static const struct parisc_device_id builtin_mux_tbl[] __initconst = {
     { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
     { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
     { 0, }
 };
 
 static const struct parisc_device_id mux_tbl[] __initconst = {
     { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
     { 0, }
 };
 
 MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
 MODULE_DEVICE_TABLE(parisc, mux_tbl);
 
 static struct parisc_driver builtin_serial_mux_driver __refdata = {
     .name =     "builtin_serial_mux",
     .id_table = builtin_mux_tbl,
     .probe =    mux_probe,
     .remove =       __exit_p(mux_remove),
 };
 
 static struct parisc_driver serial_mux_driver __refdata = {
     .name =     "serial_mux",
     .id_table = mux_tbl,
     .probe =    mux_probe,
     .remove =       __exit_p(mux_remove),
 };
 
 /**
  * mux_init - Serial MUX initialization procedure.
  *
  * Register the Serial MUX driver.
  */
 static int __init mux_init(void)
 {
     register_parisc_driver(&builtin_serial_mux_driver);
     register_parisc_driver(&serial_mux_driver);
 
     if(port_cnt > 0) {
         /* Start the Mux timer */
         timer_setup(&mux_timer, mux_poll, 0);
         mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 
 #ifdef CONFIG_SERIAL_MUX_CONSOLE
             register_console(&mux_console);
 #endif
     }
 
     return 0;
 }
 
 /**
  * mux_exit - Serial MUX cleanup procedure.
  *
  * Unregister the Serial MUX driver from the tty layer.
  */
 static void __exit mux_exit(void)
 {
     /* Delete the Mux timer. */
     if(port_cnt > 0) {
         del_timer_sync(&mux_timer);
 #ifdef CONFIG_SERIAL_MUX_CONSOLE
         unregister_console(&mux_console);
 #endif
     }
 
     unregister_parisc_driver(&builtin_serial_mux_driver);
     unregister_parisc_driver(&serial_mux_driver);
     uart_unregister_driver(&mux_driver);
 }
 
 module_init(mux_init);
 module_exit(mux_exit);
 
 MODULE_AUTHOR("Ryan Bradetich");
 MODULE_DESCRIPTION("Serial MUX driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);

This page was automatically generated by the 2.1.0 LXR engine. The LXR team