1 // SPDX-License-Identifier: GPL-2.0+
4 ** serial driver for the Mux console found in some PA-RISC servers.
6 ** (c) Copyright 2002 Ryan Bradetich
7 ** (c) Copyright 2002 Hewlett-Packard Company
9 ** This program is free software; you can redistribute it and/or modify
10 ** it under the terms of the GNU General Public License as published by
11 ** the Free Software Foundation; either version 2 of the License, or
12 ** (at your option) any later version.
14 ** This Driver currently only supports the console (port 0) on the MUX.
15 ** Additional work will be needed on this driver to enable the full
16 ** functionality of the MUX.
20 #include <linux/module.h>
21 #include <linux/ioport.h>
22 #include <linux/init.h>
23 #include <linux/serial.h>
24 #include <linux/tty.h>
25 #include <linux/tty_flip.h>
26 #include <linux/console.h>
27 #include <linux/delay.h> /* for udelay */
28 #include <linux/device.h>
31 #include <asm/parisc-device.h>
33 #if defined(CONFIG_SERIAL_MUX_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
34 #include <linux/sysrq.h>
38 #include <linux/serial_core.h>
40 #define MUX_OFFSET 0x800
41 #define MUX_LINE_OFFSET 0x80
43 #define MUX_FIFO_SIZE 255
44 #define MUX_POLL_DELAY (30 * HZ / 1000)
46 #define IO_DATA_REG_OFFSET 0x3c
47 #define IO_DCOUNT_REG_OFFSET 0x40
49 #define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
50 #define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
51 #define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
54 static unsigned int port_cnt __read_mostly
;
56 struct uart_port port
;
59 static struct mux_port mux_ports
[MUX_NR
];
61 static struct uart_driver mux_driver
= {
63 .driver_name
= "ttyB",
70 static struct timer_list mux_timer
;
72 #define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)
73 #define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)
76 * get_mux_port_count - Get the number of available ports on the Mux.
77 * @dev: The parisc device.
79 * This function is used to determine the number of ports the Mux
80 * supports. The IODC data reports the number of ports the Mux
81 * can support, but there are cases where not all the Mux ports
82 * are connected. This function can override the IODC and
83 * return the true port count.
85 static int __init
get_mux_port_count(struct parisc_device
*dev
)
89 unsigned long bytecnt
;
91 /* If this is the built-in Mux for the K-Class (Eole CAP/MUX),
92 * we only need to allocate resources for 1 port since the
93 * other 7 ports are not connected.
95 if(dev
->id
.hversion
== 0x15)
98 status
= pdc_iodc_read(&bytecnt
, dev
->hpa
.start
, 0, iodc_data
, 32);
99 BUG_ON(status
!= PDC_OK
);
101 /* Return the number of ports specified in the iodc data. */
102 return ((((iodc_data
)[4] & 0xf0) >> 4) * 8) + 8;
106 * mux_tx_empty - Check if the transmitter fifo is empty.
107 * @port: Ptr to the uart_port.
109 * This function test if the transmitter fifo for the port
110 * described by 'port' is empty. If it is empty, this function
111 * should return TIOCSER_TEMT, otherwise return 0.
113 static unsigned int mux_tx_empty(struct uart_port
*port
)
115 return UART_GET_FIFO_CNT(port
) ? 0 : TIOCSER_TEMT
;
119 * mux_set_mctrl - Set the current state of the modem control inputs.
120 * @ports: Ptr to the uart_port.
121 * @mctrl: Modem control bits.
123 * The Serial MUX does not support CTS, DCD or DSR so this function
126 static void mux_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
131 * mux_get_mctrl - Returns the current state of modem control inputs.
132 * @port: Ptr to the uart_port.
134 * The Serial MUX does not support CTS, DCD or DSR so these lines are
135 * treated as permanently active.
137 static unsigned int mux_get_mctrl(struct uart_port
*port
)
139 return TIOCM_CAR
| TIOCM_DSR
| TIOCM_CTS
;
143 * mux_stop_tx - Stop transmitting characters.
144 * @port: Ptr to the uart_port.
146 * The Serial MUX does not support this function.
148 static void mux_stop_tx(struct uart_port
*port
)
153 * mux_start_tx - Start transmitting characters.
154 * @port: Ptr to the uart_port.
156 * The Serial Mux does not support this function.
158 static void mux_start_tx(struct uart_port
*port
)
163 * mux_stop_rx - Stop receiving characters.
164 * @port: Ptr to the uart_port.
166 * The Serial Mux does not support this function.
168 static void mux_stop_rx(struct uart_port
*port
)
173 * mux_break_ctl - Control the transmitssion of a break signal.
174 * @port: Ptr to the uart_port.
175 * @break_state: Raise/Lower the break signal.
177 * The Serial Mux does not support this function.
179 static void mux_break_ctl(struct uart_port
*port
, int break_state
)
184 * mux_write - Write chars to the mux fifo.
185 * @port: Ptr to the uart_port.
187 * This function writes all the data from the uart buffer to
190 static void mux_write(struct uart_port
*port
)
193 struct circ_buf
*xmit
= &port
->state
->xmit
;
196 UART_PUT_CHAR(port
, port
->x_char
);
202 if(uart_circ_empty(xmit
) || uart_tx_stopped(port
)) {
207 count
= (port
->fifosize
) - UART_GET_FIFO_CNT(port
);
209 UART_PUT_CHAR(port
, xmit
->buf
[xmit
->tail
]);
210 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
212 if(uart_circ_empty(xmit
))
215 } while(--count
> 0);
217 while(UART_GET_FIFO_CNT(port
))
220 if(uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
221 uart_write_wakeup(port
);
223 if (uart_circ_empty(xmit
))
228 * mux_read - Read chars from the mux fifo.
229 * @port: Ptr to the uart_port.
231 * This reads all available data from the mux's fifo and pushes
232 * the data to the tty layer.
234 static void mux_read(struct uart_port
*port
)
236 struct tty_port
*tport
= &port
->state
->port
;
238 __u32 start_count
= port
->icount
.rx
;
241 data
= __raw_readl(port
->membase
+ IO_DATA_REG_OFFSET
);
243 if (MUX_STATUS(data
))
246 if (MUX_EOFIFO(data
))
251 if (MUX_BREAK(data
)) {
253 if(uart_handle_break(port
))
257 if (uart_handle_sysrq_char(port
, data
& 0xffu
))
260 tty_insert_flip_char(tport
, data
& 0xFF, TTY_NORMAL
);
263 if (start_count
!= port
->icount
.rx
)
264 tty_flip_buffer_push(tport
);
268 * mux_startup - Initialize the port.
269 * @port: Ptr to the uart_port.
271 * Grab any resources needed for this port and start the
274 static int mux_startup(struct uart_port
*port
)
276 mux_ports
[port
->line
].enabled
= 1;
281 * mux_shutdown - Disable the port.
282 * @port: Ptr to the uart_port.
284 * Release any resources needed for the port.
286 static void mux_shutdown(struct uart_port
*port
)
288 mux_ports
[port
->line
].enabled
= 0;
292 * mux_set_termios - Chane port parameters.
293 * @port: Ptr to the uart_port.
294 * @termios: new termios settings.
295 * @old: old termios settings.
297 * The Serial Mux does not support this function.
300 mux_set_termios(struct uart_port
*port
, struct ktermios
*termios
,
301 struct ktermios
*old
)
306 * mux_type - Describe the port.
307 * @port: Ptr to the uart_port.
309 * Return a pointer to a string constant describing the
312 static const char *mux_type(struct uart_port
*port
)
318 * mux_release_port - Release memory and IO regions.
319 * @port: Ptr to the uart_port.
321 * Release any memory and IO region resources currently in use by
324 static void mux_release_port(struct uart_port
*port
)
329 * mux_request_port - Request memory and IO regions.
330 * @port: Ptr to the uart_port.
332 * Request any memory and IO region resources required by the port.
333 * If any fail, no resources should be registered when this function
334 * returns, and it should return -EBUSY on failure.
336 static int mux_request_port(struct uart_port
*port
)
342 * mux_config_port - Perform port autoconfiguration.
343 * @port: Ptr to the uart_port.
344 * @type: Bitmask of required configurations.
346 * Perform any autoconfiguration steps for the port. This function is
347 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
348 * [Note: This is required for now because of a bug in the Serial core.
349 * rmk has already submitted a patch to linus, should be available for
352 static void mux_config_port(struct uart_port
*port
, int type
)
354 port
->type
= PORT_MUX
;
358 * mux_verify_port - Verify the port information.
359 * @port: Ptr to the uart_port.
360 * @ser: Ptr to the serial information.
362 * Verify the new serial port information contained within serinfo is
363 * suitable for this port type.
365 static int mux_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
367 if(port
->membase
== NULL
)
374 * mux_drv_poll - Mux poll function.
375 * @unused: Unused variable
377 * This function periodically polls the Serial MUX to check for new data.
379 static void mux_poll(unsigned long unused
)
383 for(i
= 0; i
< port_cnt
; ++i
) {
384 if(!mux_ports
[i
].enabled
)
387 mux_read(&mux_ports
[i
].port
);
388 mux_write(&mux_ports
[i
].port
);
391 mod_timer(&mux_timer
, jiffies
+ MUX_POLL_DELAY
);
395 #ifdef CONFIG_SERIAL_MUX_CONSOLE
396 static void mux_console_write(struct console
*co
, const char *s
, unsigned count
)
398 /* Wait until the FIFO drains. */
399 while(UART_GET_FIFO_CNT(&mux_ports
[0].port
))
404 UART_PUT_CHAR(&mux_ports
[0].port
, '\r');
406 UART_PUT_CHAR(&mux_ports
[0].port
, *s
++);
411 static int mux_console_setup(struct console
*co
, char *options
)
416 static struct console mux_console
= {
418 .write
= mux_console_write
,
419 .device
= uart_console_device
,
420 .setup
= mux_console_setup
,
421 .flags
= CON_ENABLED
| CON_PRINTBUFFER
,
426 #define MUX_CONSOLE &mux_console
428 #define MUX_CONSOLE NULL
431 static const struct uart_ops mux_pops
= {
432 .tx_empty
= mux_tx_empty
,
433 .set_mctrl
= mux_set_mctrl
,
434 .get_mctrl
= mux_get_mctrl
,
435 .stop_tx
= mux_stop_tx
,
436 .start_tx
= mux_start_tx
,
437 .stop_rx
= mux_stop_rx
,
438 .break_ctl
= mux_break_ctl
,
439 .startup
= mux_startup
,
440 .shutdown
= mux_shutdown
,
441 .set_termios
= mux_set_termios
,
443 .release_port
= mux_release_port
,
444 .request_port
= mux_request_port
,
445 .config_port
= mux_config_port
,
446 .verify_port
= mux_verify_port
,
450 * mux_probe - Determine if the Serial Mux should claim this device.
451 * @dev: The parisc device.
453 * Deterimine if the Serial Mux should claim this chip (return 0)
456 static int __init
mux_probe(struct parisc_device
*dev
)
460 int port_count
= get_mux_port_count(dev
);
461 printk(KERN_INFO
"Serial mux driver (%d ports) Revision: 0.6\n", port_count
);
463 dev_set_drvdata(&dev
->dev
, (void *)(long)port_count
);
464 request_mem_region(dev
->hpa
.start
+ MUX_OFFSET
,
465 port_count
* MUX_LINE_OFFSET
, "Mux");
468 mux_driver
.cons
= MUX_CONSOLE
;
470 status
= uart_register_driver(&mux_driver
);
472 printk(KERN_ERR
"Serial mux: Unable to register driver.\n");
477 for(i
= 0; i
< port_count
; ++i
, ++port_cnt
) {
478 struct uart_port
*port
= &mux_ports
[port_cnt
].port
;
480 port
->mapbase
= dev
->hpa
.start
+ MUX_OFFSET
+
481 (i
* MUX_LINE_OFFSET
);
482 port
->membase
= ioremap_nocache(port
->mapbase
, MUX_LINE_OFFSET
);
483 port
->iotype
= UPIO_MEM
;
484 port
->type
= PORT_MUX
;
487 port
->fifosize
= MUX_FIFO_SIZE
;
488 port
->ops
= &mux_pops
;
489 port
->flags
= UPF_BOOT_AUTOCONF
;
490 port
->line
= port_cnt
;
492 /* The port->timeout needs to match what is present in
493 * uart_wait_until_sent in serial_core.c. Otherwise
494 * the time spent in msleep_interruptable will be very
495 * long, causing the appearance of a console hang.
497 port
->timeout
= HZ
/ 50;
498 spin_lock_init(&port
->lock
);
500 status
= uart_add_one_port(&mux_driver
, port
);
507 static int __exit
mux_remove(struct parisc_device
*dev
)
510 int port_count
= (long)dev_get_drvdata(&dev
->dev
);
512 /* Find Port 0 for this card in the mux_ports list. */
513 for(i
= 0; i
< port_cnt
; ++i
) {
514 if(mux_ports
[i
].port
.mapbase
== dev
->hpa
.start
+ MUX_OFFSET
)
517 BUG_ON(i
+ port_count
> port_cnt
);
519 /* Release the resources associated with each port on the device. */
520 for(j
= 0; j
< port_count
; ++j
, ++i
) {
521 struct uart_port
*port
= &mux_ports
[i
].port
;
523 uart_remove_one_port(&mux_driver
, port
);
525 iounmap(port
->membase
);
528 release_mem_region(dev
->hpa
.start
+ MUX_OFFSET
, port_count
* MUX_LINE_OFFSET
);
532 /* Hack. This idea was taken from the 8250_gsc.c on how to properly order
533 * the serial port detection in the proper order. The idea is we always
534 * want the builtin mux to be detected before addin mux cards, so we
535 * specifically probe for the builtin mux cards first.
537 * This table only contains the parisc_device_id of known builtin mux
538 * devices. All other mux cards will be detected by the generic mux_tbl.
540 static const struct parisc_device_id builtin_mux_tbl
[] __initconst
= {
541 { HPHW_A_DIRECT
, HVERSION_REV_ANY_ID
, 0x15, 0x0000D }, /* All K-class */
542 { HPHW_A_DIRECT
, HVERSION_REV_ANY_ID
, 0x44, 0x0000D }, /* E35, E45, and E55 */
546 static const struct parisc_device_id mux_tbl
[] __initconst
= {
547 { HPHW_A_DIRECT
, HVERSION_REV_ANY_ID
, HVERSION_ANY_ID
, 0x0000D },
551 MODULE_DEVICE_TABLE(parisc
, builtin_mux_tbl
);
552 MODULE_DEVICE_TABLE(parisc
, mux_tbl
);
554 static struct parisc_driver builtin_serial_mux_driver __refdata
= {
555 .name
= "builtin_serial_mux",
556 .id_table
= builtin_mux_tbl
,
558 .remove
= __exit_p(mux_remove
),
561 static struct parisc_driver serial_mux_driver __refdata
= {
562 .name
= "serial_mux",
565 .remove
= __exit_p(mux_remove
),
569 * mux_init - Serial MUX initialization procedure.
571 * Register the Serial MUX driver.
573 static int __init
mux_init(void)
575 register_parisc_driver(&builtin_serial_mux_driver
);
576 register_parisc_driver(&serial_mux_driver
);
579 /* Start the Mux timer */
580 setup_timer(&mux_timer
, mux_poll
, 0UL);
581 mod_timer(&mux_timer
, jiffies
+ MUX_POLL_DELAY
);
583 #ifdef CONFIG_SERIAL_MUX_CONSOLE
584 register_console(&mux_console
);
592 * mux_exit - Serial MUX cleanup procedure.
594 * Unregister the Serial MUX driver from the tty layer.
596 static void __exit
mux_exit(void)
598 /* Delete the Mux timer. */
600 del_timer_sync(&mux_timer
);
601 #ifdef CONFIG_SERIAL_MUX_CONSOLE
602 unregister_console(&mux_console
);
606 unregister_parisc_driver(&builtin_serial_mux_driver
);
607 unregister_parisc_driver(&serial_mux_driver
);
608 uart_unregister_driver(&mux_driver
);
611 module_init(mux_init
);
612 module_exit(mux_exit
);
614 MODULE_AUTHOR("Ryan Bradetich");
615 MODULE_DESCRIPTION("Serial MUX driver");
616 MODULE_LICENSE("GPL");
617 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR
);