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)
75 * get_mux_port_count - Get the number of available ports on the Mux.
76 * @dev: The parisc device.
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.
84 static int __init
get_mux_port_count(struct parisc_device
*dev
)
88 unsigned long bytecnt
;
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.
94 if(dev
->id
.hversion
== 0x15)
97 status
= pdc_iodc_read(&bytecnt
, dev
->hpa
.start
, 0, iodc_data
, 32);
98 BUG_ON(status
!= PDC_OK
);
100 /* Return the number of ports specified in the iodc data. */
101 return ((((iodc_data
)[4] & 0xf0) >> 4) * 8) + 8;
105 * mux_tx_empty - Check if the transmitter fifo is empty.
106 * @port: Ptr to the uart_port.
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.
112 static unsigned int mux_tx_empty(struct uart_port
*port
)
114 return UART_GET_FIFO_CNT(port
) ? 0 : TIOCSER_TEMT
;
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.
122 * The Serial MUX does not support CTS, DCD or DSR so this function
125 static void mux_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
130 * mux_get_mctrl - Returns the current state of modem control inputs.
131 * @port: Ptr to the uart_port.
133 * The Serial MUX does not support CTS, DCD or DSR so these lines are
134 * treated as permanently active.
136 static unsigned int mux_get_mctrl(struct uart_port
*port
)
138 return TIOCM_CAR
| TIOCM_DSR
| TIOCM_CTS
;
142 * mux_stop_tx - Stop transmitting characters.
143 * @port: Ptr to the uart_port.
145 * The Serial MUX does not support this function.
147 static void mux_stop_tx(struct uart_port
*port
)
152 * mux_start_tx - Start transmitting characters.
153 * @port: Ptr to the uart_port.
155 * The Serial Mux does not support this function.
157 static void mux_start_tx(struct uart_port
*port
)
162 * mux_stop_rx - Stop receiving characters.
163 * @port: Ptr to the uart_port.
165 * The Serial Mux does not support this function.
167 static void mux_stop_rx(struct uart_port
*port
)
172 * mux_enable_ms - Enable modum status interrupts.
173 * @port: Ptr to the uart_port.
175 * The Serial Mux does not support this function.
177 static void mux_enable_ms(struct uart_port
*port
)
182 * mux_break_ctl - Control the transmitssion of a break signal.
183 * @port: Ptr to the uart_port.
184 * @break_state: Raise/Lower the break signal.
186 * The Serial Mux does not support this function.
188 static void mux_break_ctl(struct uart_port
*port
, int break_state
)
193 * mux_write - Write chars to the mux fifo.
194 * @port: Ptr to the uart_port.
196 * This function writes all the data from the uart buffer to
199 static void mux_write(struct uart_port
*port
)
202 struct circ_buf
*xmit
= &port
->info
->xmit
;
205 UART_PUT_CHAR(port
, port
->x_char
);
211 if(uart_circ_empty(xmit
) || uart_tx_stopped(port
)) {
216 count
= (port
->fifosize
) - UART_GET_FIFO_CNT(port
);
218 UART_PUT_CHAR(port
, xmit
->buf
[xmit
->tail
]);
219 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
221 if(uart_circ_empty(xmit
))
224 } while(--count
> 0);
226 while(UART_GET_FIFO_CNT(port
))
229 if(uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
230 uart_write_wakeup(port
);
232 if (uart_circ_empty(xmit
))
237 * mux_read - Read chars from the mux fifo.
238 * @port: Ptr to the uart_port.
240 * This reads all available data from the mux's fifo and pushes
241 * the data to the tty layer.
243 static void mux_read(struct uart_port
*port
)
246 struct tty_struct
*tty
= port
->info
->tty
;
247 __u32 start_count
= port
->icount
.rx
;
250 data
= __raw_readl(port
->membase
+ IO_DATA_REG_OFFSET
);
252 if (MUX_STATUS(data
))
255 if (MUX_EOFIFO(data
))
260 if (MUX_BREAK(data
)) {
262 if(uart_handle_break(port
))
266 if (uart_handle_sysrq_char(port
, data
& 0xffu
))
269 tty_insert_flip_char(tty
, data
& 0xFF, TTY_NORMAL
);
272 if (start_count
!= port
->icount
.rx
) {
273 tty_flip_buffer_push(tty
);
278 * mux_startup - Initialize the port.
279 * @port: Ptr to the uart_port.
281 * Grab any resources needed for this port and start the
284 static int mux_startup(struct uart_port
*port
)
286 mux_ports
[port
->line
].enabled
= 1;
291 * mux_shutdown - Disable the port.
292 * @port: Ptr to the uart_port.
294 * Release any resources needed for the port.
296 static void mux_shutdown(struct uart_port
*port
)
298 mux_ports
[port
->line
].enabled
= 0;
302 * mux_set_termios - Chane port parameters.
303 * @port: Ptr to the uart_port.
304 * @termios: new termios settings.
305 * @old: old termios settings.
307 * The Serial Mux does not support this function.
310 mux_set_termios(struct uart_port
*port
, struct termios
*termios
,
316 * mux_type - Describe the port.
317 * @port: Ptr to the uart_port.
319 * Return a pointer to a string constant describing the
322 static const char *mux_type(struct uart_port
*port
)
328 * mux_release_port - Release memory and IO regions.
329 * @port: Ptr to the uart_port.
331 * Release any memory and IO region resources currently in use by
334 static void mux_release_port(struct uart_port
*port
)
339 * mux_request_port - Request memory and IO regions.
340 * @port: Ptr to the uart_port.
342 * Request any memory and IO region resources required by the port.
343 * If any fail, no resources should be registered when this function
344 * returns, and it should return -EBUSY on failure.
346 static int mux_request_port(struct uart_port
*port
)
352 * mux_config_port - Perform port autoconfiguration.
353 * @port: Ptr to the uart_port.
354 * @type: Bitmask of required configurations.
356 * Perform any autoconfiguration steps for the port. This function is
357 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
358 * [Note: This is required for now because of a bug in the Serial core.
359 * rmk has already submitted a patch to linus, should be available for
362 static void mux_config_port(struct uart_port
*port
, int type
)
364 port
->type
= PORT_MUX
;
368 * mux_verify_port - Verify the port information.
369 * @port: Ptr to the uart_port.
370 * @ser: Ptr to the serial information.
372 * Verify the new serial port information contained within serinfo is
373 * suitable for this port type.
375 static int mux_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
377 if(port
->membase
== NULL
)
384 * mux_drv_poll - Mux poll function.
385 * @unused: Unused variable
387 * This function periodically polls the Serial MUX to check for new data.
389 static void mux_poll(unsigned long unused
)
393 for(i
= 0; i
< port_cnt
; ++i
) {
394 if(!mux_ports
[i
].enabled
)
397 mux_read(&mux_ports
[i
].port
);
398 mux_write(&mux_ports
[i
].port
);
401 mod_timer(&mux_timer
, jiffies
+ MUX_POLL_DELAY
);
405 #ifdef CONFIG_SERIAL_MUX_CONSOLE
406 static void mux_console_write(struct console
*co
, const char *s
, unsigned count
)
408 /* Wait until the FIFO drains. */
409 while(UART_GET_FIFO_CNT(&mux_ports
[0].port
))
414 UART_PUT_CHAR(&mux_ports
[0].port
, '\r');
416 UART_PUT_CHAR(&mux_ports
[0].port
, *s
++);
421 static int mux_console_setup(struct console
*co
, char *options
)
426 struct tty_driver
*mux_console_device(struct console
*co
, int *index
)
429 return mux_driver
.tty_driver
;
432 static struct console mux_console
= {
434 .write
= mux_console_write
,
435 .device
= mux_console_device
,
436 .setup
= mux_console_setup
,
437 .flags
= CON_ENABLED
| CON_PRINTBUFFER
,
441 #define MUX_CONSOLE &mux_console
443 #define MUX_CONSOLE NULL
446 static struct uart_ops mux_pops
= {
447 .tx_empty
= mux_tx_empty
,
448 .set_mctrl
= mux_set_mctrl
,
449 .get_mctrl
= mux_get_mctrl
,
450 .stop_tx
= mux_stop_tx
,
451 .start_tx
= mux_start_tx
,
452 .stop_rx
= mux_stop_rx
,
453 .enable_ms
= mux_enable_ms
,
454 .break_ctl
= mux_break_ctl
,
455 .startup
= mux_startup
,
456 .shutdown
= mux_shutdown
,
457 .set_termios
= mux_set_termios
,
459 .release_port
= mux_release_port
,
460 .request_port
= mux_request_port
,
461 .config_port
= mux_config_port
,
462 .verify_port
= mux_verify_port
,
466 * mux_probe - Determine if the Serial Mux should claim this device.
467 * @dev: The parisc device.
469 * Deterimine if the Serial Mux should claim this chip (return 0)
472 static int __init
mux_probe(struct parisc_device
*dev
)
476 int port_count
= get_mux_port_count(dev
);
477 printk(KERN_INFO
"Serial mux driver (%d ports) Revision: 0.6\n", port_count
);
479 dev_set_drvdata(&dev
->dev
, (void *)(long)port_count
);
480 request_mem_region(dev
->hpa
.start
+ MUX_OFFSET
,
481 port_count
* MUX_LINE_OFFSET
, "Mux");
484 mux_driver
.cons
= MUX_CONSOLE
;
486 status
= uart_register_driver(&mux_driver
);
488 printk(KERN_ERR
"Serial mux: Unable to register driver.\n");
493 for(i
= 0; i
< port_count
; ++i
, ++port_cnt
) {
494 struct uart_port
*port
= &mux_ports
[port_cnt
].port
;
496 port
->mapbase
= dev
->hpa
.start
+ MUX_OFFSET
+
497 (i
* MUX_LINE_OFFSET
);
498 port
->membase
= ioremap_nocache(port
->mapbase
, MUX_LINE_OFFSET
);
499 port
->iotype
= UPIO_MEM
;
500 port
->type
= PORT_MUX
;
503 port
->fifosize
= MUX_FIFO_SIZE
;
504 port
->ops
= &mux_pops
;
505 port
->flags
= UPF_BOOT_AUTOCONF
;
506 port
->line
= port_cnt
;
508 /* The port->timeout needs to match what is present in
509 * uart_wait_until_sent in serial_core.c. Otherwise
510 * the time spent in msleep_interruptable will be very
511 * long, causing the appearance of a console hang.
513 port
->timeout
= HZ
/ 50;
514 spin_lock_init(&port
->lock
);
516 status
= uart_add_one_port(&mux_driver
, port
);
523 static int __devexit
mux_remove(struct parisc_device
*dev
)
526 int port_count
= (long)dev_get_drvdata(&dev
->dev
);
528 /* Find Port 0 for this card in the mux_ports list. */
529 for(i
= 0; i
< port_cnt
; ++i
) {
530 if(mux_ports
[i
].port
.mapbase
== dev
->hpa
.start
+ MUX_OFFSET
)
533 BUG_ON(i
+ port_count
> port_cnt
);
535 /* Release the resources associated with each port on the device. */
536 for(j
= 0; j
< port_count
; ++j
, ++i
) {
537 struct uart_port
*port
= &mux_ports
[i
].port
;
539 uart_remove_one_port(&mux_driver
, port
);
541 iounmap(port
->membase
);
544 release_mem_region(dev
->hpa
.start
+ MUX_OFFSET
, port_count
* MUX_LINE_OFFSET
);
548 /* Hack. This idea was taken from the 8250_gsc.c on how to properly order
549 * the serial port detection in the proper order. The idea is we always
550 * want the builtin mux to be detected before addin mux cards, so we
551 * specifically probe for the builtin mux cards first.
553 * This table only contains the parisc_device_id of known builtin mux
554 * devices. All other mux cards will be detected by the generic mux_tbl.
556 static struct parisc_device_id builtin_mux_tbl
[] = {
557 { HPHW_A_DIRECT
, HVERSION_REV_ANY_ID
, 0x15, 0x0000D }, /* All K-class */
558 { HPHW_A_DIRECT
, HVERSION_REV_ANY_ID
, 0x44, 0x0000D }, /* E35, E45, and E55 */
562 static struct parisc_device_id mux_tbl
[] = {
563 { HPHW_A_DIRECT
, HVERSION_REV_ANY_ID
, HVERSION_ANY_ID
, 0x0000D },
567 MODULE_DEVICE_TABLE(parisc
, builtin_mux_tbl
);
568 MODULE_DEVICE_TABLE(parisc
, mux_tbl
);
570 static struct parisc_driver builtin_serial_mux_driver
= {
571 .name
= "builtin_serial_mux",
572 .id_table
= builtin_mux_tbl
,
574 .remove
= __devexit_p(mux_remove
),
577 static struct parisc_driver serial_mux_driver
= {
578 .name
= "serial_mux",
581 .remove
= __devexit_p(mux_remove
),
585 * mux_init - Serial MUX initalization procedure.
587 * Register the Serial MUX driver.
589 static int __init
mux_init(void)
591 register_parisc_driver(&builtin_serial_mux_driver
);
592 register_parisc_driver(&serial_mux_driver
);
595 /* Start the Mux timer */
596 init_timer(&mux_timer
);
597 mux_timer
.function
= mux_poll
;
598 mod_timer(&mux_timer
, jiffies
+ MUX_POLL_DELAY
);
600 #ifdef CONFIG_SERIAL_MUX_CONSOLE
601 register_console(&mux_console
);
609 * mux_exit - Serial MUX cleanup procedure.
611 * Unregister the Serial MUX driver from the tty layer.
613 static void __exit
mux_exit(void)
615 /* Delete the Mux timer. */
617 del_timer(&mux_timer
);
618 #ifdef CONFIG_SERIAL_MUX_CONSOLE
619 unregister_console(&mux_console
);
623 unregister_parisc_driver(&builtin_serial_mux_driver
);
624 unregister_parisc_driver(&serial_mux_driver
);
625 uart_unregister_driver(&mux_driver
);
628 module_init(mux_init
);
629 module_exit(mux_exit
);
631 MODULE_AUTHOR("Ryan Bradetich");
632 MODULE_DESCRIPTION("Serial MUX driver");
633 MODULE_LICENSE("GPL");
634 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR
);