3 ** serial driver for the Mux console found in some PA-RISC servers.
5 ** (c) Copyright 2002 Ryan Bradetich
6 ** (c) Copyright 2002 Hewlett-Packard Company
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.
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.
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>
30 #include <asm/parisc-device.h>
32 #ifdef CONFIG_MAGIC_SYSRQ
33 #include <linux/sysrq.h>
37 #include <linux/serial_core.h>
39 #define MUX_OFFSET 0x800
40 #define MUX_LINE_OFFSET 0x80
42 #define MUX_FIFO_SIZE 255
43 #define MUX_POLL_DELAY (30 * HZ / 1000)
45 #define IO_DATA_REG_OFFSET 0x3c
46 #define IO_DCOUNT_REG_OFFSET 0x40
48 #define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
49 #define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
50 #define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
53 static unsigned int port_cnt __read_mostly;
55 struct uart_port port;
58 static struct mux_port mux_ports[MUX_NR];
60 static struct uart_driver mux_driver = {
62 .driver_name = "ttyB",
69 static struct timer_list mux_timer;
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
76 * mux_tx_empty - Check if the transmitter fifo is empty.
77 * @port: Ptr to the uart_port.
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.
83 static unsigned int mux_tx_empty(struct uart_port *port)
85 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
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.
93 * The Serial MUX does not support CTS, DCD or DSR so this function
96 static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
101 * mux_get_mctrl - Returns the current state of modem control inputs.
102 * @port: Ptr to the uart_port.
104 * The Serial MUX does not support CTS, DCD or DSR so these lines are
105 * treated as permanently active.
107 static unsigned int mux_get_mctrl(struct uart_port *port)
109 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
113 * mux_stop_tx - Stop transmitting characters.
114 * @port: Ptr to the uart_port.
116 * The Serial MUX does not support this function.
118 static void mux_stop_tx(struct uart_port *port)
123 * mux_start_tx - Start transmitting characters.
124 * @port: Ptr to the uart_port.
126 * The Serial Mux does not support this function.
128 static void mux_start_tx(struct uart_port *port)
133 * mux_stop_rx - Stop receiving characters.
134 * @port: Ptr to the uart_port.
136 * The Serial Mux does not support this function.
138 static void mux_stop_rx(struct uart_port *port)
143 * mux_enable_ms - Enable modum status interrupts.
144 * @port: Ptr to the uart_port.
146 * The Serial Mux does not support this function.
148 static void mux_enable_ms(struct uart_port *port)
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.
157 * The Serial Mux does not support this function.
159 static void mux_break_ctl(struct uart_port *port, int break_state)
164 * mux_write - Write chars to the mux fifo.
165 * @port: Ptr to the uart_port.
167 * This function writes all the data from the uart buffer to
170 static void mux_write(struct uart_port *port)
173 struct circ_buf *xmit = &port->info->xmit;
176 UART_PUT_CHAR(port, port->x_char);
182 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
187 count = (port->fifosize) - UART_GET_FIFO_CNT(port);
189 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
190 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
192 if(uart_circ_empty(xmit))
195 } while(--count > 0);
197 while(UART_GET_FIFO_CNT(port))
200 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
201 uart_write_wakeup(port);
203 if (uart_circ_empty(xmit))
208 * mux_read - Read chars from the mux fifo.
209 * @port: Ptr to the uart_port.
211 * This reads all available data from the mux's fifo and pushes
212 * the data to the tty layer.
214 static void mux_read(struct uart_port *port)
217 struct tty_struct *tty = port->info->tty;
218 __u32 start_count = port->icount.rx;
221 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
223 if (MUX_STATUS(data))
226 if (MUX_EOFIFO(data))
231 if (MUX_BREAK(data)) {
233 if(uart_handle_break(port))
237 if (uart_handle_sysrq_char(port, data & 0xffu))
240 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
243 if (start_count != port->icount.rx) {
244 tty_flip_buffer_push(tty);
249 * mux_startup - Initialize the port.
250 * @port: Ptr to the uart_port.
252 * Grab any resources needed for this port and start the
255 static int mux_startup(struct uart_port *port)
257 mux_ports[port->line].enabled = 1;
262 * mux_shutdown - Disable the port.
263 * @port: Ptr to the uart_port.
265 * Release any resources needed for the port.
267 static void mux_shutdown(struct uart_port *port)
269 mux_ports[port->line].enabled = 0;
273 * mux_set_termios - Chane port parameters.
274 * @port: Ptr to the uart_port.
275 * @termios: new termios settings.
276 * @old: old termios settings.
278 * The Serial Mux does not support this function.
281 mux_set_termios(struct uart_port *port, struct termios *termios,
287 * mux_type - Describe the port.
288 * @port: Ptr to the uart_port.
290 * Return a pointer to a string constant describing the
293 static const char *mux_type(struct uart_port *port)
299 * mux_release_port - Release memory and IO regions.
300 * @port: Ptr to the uart_port.
302 * Release any memory and IO region resources currently in use by
305 static void mux_release_port(struct uart_port *port)
310 * mux_request_port - Request memory and IO regions.
311 * @port: Ptr to the uart_port.
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.
317 static int mux_request_port(struct uart_port *port)
323 * mux_config_port - Perform port autoconfiguration.
324 * @port: Ptr to the uart_port.
325 * @type: Bitmask of required configurations.
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
333 static void mux_config_port(struct uart_port *port, int type)
335 port->type = PORT_MUX;
339 * mux_verify_port - Verify the port information.
340 * @port: Ptr to the uart_port.
341 * @ser: Ptr to the serial information.
343 * Verify the new serial port information contained within serinfo is
344 * suitable for this port type.
346 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
348 if(port->membase == NULL)
355 * mux_drv_poll - Mux poll function.
356 * @unused: Unused variable
358 * This function periodically polls the Serial MUX to check for new data.
360 static void mux_poll(unsigned long unused)
364 for(i = 0; i < port_cnt; ++i) {
365 if(!mux_ports[i].enabled)
368 mux_read(&mux_ports[i].port);
369 mux_write(&mux_ports[i].port);
372 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
376 #ifdef CONFIG_SERIAL_MUX_CONSOLE
377 static void mux_console_write(struct console *co, const char *s, unsigned count)
379 /* Wait until the FIFO drains. */
380 while(UART_GET_FIFO_CNT(&mux_ports[0].port))
385 UART_PUT_CHAR(&mux_ports[0].port, '\r');
387 UART_PUT_CHAR(&mux_ports[0].port, *s++);
392 static int mux_console_setup(struct console *co, char *options)
397 struct tty_driver *mux_console_device(struct console *co, int *index)
400 return mux_driver.tty_driver;
403 static struct console mux_console = {
405 .write = mux_console_write,
406 .device = mux_console_device,
407 .setup = mux_console_setup,
408 .flags = CON_ENABLED | CON_PRINTBUFFER,
412 #define MUX_CONSOLE &mux_console
414 #define MUX_CONSOLE NULL
417 static struct uart_ops mux_pops = {
418 .tx_empty = mux_tx_empty,
419 .set_mctrl = mux_set_mctrl,
420 .get_mctrl = mux_get_mctrl,
421 .stop_tx = mux_stop_tx,
422 .start_tx = mux_start_tx,
423 .stop_rx = mux_stop_rx,
424 .enable_ms = mux_enable_ms,
425 .break_ctl = mux_break_ctl,
426 .startup = mux_startup,
427 .shutdown = mux_shutdown,
428 .set_termios = mux_set_termios,
430 .release_port = mux_release_port,
431 .request_port = mux_request_port,
432 .config_port = mux_config_port,
433 .verify_port = mux_verify_port,
437 * mux_probe - Determine if the Serial Mux should claim this device.
438 * @dev: The parisc device.
440 * Deterimine if the Serial Mux should claim this chip (return 0)
443 static int __init mux_probe(struct parisc_device *dev)
445 int i, status, port_count;
447 unsigned long bytecnt;
449 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
450 if(status != PDC_OK) {
451 printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
455 port_count = GET_MUX_PORTS(iodc_data);
456 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
458 dev_set_drvdata(&dev->dev, (void *)(long)port_count);
459 request_mem_region(dev->hpa.start + MUX_OFFSET,
460 port_count * MUX_LINE_OFFSET, "Mux");
463 mux_driver.cons = MUX_CONSOLE;
465 status = uart_register_driver(&mux_driver);
467 printk(KERN_ERR "Serial mux: Unable to register driver.\n");
472 for(i = 0; i < port_count; ++i, ++port_cnt) {
473 struct uart_port *port = &mux_ports[port_cnt].port;
475 port->mapbase = dev->hpa.start + MUX_OFFSET +
476 (i * MUX_LINE_OFFSET);
477 port->membase = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
478 port->iotype = UPIO_MEM;
479 port->type = PORT_MUX;
482 port->fifosize = MUX_FIFO_SIZE;
483 port->ops = &mux_pops;
484 port->flags = UPF_BOOT_AUTOCONF;
485 port->line = port_cnt;
487 /* The port->timeout needs to match what is present in
488 * uart_wait_until_sent in serial_core.c. Otherwise
489 * the time spent in msleep_interruptable will be very
490 * long, causing the appearance of a console hang.
492 port->timeout = HZ / 50;
493 spin_lock_init(&port->lock);
495 status = uart_add_one_port(&mux_driver, port);
502 static int __devexit mux_remove(struct parisc_device *dev)
505 int port_count = (long)dev_get_drvdata(&dev->dev);
507 /* Find Port 0 for this card in the mux_ports list. */
508 for(i = 0; i < port_cnt; ++i) {
509 if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
512 BUG_ON(i + port_count > port_cnt);
514 /* Release the resources associated with each port on the device. */
515 for(j = 0; j < port_count; ++j, ++i) {
516 struct uart_port *port = &mux_ports[i].port;
518 uart_remove_one_port(&mux_driver, port);
520 iounmap(port->membase);
523 release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
527 /* Hack. This idea was taken from the 8250_gsc.c on how to properly order
528 * the serial port detection in the proper order. The idea is we always
529 * want the builtin mux to be detected before addin mux cards, so we
530 * specifically probe for the builtin mux cards first.
532 * This table only contains the parisc_device_id of known builtin mux
533 * devices. All other mux cards will be detected by the generic mux_tbl.
535 static struct parisc_device_id builtin_mux_tbl[] = {
536 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
537 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
541 static struct parisc_device_id mux_tbl[] = {
542 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
546 MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
547 MODULE_DEVICE_TABLE(parisc, mux_tbl);
549 static struct parisc_driver builtin_serial_mux_driver = {
550 .name = "builtin_serial_mux",
551 .id_table = builtin_mux_tbl,
553 .remove = __devexit_p(mux_remove),
556 static struct parisc_driver serial_mux_driver = {
557 .name = "serial_mux",
560 .remove = __devexit_p(mux_remove),
564 * mux_init - Serial MUX initalization procedure.
566 * Register the Serial MUX driver.
568 static int __init mux_init(void)
570 register_parisc_driver(&builtin_serial_mux_driver);
571 register_parisc_driver(&serial_mux_driver);
574 /* Start the Mux timer */
575 init_timer(&mux_timer);
576 mux_timer.function = mux_poll;
577 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
579 #ifdef CONFIG_SERIAL_MUX_CONSOLE
580 register_console(&mux_console);
588 * mux_exit - Serial MUX cleanup procedure.
590 * Unregister the Serial MUX driver from the tty layer.
592 static void __exit mux_exit(void)
594 /* Delete the Mux timer. */
596 del_timer(&mux_timer);
597 #ifdef CONFIG_SERIAL_MUX_CONSOLE
598 unregister_console(&mux_console);
602 unregister_parisc_driver(&builtin_serial_mux_driver);
603 unregister_parisc_driver(&serial_mux_driver);
604 uart_unregister_driver(&mux_driver);
607 module_init(mux_init);
608 module_exit(mux_exit);
610 MODULE_AUTHOR("Ryan Bradetich");
611 MODULE_DESCRIPTION("Serial MUX driver");
612 MODULE_LICENSE("GPL");
613 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);