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/config.h>
20 #include <linux/module.h>
21 #include <linux/tty.h>
22 #include <linux/ioport.h>
23 #include <linux/init.h>
24 #include <linux/serial.h>
25 #include <linux/console.h>
26 #include <linux/slab.h>
27 #include <linux/delay.h> /* for udelay */
28 #include <linux/device.h>
31 #include <asm/parisc-device.h>
33 #ifdef 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
= 0;
55 static struct uart_port mux_ports
[MUX_NR
];
57 static struct uart_driver mux_driver
= {
59 .driver_name
= "ttyB",
66 static struct timer_list mux_timer
;
68 #define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)
69 #define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)
70 #define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8
73 * mux_tx_empty - Check if the transmitter fifo is empty.
74 * @port: Ptr to the uart_port.
76 * This function test if the transmitter fifo for the port
77 * described by 'port' is empty. If it is empty, this function
78 * should return TIOCSER_TEMT, otherwise return 0.
80 static unsigned int mux_tx_empty(struct uart_port
*port
)
82 return UART_GET_FIFO_CNT(port
) ? 0 : TIOCSER_TEMT
;
86 * mux_set_mctrl - Set the current state of the modem control inputs.
87 * @ports: Ptr to the uart_port.
88 * @mctrl: Modem control bits.
90 * The Serial MUX does not support CTS, DCD or DSR so this function
93 static void mux_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
98 * mux_get_mctrl - Returns the current state of modem control inputs.
99 * @port: Ptr to the uart_port.
101 * The Serial MUX does not support CTS, DCD or DSR so these lines are
102 * treated as permanently active.
104 static unsigned int mux_get_mctrl(struct uart_port
*port
)
106 return TIOCM_CAR
| TIOCM_DSR
| TIOCM_CTS
;
110 * mux_stop_tx - Stop transmitting characters.
111 * @port: Ptr to the uart_port.
113 * The Serial MUX does not support this function.
115 static void mux_stop_tx(struct uart_port
*port
)
120 * mux_start_tx - Start transmitting characters.
121 * @port: Ptr to the uart_port.
123 * The Serial Mux does not support this function.
125 static void mux_start_tx(struct uart_port
*port
)
130 * mux_stop_rx - Stop receiving characters.
131 * @port: Ptr to the uart_port.
133 * The Serial Mux does not support this function.
135 static void mux_stop_rx(struct uart_port
*port
)
140 * mux_enable_ms - Enable modum status interrupts.
141 * @port: Ptr to the uart_port.
143 * The Serial Mux does not support this function.
145 static void mux_enable_ms(struct uart_port
*port
)
150 * mux_break_ctl - Control the transmitssion of a break signal.
151 * @port: Ptr to the uart_port.
152 * @break_state: Raise/Lower the break signal.
154 * The Serial Mux does not support this function.
156 static void mux_break_ctl(struct uart_port
*port
, int break_state
)
161 * mux_write - Write chars to the mux fifo.
162 * @port: Ptr to the uart_port.
164 * This function writes all the data from the uart buffer to
167 static void mux_write(struct uart_port
*port
)
170 struct circ_buf
*xmit
= &port
->info
->xmit
;
173 UART_PUT_CHAR(port
, port
->x_char
);
179 if(uart_circ_empty(xmit
) || uart_tx_stopped(port
)) {
184 count
= (port
->fifosize
) - UART_GET_FIFO_CNT(port
);
186 UART_PUT_CHAR(port
, xmit
->buf
[xmit
->tail
]);
187 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
189 if(uart_circ_empty(xmit
))
192 } while(--count
> 0);
194 while(UART_GET_FIFO_CNT(port
))
197 if(uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
198 uart_write_wakeup(port
);
200 if (uart_circ_empty(xmit
))
205 * mux_read - Read chars from the mux fifo.
206 * @port: Ptr to the uart_port.
208 * This reads all available data from the mux's fifo and pushes
209 * the data to the tty layer.
211 static void mux_read(struct uart_port
*port
)
214 struct tty_struct
*tty
= port
->info
->tty
;
215 __u32 start_count
= port
->icount
.rx
;
218 data
= __raw_readl(port
->membase
+ IO_DATA_REG_OFFSET
);
220 if (MUX_STATUS(data
))
223 if (MUX_EOFIFO(data
))
226 if (tty
->flip
.count
>= TTY_FLIPBUF_SIZE
)
229 *tty
->flip
.char_buf_ptr
= data
& 0xffu
;
230 *tty
->flip
.flag_buf_ptr
= TTY_NORMAL
;
233 if (MUX_BREAK(data
)) {
235 if(uart_handle_break(port
))
239 if (uart_handle_sysrq_char(port
, data
& 0xffu
, NULL
))
242 tty
->flip
.flag_buf_ptr
++;
243 tty
->flip
.char_buf_ptr
++;
247 if (start_count
!= port
->icount
.rx
) {
248 tty_flip_buffer_push(tty
);
253 * mux_startup - Initialize the port.
254 * @port: Ptr to the uart_port.
256 * Grab any resources needed for this port and start the
259 static int mux_startup(struct uart_port
*port
)
261 mod_timer(&mux_timer
, jiffies
+ MUX_POLL_DELAY
);
266 * mux_shutdown - Disable the port.
267 * @port: Ptr to the uart_port.
269 * Release any resources needed for the port.
271 static void mux_shutdown(struct uart_port
*port
)
276 * mux_set_termios - Chane port parameters.
277 * @port: Ptr to the uart_port.
278 * @termios: new termios settings.
279 * @old: old termios settings.
281 * The Serial Mux does not support this function.
284 mux_set_termios(struct uart_port
*port
, struct termios
*termios
,
290 * mux_type - Describe the port.
291 * @port: Ptr to the uart_port.
293 * Return a pointer to a string constant describing the
296 static const char *mux_type(struct uart_port
*port
)
302 * mux_release_port - Release memory and IO regions.
303 * @port: Ptr to the uart_port.
305 * Release any memory and IO region resources currently in use by
308 static void mux_release_port(struct uart_port
*port
)
313 * mux_request_port - Request memory and IO regions.
314 * @port: Ptr to the uart_port.
316 * Request any memory and IO region resources required by the port.
317 * If any fail, no resources should be registered when this function
318 * returns, and it should return -EBUSY on failure.
320 static int mux_request_port(struct uart_port
*port
)
326 * mux_config_port - Perform port autoconfiguration.
327 * @port: Ptr to the uart_port.
328 * @type: Bitmask of required configurations.
330 * Perform any autoconfiguration steps for the port. This functino is
331 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
332 * [Note: This is required for now because of a bug in the Serial core.
333 * rmk has already submitted a patch to linus, should be available for
336 static void mux_config_port(struct uart_port
*port
, int type
)
338 port
->type
= PORT_MUX
;
342 * mux_verify_port - Verify the port information.
343 * @port: Ptr to the uart_port.
344 * @ser: Ptr to the serial information.
346 * Verify the new serial port information contained within serinfo is
347 * suitable for this port type.
349 static int mux_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
351 if(port
->membase
== NULL
)
358 * mux_drv_poll - Mux poll function.
359 * @unused: Unused variable
361 * This function periodically polls the Serial MUX to check for new data.
363 static void mux_poll(unsigned long unused
)
367 for(i
= 0; i
< port_cnt
; ++i
) {
368 if(!mux_ports
[i
].info
)
371 mux_read(&mux_ports
[i
]);
372 mux_write(&mux_ports
[i
]);
375 mod_timer(&mux_timer
, jiffies
+ MUX_POLL_DELAY
);
379 #ifdef CONFIG_SERIAL_MUX_CONSOLE
380 static void mux_console_write(struct console
*co
, const char *s
, unsigned count
)
386 static int mux_console_setup(struct console
*co
, char *options
)
391 struct tty_driver
*mux_console_device(struct console
*co
, int *index
)
394 return mux_driver
.tty_driver
;
397 static struct console mux_console
= {
399 .write
= mux_console_write
,
400 .device
= mux_console_device
,
401 .setup
= mux_console_setup
,
402 .flags
= CON_ENABLED
| CON_PRINTBUFFER
,
406 #define MUX_CONSOLE &mux_console
408 #define MUX_CONSOLE NULL
411 static struct uart_ops mux_pops
= {
412 .tx_empty
= mux_tx_empty
,
413 .set_mctrl
= mux_set_mctrl
,
414 .get_mctrl
= mux_get_mctrl
,
415 .stop_tx
= mux_stop_tx
,
416 .start_tx
= mux_start_tx
,
417 .stop_rx
= mux_stop_rx
,
418 .enable_ms
= mux_enable_ms
,
419 .break_ctl
= mux_break_ctl
,
420 .startup
= mux_startup
,
421 .shutdown
= mux_shutdown
,
422 .set_termios
= mux_set_termios
,
424 .release_port
= mux_release_port
,
425 .request_port
= mux_request_port
,
426 .config_port
= mux_config_port
,
427 .verify_port
= mux_verify_port
,
431 * mux_probe - Determine if the Serial Mux should claim this device.
432 * @dev: The parisc device.
434 * Deterimine if the Serial Mux should claim this chip (return 0)
437 static int __init
mux_probe(struct parisc_device
*dev
)
439 int i
, status
, ports
;
441 unsigned long bytecnt
;
442 struct uart_port
*port
;
444 status
= pdc_iodc_read(&bytecnt
, dev
->hpa
.start
, 0, iodc_data
, 32);
445 if(status
!= PDC_OK
) {
446 printk(KERN_ERR
"Serial mux: Unable to read IODC.\n");
450 ports
= GET_MUX_PORTS(iodc_data
);
451 printk(KERN_INFO
"Serial mux driver (%d ports) Revision: 0.3\n", ports
);
454 mux_driver
.cons
= MUX_CONSOLE
;
456 status
= uart_register_driver(&mux_driver
);
458 printk(KERN_ERR
"Serial mux: Unable to register driver.\n");
462 init_timer(&mux_timer
);
463 mux_timer
.function
= mux_poll
;
466 for(i
= 0; i
< ports
; ++i
, ++port_cnt
) {
467 port
= &mux_ports
[port_cnt
];
469 port
->mapbase
= dev
->hpa
.start
+ MUX_OFFSET
+
470 (i
* MUX_LINE_OFFSET
);
471 port
->membase
= ioremap(port
->mapbase
, MUX_LINE_OFFSET
);
472 port
->iotype
= SERIAL_IO_MEM
;
473 port
->type
= PORT_MUX
;
476 port
->fifosize
= MUX_FIFO_SIZE
;
477 port
->ops
= &mux_pops
;
478 port
->flags
= UPF_BOOT_AUTOCONF
;
479 port
->line
= port_cnt
;
481 /* The port->timeout needs to match what is present in
482 * uart_wait_until_sent in serial_core.c. Otherwise
483 * the time spent in msleep_interruptable will be very
484 * long, causing the appearance of a console hang.
486 port
->timeout
= HZ
/ 50;
487 spin_lock_init(&port
->lock
);
488 status
= uart_add_one_port(&mux_driver
, port
);
492 #ifdef CONFIG_SERIAL_MUX_CONSOLE
493 register_console(&mux_console
);
498 static struct parisc_device_id mux_tbl
[] = {
499 { HPHW_A_DIRECT
, HVERSION_REV_ANY_ID
, HVERSION_ANY_ID
, 0x0000D },
503 MODULE_DEVICE_TABLE(parisc
, mux_tbl
);
505 static struct parisc_driver serial_mux_driver
= {
506 .name
= "serial_mux",
512 * mux_init - Serial MUX initalization procedure.
514 * Register the Serial MUX driver.
516 static int __init
mux_init(void)
518 return register_parisc_driver(&serial_mux_driver
);
522 * mux_exit - Serial MUX cleanup procedure.
524 * Unregister the Serial MUX driver from the tty layer.
526 static void __exit
mux_exit(void)
530 for (i
= 0; i
< port_cnt
; i
++) {
531 uart_remove_one_port(&mux_driver
, &mux_ports
[i
]);
534 uart_unregister_driver(&mux_driver
);
537 module_init(mux_init
);
538 module_exit(mux_exit
);
540 MODULE_AUTHOR("Ryan Bradetich");
541 MODULE_DESCRIPTION("Serial MUX driver");
542 MODULE_LICENSE("GPL");
543 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR
);