blob: 6408b9b1561a128de25fc340a58d1d8507845c4c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2** mux.c:
3** serial driver for the Mux console found in some PA-RISC servers.
4**
5** (c) Copyright 2002 Ryan Bradetich
6** (c) Copyright 2002 Hewlett-Packard Company
7**
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.
12**
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.
16**
17*/
18
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#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>
28#include <asm/io.h>
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -040029#include <asm/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/parisc-device.h>
31
32#ifdef CONFIG_MAGIC_SYSRQ
33#include <linux/sysrq.h>
34#define SUPPORT_SYSRQ
35#endif
36
37#include <linux/serial_core.h>
38
39#define MUX_OFFSET 0x800
40#define MUX_LINE_OFFSET 0x80
41
42#define MUX_FIFO_SIZE 255
43#define MUX_POLL_DELAY (30 * HZ / 1000)
44
45#define IO_DATA_REG_OFFSET 0x3c
46#define IO_DCOUNT_REG_OFFSET 0x40
47
48#define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
49#define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
50#define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
51
52#define MUX_NR 256
Helge Deller5076c152006-03-27 12:52:15 -070053static unsigned int port_cnt __read_mostly;
Ryan Bradetich4bd5d822006-11-03 05:38:39 +000054struct mux_port {
55 struct uart_port port;
56 int enabled;
57};
58static struct mux_port mux_ports[MUX_NR];
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60static struct uart_driver mux_driver = {
61 .owner = THIS_MODULE,
62 .driver_name = "ttyB",
63 .dev_name = "ttyB",
64 .major = MUX_MAJOR,
65 .minor = 0,
66 .nr = MUX_NR,
67};
68
69static struct timer_list mux_timer;
70
Ryan Bradetich92495c02005-11-17 16:36:52 -050071#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)
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8
74
75/**
76 * mux_tx_empty - Check if the transmitter fifo is empty.
77 * @port: Ptr to the uart_port.
78 *
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.
82 */
83static unsigned int mux_tx_empty(struct uart_port *port)
84{
Ryan Bradetich92495c02005-11-17 16:36:52 -050085 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
88/**
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.
92 *
93 * The Serial MUX does not support CTS, DCD or DSR so this function
94 * is ignored.
95 */
96static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
97{
98}
99
100/**
101 * mux_get_mctrl - Returns the current state of modem control inputs.
102 * @port: Ptr to the uart_port.
103 *
104 * The Serial MUX does not support CTS, DCD or DSR so these lines are
105 * treated as permanently active.
106 */
107static unsigned int mux_get_mctrl(struct uart_port *port)
108{
109 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
110}
111
112/**
113 * mux_stop_tx - Stop transmitting characters.
114 * @port: Ptr to the uart_port.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 *
116 * The Serial MUX does not support this function.
117 */
Russell Kingb129a8c2005-08-31 10:12:14 +0100118static void mux_stop_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
120}
121
122/**
123 * mux_start_tx - Start transmitting characters.
124 * @port: Ptr to the uart_port.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 *
126 * The Serial Mux does not support this function.
127 */
Russell Kingb129a8c2005-08-31 10:12:14 +0100128static void mux_start_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
130}
131
132/**
133 * mux_stop_rx - Stop receiving characters.
134 * @port: Ptr to the uart_port.
135 *
136 * The Serial Mux does not support this function.
137 */
138static void mux_stop_rx(struct uart_port *port)
139{
140}
141
142/**
143 * mux_enable_ms - Enable modum status interrupts.
144 * @port: Ptr to the uart_port.
145 *
146 * The Serial Mux does not support this function.
147 */
148static void mux_enable_ms(struct uart_port *port)
149{
150}
151
152/**
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.
156 *
157 * The Serial Mux does not support this function.
158 */
159static void mux_break_ctl(struct uart_port *port, int break_state)
160{
161}
162
163/**
164 * mux_write - Write chars to the mux fifo.
165 * @port: Ptr to the uart_port.
166 *
167 * This function writes all the data from the uart buffer to
168 * the mux fifo.
169 */
170static void mux_write(struct uart_port *port)
171{
172 int count;
173 struct circ_buf *xmit = &port->info->xmit;
174
175 if(port->x_char) {
176 UART_PUT_CHAR(port, port->x_char);
177 port->icount.tx++;
178 port->x_char = 0;
179 return;
180 }
181
182 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
Russell Kingb129a8c2005-08-31 10:12:14 +0100183 mux_stop_tx(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 return;
185 }
186
187 count = (port->fifosize) - UART_GET_FIFO_CNT(port);
188 do {
189 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
190 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
191 port->icount.tx++;
192 if(uart_circ_empty(xmit))
193 break;
194
195 } while(--count > 0);
196
197 while(UART_GET_FIFO_CNT(port))
198 udelay(1);
199
200 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
201 uart_write_wakeup(port);
202
203 if (uart_circ_empty(xmit))
Russell Kingb129a8c2005-08-31 10:12:14 +0100204 mux_stop_tx(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
206
207/**
208 * mux_read - Read chars from the mux fifo.
209 * @port: Ptr to the uart_port.
210 *
211 * This reads all available data from the mux's fifo and pushes
212 * the data to the tty layer.
213 */
214static void mux_read(struct uart_port *port)
215{
216 int data;
217 struct tty_struct *tty = port->info->tty;
218 __u32 start_count = port->icount.rx;
219
220 while(1) {
Ryan Bradetich92495c02005-11-17 16:36:52 -0500221 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 if (MUX_STATUS(data))
224 continue;
225
226 if (MUX_EOFIFO(data))
227 break;
228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 port->icount.rx++;
230
231 if (MUX_BREAK(data)) {
232 port->icount.brk++;
233 if(uart_handle_break(port))
234 continue;
235 }
236
Matthew Wilcoxbe577a52006-10-06 20:47:23 -0600237 if (uart_handle_sysrq_char(port, data & 0xffu))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 continue;
239
Alan Cox33f0f882006-01-09 20:54:13 -0800240 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 }
242
243 if (start_count != port->icount.rx) {
244 tty_flip_buffer_push(tty);
245 }
246}
247
248/**
249 * mux_startup - Initialize the port.
250 * @port: Ptr to the uart_port.
251 *
252 * Grab any resources needed for this port and start the
253 * mux timer.
254 */
255static int mux_startup(struct uart_port *port)
256{
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000257 mux_ports[port->line].enabled = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 return 0;
259}
260
261/**
262 * mux_shutdown - Disable the port.
263 * @port: Ptr to the uart_port.
264 *
265 * Release any resources needed for the port.
266 */
267static void mux_shutdown(struct uart_port *port)
268{
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000269 mux_ports[port->line].enabled = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
271
272/**
273 * mux_set_termios - Chane port parameters.
274 * @port: Ptr to the uart_port.
275 * @termios: new termios settings.
276 * @old: old termios settings.
277 *
278 * The Serial Mux does not support this function.
279 */
280static void
281mux_set_termios(struct uart_port *port, struct termios *termios,
282 struct termios *old)
283{
284}
285
286/**
287 * mux_type - Describe the port.
288 * @port: Ptr to the uart_port.
289 *
290 * Return a pointer to a string constant describing the
291 * specified port.
292 */
293static const char *mux_type(struct uart_port *port)
294{
295 return "Mux";
296}
297
298/**
299 * mux_release_port - Release memory and IO regions.
300 * @port: Ptr to the uart_port.
301 *
302 * Release any memory and IO region resources currently in use by
303 * the port.
304 */
305static void mux_release_port(struct uart_port *port)
306{
307}
308
309/**
310 * mux_request_port - Request memory and IO regions.
311 * @port: Ptr to the uart_port.
312 *
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.
316 */
317static int mux_request_port(struct uart_port *port)
318{
319 return 0;
320}
321
322/**
323 * mux_config_port - Perform port autoconfiguration.
324 * @port: Ptr to the uart_port.
325 * @type: Bitmask of required configurations.
326 *
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000327 * Perform any autoconfiguration steps for the port. This function is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 * 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
331 * 2.5.47.]
332 */
333static void mux_config_port(struct uart_port *port, int type)
334{
335 port->type = PORT_MUX;
336}
337
338/**
339 * mux_verify_port - Verify the port information.
340 * @port: Ptr to the uart_port.
341 * @ser: Ptr to the serial information.
342 *
343 * Verify the new serial port information contained within serinfo is
344 * suitable for this port type.
345 */
346static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
347{
348 if(port->membase == NULL)
349 return -EINVAL;
350
351 return 0;
352}
353
354/**
355 * mux_drv_poll - Mux poll function.
356 * @unused: Unused variable
357 *
358 * This function periodically polls the Serial MUX to check for new data.
359 */
360static void mux_poll(unsigned long unused)
361{
362 int i;
363
364 for(i = 0; i < port_cnt; ++i) {
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000365 if(!mux_ports[i].enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 continue;
367
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000368 mux_read(&mux_ports[i].port);
369 mux_write(&mux_ports[i].port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 }
371
372 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
373}
374
375
376#ifdef CONFIG_SERIAL_MUX_CONSOLE
377static void mux_console_write(struct console *co, const char *s, unsigned count)
378{
Ryan Bradetich3de7b642006-11-03 05:52:41 +0000379 /* Wait until the FIFO drains. */
380 while(UART_GET_FIFO_CNT(&mux_ports[0].port))
381 udelay(1);
382
383 while(count--) {
384 if(*s == '\n') {
385 UART_PUT_CHAR(&mux_ports[0].port, '\r');
386 }
387 UART_PUT_CHAR(&mux_ports[0].port, *s++);
388 }
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390}
391
392static int mux_console_setup(struct console *co, char *options)
393{
394 return 0;
395}
396
397struct tty_driver *mux_console_device(struct console *co, int *index)
398{
399 *index = co->index;
400 return mux_driver.tty_driver;
401}
402
403static struct console mux_console = {
404 .name = "ttyB",
405 .write = mux_console_write,
406 .device = mux_console_device,
407 .setup = mux_console_setup,
408 .flags = CON_ENABLED | CON_PRINTBUFFER,
409 .index = 0,
410};
411
412#define MUX_CONSOLE &mux_console
413#else
414#define MUX_CONSOLE NULL
415#endif
416
417static 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,
429 .type = mux_type,
430 .release_port = mux_release_port,
431 .request_port = mux_request_port,
432 .config_port = mux_config_port,
433 .verify_port = mux_verify_port,
434};
435
436/**
437 * mux_probe - Determine if the Serial Mux should claim this device.
438 * @dev: The parisc device.
439 *
440 * Deterimine if the Serial Mux should claim this chip (return 0)
441 * or not (return 1).
442 */
443static int __init mux_probe(struct parisc_device *dev)
444{
445 int i, status, ports;
446 u8 iodc_data[32];
447 unsigned long bytecnt;
448 struct uart_port *port;
449
Matthew Wilcox53f01bb2005-10-21 22:36:40 -0400450 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 if(status != PDC_OK) {
452 printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
453 return 1;
454 }
455
456 ports = GET_MUX_PORTS(iodc_data);
457 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);
458
459 if(!port_cnt) {
460 mux_driver.cons = MUX_CONSOLE;
461
462 status = uart_register_driver(&mux_driver);
463 if(status) {
464 printk(KERN_ERR "Serial mux: Unable to register driver.\n");
465 return 1;
466 }
467
468 init_timer(&mux_timer);
469 mux_timer.function = mux_poll;
470 }
471
472 for(i = 0; i < ports; ++i, ++port_cnt) {
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000473 port = &mux_ports[port_cnt].port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 port->iobase = 0;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400475 port->mapbase = dev->hpa.start + MUX_OFFSET +
476 (i * MUX_LINE_OFFSET);
Helge Deller5076c152006-03-27 12:52:15 -0700477 port->membase = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
Russell King9b4a1612006-02-05 10:48:10 +0000478 port->iotype = UPIO_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 port->type = PORT_MUX;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400480 port->irq = NO_IRQ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 port->uartclk = 0;
482 port->fifosize = MUX_FIFO_SIZE;
483 port->ops = &mux_pops;
484 port->flags = UPF_BOOT_AUTOCONF;
485 port->line = port_cnt;
Ryan Bradeticha137ce852005-11-17 16:38:28 -0500486
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.
491 */
492 port->timeout = HZ / 50;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400493 spin_lock_init(&port->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 status = uart_add_one_port(&mux_driver, port);
495 BUG_ON(status);
496 }
497
498#ifdef CONFIG_SERIAL_MUX_CONSOLE
499 register_console(&mux_console);
500#endif
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000501 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 return 0;
504}
505
506static struct parisc_device_id mux_tbl[] = {
507 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
508 { 0, }
509};
510
511MODULE_DEVICE_TABLE(parisc, mux_tbl);
512
513static struct parisc_driver serial_mux_driver = {
Matthew Wilcoxbdad1f82005-10-21 22:36:23 -0400514 .name = "serial_mux",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 .id_table = mux_tbl,
516 .probe = mux_probe,
517};
518
519/**
520 * mux_init - Serial MUX initalization procedure.
521 *
522 * Register the Serial MUX driver.
523 */
524static int __init mux_init(void)
525{
526 return register_parisc_driver(&serial_mux_driver);
527}
528
529/**
530 * mux_exit - Serial MUX cleanup procedure.
531 *
532 * Unregister the Serial MUX driver from the tty layer.
533 */
534static void __exit mux_exit(void)
535{
536 int i;
537
538 for (i = 0; i < port_cnt; i++) {
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000539 uart_remove_one_port(&mux_driver, &mux_ports[i].port);
540 if (mux_ports[i].port.membase)
541 iounmap(mux_ports[i].port.membase);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 }
543
544 uart_unregister_driver(&mux_driver);
545}
546
547module_init(mux_init);
548module_exit(mux_exit);
549
550MODULE_AUTHOR("Ryan Bradetich");
551MODULE_DESCRIPTION("Serial MUX driver");
552MODULE_LICENSE("GPL");
553MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);