584 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3** mux.c:4** serial driver for the Mux console found in some PA-RISC servers.5**6** (c) Copyright 2002 Ryan Bradetich7** (c) Copyright 2002 Hewlett-Packard Company8**9** This Driver currently only supports the console (port 0) on the MUX.10** Additional work will be needed on this driver to enable the full11** functionality of the MUX.12**13*/14 15#include <linux/module.h>16#include <linux/ioport.h>17#include <linux/init.h>18#include <linux/serial.h>19#include <linux/tty.h>20#include <linux/tty_flip.h>21#include <linux/console.h>22#include <linux/delay.h> /* for udelay */23#include <linux/device.h>24#include <linux/io.h>25#include <asm/irq.h>26#include <asm/parisc-device.h>27 28#include <linux/sysrq.h>29#include <linux/serial_core.h>30 31#define MUX_OFFSET 0x80032#define MUX_LINE_OFFSET 0x8033 34#define MUX_FIFO_SIZE 25535#define MUX_POLL_DELAY (30 * HZ / 1000)36 37#define IO_DATA_REG_OFFSET 0x3c38#define IO_DCOUNT_REG_OFFSET 0x4039 40#define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)41#define MUX_STATUS(status) ((status & 0xF000) == 0x8000)42#define MUX_BREAK(status) ((status & 0xF000) == 0x2000)43 44#define MUX_NR 25645static unsigned int port_cnt __read_mostly;46struct mux_port {47 struct uart_port port;48 int enabled;49};50static struct mux_port mux_ports[MUX_NR];51 52static struct uart_driver mux_driver = {53 .owner = THIS_MODULE,54 .driver_name = "ttyB",55 .dev_name = "ttyB",56 .major = MUX_MAJOR,57 .minor = 0,58 .nr = MUX_NR,59};60 61static struct timer_list mux_timer;62 63#define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)64#define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)65 66/**67 * get_mux_port_count - Get the number of available ports on the Mux.68 * @dev: The parisc device.69 *70 * This function is used to determine the number of ports the Mux71 * supports. The IODC data reports the number of ports the Mux72 * can support, but there are cases where not all the Mux ports73 * are connected. This function can override the IODC and74 * return the true port count.75 */76static int __init get_mux_port_count(struct parisc_device *dev)77{78 int status;79 u8 iodc_data[32];80 unsigned long bytecnt;81 82 /* If this is the built-in Mux for the K-Class (Eole CAP/MUX),83 * we only need to allocate resources for 1 port since the84 * other 7 ports are not connected.85 */86 if(dev->id.hversion == 0x15)87 return 1;88 89 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);90 BUG_ON(status != PDC_OK);91 92 /* Return the number of ports specified in the iodc data. */93 return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8;94}95 96/**97 * mux_tx_empty - Check if the transmitter fifo is empty.98 * @port: Ptr to the uart_port.99 *100 * This function test if the transmitter fifo for the port101 * described by 'port' is empty. If it is empty, this function102 * should return TIOCSER_TEMT, otherwise return 0.103 */104static unsigned int mux_tx_empty(struct uart_port *port)105{106 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;107} 108 109/**110 * mux_set_mctrl - Set the current state of the modem control inputs.111 * @ports: Ptr to the uart_port.112 * @mctrl: Modem control bits.113 *114 * The Serial MUX does not support CTS, DCD or DSR so this function115 * is ignored.116 */117static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)118{119}120 121/**122 * mux_get_mctrl - Returns the current state of modem control inputs.123 * @port: Ptr to the uart_port.124 *125 * The Serial MUX does not support CTS, DCD or DSR so these lines are126 * treated as permanently active.127 */128static unsigned int mux_get_mctrl(struct uart_port *port)129{ 130 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;131}132 133/**134 * mux_stop_tx - Stop transmitting characters.135 * @port: Ptr to the uart_port.136 *137 * The Serial MUX does not support this function.138 */139static void mux_stop_tx(struct uart_port *port)140{141}142 143/**144 * mux_start_tx - Start transmitting characters.145 * @port: Ptr to the uart_port.146 *147 * The Serial Mux does not support this function.148 */149static void mux_start_tx(struct uart_port *port)150{151}152 153/**154 * mux_stop_rx - Stop receiving characters.155 * @port: Ptr to the uart_port.156 *157 * The Serial Mux does not support this function.158 */159static void mux_stop_rx(struct uart_port *port)160{161}162 163/**164 * mux_break_ctl - Control the transmitssion of a break signal.165 * @port: Ptr to the uart_port.166 * @break_state: Raise/Lower the break signal.167 *168 * The Serial Mux does not support this function.169 */170static void mux_break_ctl(struct uart_port *port, int break_state)171{172}173 174static void mux_tx_done(struct uart_port *port)175{176 /* FIXME js: really needs to wait? */177 while (UART_GET_FIFO_CNT(port))178 udelay(1);179}180 181/**182 * mux_write - Write chars to the mux fifo.183 * @port: Ptr to the uart_port.184 *185 * This function writes all the data from the uart buffer to186 * the mux fifo.187 */188static void mux_write(struct uart_port *port)189{190 u8 ch;191 192 uart_port_tx_limited(port, ch,193 port->fifosize - UART_GET_FIFO_CNT(port),194 true,195 UART_PUT_CHAR(port, ch),196 mux_tx_done(port));197}198 199/**200 * mux_read - Read chars from the mux fifo.201 * @port: Ptr to the uart_port.202 *203 * This reads all available data from the mux's fifo and pushes204 * the data to the tty layer.205 */206static void mux_read(struct uart_port *port)207{208 struct tty_port *tport = &port->state->port;209 int data;210 __u32 start_count = port->icount.rx;211 212 while(1) {213 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);214 215 if (MUX_STATUS(data))216 continue;217 218 if (MUX_EOFIFO(data))219 break;220 221 port->icount.rx++;222 223 if (MUX_BREAK(data)) {224 port->icount.brk++;225 if(uart_handle_break(port))226 continue;227 }228 229 if (uart_handle_sysrq_char(port, data & 0xffu))230 continue;231 232 tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL);233 }234 235 if (start_count != port->icount.rx)236 tty_flip_buffer_push(tport);237}238 239/**240 * mux_startup - Initialize the port.241 * @port: Ptr to the uart_port.242 *243 * Grab any resources needed for this port and start the244 * mux timer.245 */246static int mux_startup(struct uart_port *port)247{248 mux_ports[port->line].enabled = 1;249 return 0;250}251 252/**253 * mux_shutdown - Disable the port.254 * @port: Ptr to the uart_port.255 *256 * Release any resources needed for the port.257 */258static void mux_shutdown(struct uart_port *port)259{260 mux_ports[port->line].enabled = 0;261}262 263/**264 * mux_set_termios - Chane port parameters.265 * @port: Ptr to the uart_port.266 * @termios: new termios settings.267 * @old: old termios settings.268 *269 * The Serial Mux does not support this function.270 */271static void272mux_set_termios(struct uart_port *port, struct ktermios *termios,273 const struct ktermios *old)274{275}276 277/**278 * mux_type - Describe the port.279 * @port: Ptr to the uart_port.280 *281 * Return a pointer to a string constant describing the282 * specified port.283 */284static const char *mux_type(struct uart_port *port)285{286 return "Mux";287}288 289/**290 * mux_release_port - Release memory and IO regions.291 * @port: Ptr to the uart_port.292 * 293 * Release any memory and IO region resources currently in use by294 * the port.295 */296static void mux_release_port(struct uart_port *port)297{298}299 300/**301 * mux_request_port - Request memory and IO regions.302 * @port: Ptr to the uart_port.303 *304 * Request any memory and IO region resources required by the port.305 * If any fail, no resources should be registered when this function306 * returns, and it should return -EBUSY on failure.307 */308static int mux_request_port(struct uart_port *port)309{310 return 0;311}312 313/**314 * mux_config_port - Perform port autoconfiguration.315 * @port: Ptr to the uart_port.316 * @type: Bitmask of required configurations.317 *318 * Perform any autoconfiguration steps for the port. This function is319 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.320 * [Note: This is required for now because of a bug in the Serial core.321 * rmk has already submitted a patch to linus, should be available for322 * 2.5.47.]323 */324static void mux_config_port(struct uart_port *port, int type)325{326 port->type = PORT_MUX;327}328 329/**330 * mux_verify_port - Verify the port information.331 * @port: Ptr to the uart_port.332 * @ser: Ptr to the serial information.333 *334 * Verify the new serial port information contained within serinfo is335 * suitable for this port type.336 */337static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)338{339 if(port->membase == NULL)340 return -EINVAL;341 342 return 0;343}344 345/**346 * mux_drv_poll - Mux poll function.347 * @unused: Unused variable348 *349 * This function periodically polls the Serial MUX to check for new data.350 */351static void mux_poll(struct timer_list *unused)352{ 353 int i;354 355 for(i = 0; i < port_cnt; ++i) {356 if(!mux_ports[i].enabled)357 continue;358 359 mux_read(&mux_ports[i].port);360 mux_write(&mux_ports[i].port);361 }362 363 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);364}365 366 367#ifdef CONFIG_SERIAL_MUX_CONSOLE368static void mux_console_write(struct console *co, const char *s, unsigned count)369{370 /* Wait until the FIFO drains. */371 while(UART_GET_FIFO_CNT(&mux_ports[0].port))372 udelay(1);373 374 while(count--) {375 if(*s == '\n') {376 UART_PUT_CHAR(&mux_ports[0].port, '\r');377 }378 UART_PUT_CHAR(&mux_ports[0].port, *s++);379 }380 381}382 383static int mux_console_setup(struct console *co, char *options)384{385 return 0;386}387 388static struct console mux_console = {389 .name = "ttyB",390 .write = mux_console_write,391 .device = uart_console_device,392 .setup = mux_console_setup,393 .flags = CON_ENABLED | CON_PRINTBUFFER,394 .index = 0,395 .data = &mux_driver,396};397 398#define MUX_CONSOLE &mux_console399#else400#define MUX_CONSOLE NULL401#endif402 403static const 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 .break_ctl = mux_break_ctl,411 .startup = mux_startup,412 .shutdown = mux_shutdown,413 .set_termios = mux_set_termios,414 .type = mux_type,415 .release_port = mux_release_port,416 .request_port = mux_request_port,417 .config_port = mux_config_port,418 .verify_port = mux_verify_port,419};420 421/**422 * mux_probe - Determine if the Serial Mux should claim this device.423 * @dev: The parisc device.424 *425 * Deterimine if the Serial Mux should claim this chip (return 0)426 * or not (return 1).427 */428static int __init mux_probe(struct parisc_device *dev)429{430 int i, status;431 432 int port_count = get_mux_port_count(dev);433 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);434 435 dev_set_drvdata(&dev->dev, (void *)(long)port_count);436 request_mem_region(dev->hpa.start + MUX_OFFSET,437 port_count * MUX_LINE_OFFSET, "Mux");438 439 if(!port_cnt) {440 mux_driver.cons = MUX_CONSOLE;441 442 status = uart_register_driver(&mux_driver);443 if(status) {444 printk(KERN_ERR "Serial mux: Unable to register driver.\n");445 return 1;446 }447 }448 449 for(i = 0; i < port_count; ++i, ++port_cnt) {450 struct uart_port *port = &mux_ports[port_cnt].port;451 port->iobase = 0;452 port->mapbase = dev->hpa.start + MUX_OFFSET +453 (i * MUX_LINE_OFFSET);454 port->membase = ioremap(port->mapbase, MUX_LINE_OFFSET);455 port->iotype = UPIO_MEM;456 port->type = PORT_MUX;457 port->irq = 0;458 port->uartclk = 0;459 port->fifosize = MUX_FIFO_SIZE;460 port->ops = &mux_pops;461 port->flags = UPF_BOOT_AUTOCONF;462 port->line = port_cnt;463 port->has_sysrq = IS_ENABLED(CONFIG_SERIAL_MUX_CONSOLE);464 465 spin_lock_init(&port->lock);466 467 status = uart_add_one_port(&mux_driver, port);468 BUG_ON(status);469 }470 471 return 0;472}473 474static void __exit mux_remove(struct parisc_device *dev)475{476 int i, j;477 int port_count = (long)dev_get_drvdata(&dev->dev);478 479 /* Find Port 0 for this card in the mux_ports list. */480 for(i = 0; i < port_cnt; ++i) {481 if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)482 break;483 }484 BUG_ON(i + port_count > port_cnt);485 486 /* Release the resources associated with each port on the device. */487 for(j = 0; j < port_count; ++j, ++i) {488 struct uart_port *port = &mux_ports[i].port;489 490 uart_remove_one_port(&mux_driver, port);491 if(port->membase)492 iounmap(port->membase);493 }494 495 release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);496}497 498/* Hack. This idea was taken from the 8250_gsc.c on how to properly order499 * the serial port detection in the proper order. The idea is we always500 * want the builtin mux to be detected before addin mux cards, so we501 * specifically probe for the builtin mux cards first.502 *503 * This table only contains the parisc_device_id of known builtin mux504 * devices. All other mux cards will be detected by the generic mux_tbl.505 */506static const struct parisc_device_id builtin_mux_tbl[] __initconst = {507 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */508 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */509 { 0, }510};511 512static const struct parisc_device_id mux_tbl[] __initconst = {513 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },514 { 0, }515};516 517MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);518MODULE_DEVICE_TABLE(parisc, mux_tbl);519 520static struct parisc_driver builtin_serial_mux_driver __refdata = {521 .name = "builtin_serial_mux",522 .id_table = builtin_mux_tbl,523 .probe = mux_probe,524 .remove = __exit_p(mux_remove),525};526 527static struct parisc_driver serial_mux_driver __refdata = {528 .name = "serial_mux",529 .id_table = mux_tbl,530 .probe = mux_probe,531 .remove = __exit_p(mux_remove),532};533 534/**535 * mux_init - Serial MUX initialization procedure.536 *537 * Register the Serial MUX driver.538 */539static int __init mux_init(void)540{541 register_parisc_driver(&builtin_serial_mux_driver);542 register_parisc_driver(&serial_mux_driver);543 544 if(port_cnt > 0) {545 /* Start the Mux timer */546 timer_setup(&mux_timer, mux_poll, 0);547 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);548 549#ifdef CONFIG_SERIAL_MUX_CONSOLE550 register_console(&mux_console);551#endif552 }553 554 return 0;555}556 557/**558 * mux_exit - Serial MUX cleanup procedure.559 *560 * Unregister the Serial MUX driver from the tty layer.561 */562static void __exit mux_exit(void)563{564 /* Delete the Mux timer. */565 if(port_cnt > 0) {566 del_timer_sync(&mux_timer);567#ifdef CONFIG_SERIAL_MUX_CONSOLE568 unregister_console(&mux_console);569#endif570 }571 572 unregister_parisc_driver(&builtin_serial_mux_driver);573 unregister_parisc_driver(&serial_mux_driver);574 uart_unregister_driver(&mux_driver);575}576 577module_init(mux_init);578module_exit(mux_exit);579 580MODULE_AUTHOR("Ryan Bradetich");581MODULE_DESCRIPTION("Serial MUX driver");582MODULE_LICENSE("GPL");583MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);584