blob: ccb8fa1800a58e0b8a9f1fdf1b32b40d1e225831 [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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054static struct uart_port mux_ports[MUX_NR];
55
56static struct uart_driver mux_driver = {
57 .owner = THIS_MODULE,
58 .driver_name = "ttyB",
59 .dev_name = "ttyB",
60 .major = MUX_MAJOR,
61 .minor = 0,
62 .nr = MUX_NR,
63};
64
65static struct timer_list mux_timer;
66
Ryan Bradetich92495c02005-11-17 16:36:52 -050067#define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)
68#define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8
70
71/**
72 * mux_tx_empty - Check if the transmitter fifo is empty.
73 * @port: Ptr to the uart_port.
74 *
75 * This function test if the transmitter fifo for the port
76 * described by 'port' is empty. If it is empty, this function
77 * should return TIOCSER_TEMT, otherwise return 0.
78 */
79static unsigned int mux_tx_empty(struct uart_port *port)
80{
Ryan Bradetich92495c02005-11-17 16:36:52 -050081 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082}
83
84/**
85 * mux_set_mctrl - Set the current state of the modem control inputs.
86 * @ports: Ptr to the uart_port.
87 * @mctrl: Modem control bits.
88 *
89 * The Serial MUX does not support CTS, DCD or DSR so this function
90 * is ignored.
91 */
92static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
93{
94}
95
96/**
97 * mux_get_mctrl - Returns the current state of modem control inputs.
98 * @port: Ptr to the uart_port.
99 *
100 * The Serial MUX does not support CTS, DCD or DSR so these lines are
101 * treated as permanently active.
102 */
103static unsigned int mux_get_mctrl(struct uart_port *port)
104{
105 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
106}
107
108/**
109 * mux_stop_tx - Stop transmitting characters.
110 * @port: Ptr to the uart_port.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 *
112 * The Serial MUX does not support this function.
113 */
Russell Kingb129a8c2005-08-31 10:12:14 +0100114static void mux_stop_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115{
116}
117
118/**
119 * mux_start_tx - Start transmitting characters.
120 * @port: Ptr to the uart_port.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 *
122 * The Serial Mux does not support this function.
123 */
Russell Kingb129a8c2005-08-31 10:12:14 +0100124static void mux_start_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125{
126}
127
128/**
129 * mux_stop_rx - Stop receiving characters.
130 * @port: Ptr to the uart_port.
131 *
132 * The Serial Mux does not support this function.
133 */
134static void mux_stop_rx(struct uart_port *port)
135{
136}
137
138/**
139 * mux_enable_ms - Enable modum status interrupts.
140 * @port: Ptr to the uart_port.
141 *
142 * The Serial Mux does not support this function.
143 */
144static void mux_enable_ms(struct uart_port *port)
145{
146}
147
148/**
149 * mux_break_ctl - Control the transmitssion of a break signal.
150 * @port: Ptr to the uart_port.
151 * @break_state: Raise/Lower the break signal.
152 *
153 * The Serial Mux does not support this function.
154 */
155static void mux_break_ctl(struct uart_port *port, int break_state)
156{
157}
158
159/**
160 * mux_write - Write chars to the mux fifo.
161 * @port: Ptr to the uart_port.
162 *
163 * This function writes all the data from the uart buffer to
164 * the mux fifo.
165 */
166static void mux_write(struct uart_port *port)
167{
168 int count;
169 struct circ_buf *xmit = &port->info->xmit;
170
171 if(port->x_char) {
172 UART_PUT_CHAR(port, port->x_char);
173 port->icount.tx++;
174 port->x_char = 0;
175 return;
176 }
177
178 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
Russell Kingb129a8c2005-08-31 10:12:14 +0100179 mux_stop_tx(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 return;
181 }
182
183 count = (port->fifosize) - UART_GET_FIFO_CNT(port);
184 do {
185 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
186 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
187 port->icount.tx++;
188 if(uart_circ_empty(xmit))
189 break;
190
191 } while(--count > 0);
192
193 while(UART_GET_FIFO_CNT(port))
194 udelay(1);
195
196 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
197 uart_write_wakeup(port);
198
199 if (uart_circ_empty(xmit))
Russell Kingb129a8c2005-08-31 10:12:14 +0100200 mux_stop_tx(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201}
202
203/**
204 * mux_read - Read chars from the mux fifo.
205 * @port: Ptr to the uart_port.
206 *
207 * This reads all available data from the mux's fifo and pushes
208 * the data to the tty layer.
209 */
210static void mux_read(struct uart_port *port)
211{
212 int data;
213 struct tty_struct *tty = port->info->tty;
214 __u32 start_count = port->icount.rx;
215
216 while(1) {
Ryan Bradetich92495c02005-11-17 16:36:52 -0500217 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
219 if (MUX_STATUS(data))
220 continue;
221
222 if (MUX_EOFIFO(data))
223 break;
224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 port->icount.rx++;
226
227 if (MUX_BREAK(data)) {
228 port->icount.brk++;
229 if(uart_handle_break(port))
230 continue;
231 }
232
Matthew Wilcoxbe577a52006-10-06 20:47:23 -0600233 if (uart_handle_sysrq_char(port, data & 0xffu))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 continue;
235
Alan Cox33f0f882006-01-09 20:54:13 -0800236 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 }
238
239 if (start_count != port->icount.rx) {
240 tty_flip_buffer_push(tty);
241 }
242}
243
244/**
245 * mux_startup - Initialize the port.
246 * @port: Ptr to the uart_port.
247 *
248 * Grab any resources needed for this port and start the
249 * mux timer.
250 */
251static int mux_startup(struct uart_port *port)
252{
253 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
254 return 0;
255}
256
257/**
258 * mux_shutdown - Disable the port.
259 * @port: Ptr to the uart_port.
260 *
261 * Release any resources needed for the port.
262 */
263static void mux_shutdown(struct uart_port *port)
264{
265}
266
267/**
268 * mux_set_termios - Chane port parameters.
269 * @port: Ptr to the uart_port.
270 * @termios: new termios settings.
271 * @old: old termios settings.
272 *
273 * The Serial Mux does not support this function.
274 */
275static void
Alan Cox606d0992006-12-08 02:38:45 -0800276mux_set_termios(struct uart_port *port, struct ktermios *termios,
277 struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278{
279}
280
281/**
282 * mux_type - Describe the port.
283 * @port: Ptr to the uart_port.
284 *
285 * Return a pointer to a string constant describing the
286 * specified port.
287 */
288static const char *mux_type(struct uart_port *port)
289{
290 return "Mux";
291}
292
293/**
294 * mux_release_port - Release memory and IO regions.
295 * @port: Ptr to the uart_port.
296 *
297 * Release any memory and IO region resources currently in use by
298 * the port.
299 */
300static void mux_release_port(struct uart_port *port)
301{
302}
303
304/**
305 * mux_request_port - Request memory and IO regions.
306 * @port: Ptr to the uart_port.
307 *
308 * Request any memory and IO region resources required by the port.
309 * If any fail, no resources should be registered when this function
310 * returns, and it should return -EBUSY on failure.
311 */
312static int mux_request_port(struct uart_port *port)
313{
314 return 0;
315}
316
317/**
318 * mux_config_port - Perform port autoconfiguration.
319 * @port: Ptr to the uart_port.
320 * @type: Bitmask of required configurations.
321 *
322 * Perform any autoconfiguration steps for the port. This functino is
323 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
324 * [Note: This is required for now because of a bug in the Serial core.
325 * rmk has already submitted a patch to linus, should be available for
326 * 2.5.47.]
327 */
328static void mux_config_port(struct uart_port *port, int type)
329{
330 port->type = PORT_MUX;
331}
332
333/**
334 * mux_verify_port - Verify the port information.
335 * @port: Ptr to the uart_port.
336 * @ser: Ptr to the serial information.
337 *
338 * Verify the new serial port information contained within serinfo is
339 * suitable for this port type.
340 */
341static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
342{
343 if(port->membase == NULL)
344 return -EINVAL;
345
346 return 0;
347}
348
349/**
350 * mux_drv_poll - Mux poll function.
351 * @unused: Unused variable
352 *
353 * This function periodically polls the Serial MUX to check for new data.
354 */
355static void mux_poll(unsigned long unused)
356{
357 int i;
358
359 for(i = 0; i < port_cnt; ++i) {
360 if(!mux_ports[i].info)
361 continue;
362
363 mux_read(&mux_ports[i]);
364 mux_write(&mux_ports[i]);
365 }
366
367 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
368}
369
370
371#ifdef CONFIG_SERIAL_MUX_CONSOLE
372static void mux_console_write(struct console *co, const char *s, unsigned count)
373{
374 while(count--)
375 pdc_iodc_putc(*s++);
376}
377
378static int mux_console_setup(struct console *co, char *options)
379{
380 return 0;
381}
382
383struct tty_driver *mux_console_device(struct console *co, int *index)
384{
385 *index = co->index;
386 return mux_driver.tty_driver;
387}
388
389static struct console mux_console = {
390 .name = "ttyB",
391 .write = mux_console_write,
392 .device = mux_console_device,
393 .setup = mux_console_setup,
394 .flags = CON_ENABLED | CON_PRINTBUFFER,
395 .index = 0,
396};
397
398#define MUX_CONSOLE &mux_console
399#else
400#define MUX_CONSOLE NULL
401#endif
402
403static struct uart_ops mux_pops = {
404 .tx_empty = mux_tx_empty,
405 .set_mctrl = mux_set_mctrl,
406 .get_mctrl = mux_get_mctrl,
407 .stop_tx = mux_stop_tx,
408 .start_tx = mux_start_tx,
409 .stop_rx = mux_stop_rx,
410 .enable_ms = mux_enable_ms,
411 .break_ctl = mux_break_ctl,
412 .startup = mux_startup,
413 .shutdown = mux_shutdown,
414 .set_termios = mux_set_termios,
415 .type = mux_type,
416 .release_port = mux_release_port,
417 .request_port = mux_request_port,
418 .config_port = mux_config_port,
419 .verify_port = mux_verify_port,
420};
421
422/**
423 * mux_probe - Determine if the Serial Mux should claim this device.
424 * @dev: The parisc device.
425 *
426 * Deterimine if the Serial Mux should claim this chip (return 0)
427 * or not (return 1).
428 */
429static int __init mux_probe(struct parisc_device *dev)
430{
431 int i, status, ports;
432 u8 iodc_data[32];
433 unsigned long bytecnt;
434 struct uart_port *port;
435
Matthew Wilcox53f01bb2005-10-21 22:36:40 -0400436 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 if(status != PDC_OK) {
438 printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
439 return 1;
440 }
441
442 ports = GET_MUX_PORTS(iodc_data);
443 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);
444
445 if(!port_cnt) {
446 mux_driver.cons = MUX_CONSOLE;
447
448 status = uart_register_driver(&mux_driver);
449 if(status) {
450 printk(KERN_ERR "Serial mux: Unable to register driver.\n");
451 return 1;
452 }
453
454 init_timer(&mux_timer);
455 mux_timer.function = mux_poll;
456 }
457
458 for(i = 0; i < ports; ++i, ++port_cnt) {
459 port = &mux_ports[port_cnt];
460 port->iobase = 0;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400461 port->mapbase = dev->hpa.start + MUX_OFFSET +
462 (i * MUX_LINE_OFFSET);
Helge Deller5076c152006-03-27 12:52:15 -0700463 port->membase = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
Russell King9b4a1612006-02-05 10:48:10 +0000464 port->iotype = UPIO_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 port->type = PORT_MUX;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400466 port->irq = NO_IRQ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 port->uartclk = 0;
468 port->fifosize = MUX_FIFO_SIZE;
469 port->ops = &mux_pops;
470 port->flags = UPF_BOOT_AUTOCONF;
471 port->line = port_cnt;
Ryan Bradeticha137ce852005-11-17 16:38:28 -0500472
473 /* The port->timeout needs to match what is present in
474 * uart_wait_until_sent in serial_core.c. Otherwise
475 * the time spent in msleep_interruptable will be very
476 * long, causing the appearance of a console hang.
477 */
478 port->timeout = HZ / 50;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400479 spin_lock_init(&port->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 status = uart_add_one_port(&mux_driver, port);
481 BUG_ON(status);
482 }
483
484#ifdef CONFIG_SERIAL_MUX_CONSOLE
485 register_console(&mux_console);
486#endif
487 return 0;
488}
489
490static struct parisc_device_id mux_tbl[] = {
491 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
492 { 0, }
493};
494
495MODULE_DEVICE_TABLE(parisc, mux_tbl);
496
497static struct parisc_driver serial_mux_driver = {
Matthew Wilcoxbdad1f82005-10-21 22:36:23 -0400498 .name = "serial_mux",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 .id_table = mux_tbl,
500 .probe = mux_probe,
501};
502
503/**
504 * mux_init - Serial MUX initalization procedure.
505 *
506 * Register the Serial MUX driver.
507 */
508static int __init mux_init(void)
509{
510 return register_parisc_driver(&serial_mux_driver);
511}
512
513/**
514 * mux_exit - Serial MUX cleanup procedure.
515 *
516 * Unregister the Serial MUX driver from the tty layer.
517 */
518static void __exit mux_exit(void)
519{
520 int i;
521
522 for (i = 0; i < port_cnt; i++) {
523 uart_remove_one_port(&mux_driver, &mux_ports[i]);
Amol Ladaf907dc2006-09-30 23:29:25 -0700524 if (mux_ports[i].membase)
525 iounmap(mux_ports[i].membase);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 }
527
528 uart_unregister_driver(&mux_driver);
529}
530
531module_init(mux_init);
532module_exit(mux_exit);
533
534MODULE_AUTHOR("Ryan Bradetich");
535MODULE_DESCRIPTION("Serial MUX driver");
536MODULE_LICENSE("GPL");
537MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);