blob: 953a5ffa9b44e6279b80f26a4a4aefb59ab934e3 [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)
Ryan Bradetich61425442006-11-10 03:08:45 +000073
74/**
75 * get_mux_port_count - Get the number of available ports on the Mux.
76 * @dev: The parisc device.
77 *
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.
83 */
84static int __init get_mux_port_count(struct parisc_device *dev)
85{
Ryan Bradetich514fb842006-11-10 04:06:14 +000086 int status;
Ryan Bradetich61425442006-11-10 03:08:45 +000087 u8 iodc_data[32];
88 unsigned long bytecnt;
89
Ryan Bradetich61425442006-11-10 03:08:45 +000090 /* 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.
93 */
Ryan Bradetich514fb842006-11-10 04:06:14 +000094 if(dev->id.hversion == 0x15)
Ryan Bradetich61425442006-11-10 03:08:45 +000095 return 1;
96
Ryan Bradetich514fb842006-11-10 04:06:14 +000097 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
98 BUG_ON(status != PDC_OK);
99
Ryan Bradetich61425442006-11-10 03:08:45 +0000100 /* Return the number of ports specified in the iodc data. */
101 return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8;
102}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104/**
105 * mux_tx_empty - Check if the transmitter fifo is empty.
106 * @port: Ptr to the uart_port.
107 *
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.
111 */
112static unsigned int mux_tx_empty(struct uart_port *port)
113{
Ryan Bradetich92495c02005-11-17 16:36:52 -0500114 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115}
116
117/**
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.
121 *
122 * The Serial MUX does not support CTS, DCD or DSR so this function
123 * is ignored.
124 */
125static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
126{
127}
128
129/**
130 * mux_get_mctrl - Returns the current state of modem control inputs.
131 * @port: Ptr to the uart_port.
132 *
133 * The Serial MUX does not support CTS, DCD or DSR so these lines are
134 * treated as permanently active.
135 */
136static unsigned int mux_get_mctrl(struct uart_port *port)
137{
138 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
139}
140
141/**
142 * mux_stop_tx - Stop transmitting characters.
143 * @port: Ptr to the uart_port.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 *
145 * The Serial MUX does not support this function.
146 */
Russell Kingb129a8c2005-08-31 10:12:14 +0100147static void mux_stop_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148{
149}
150
151/**
152 * mux_start_tx - Start transmitting characters.
153 * @port: Ptr to the uart_port.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 *
155 * The Serial Mux does not support this function.
156 */
Russell Kingb129a8c2005-08-31 10:12:14 +0100157static void mux_start_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158{
159}
160
161/**
162 * mux_stop_rx - Stop receiving characters.
163 * @port: Ptr to the uart_port.
164 *
165 * The Serial Mux does not support this function.
166 */
167static void mux_stop_rx(struct uart_port *port)
168{
169}
170
171/**
172 * mux_enable_ms - Enable modum status interrupts.
173 * @port: Ptr to the uart_port.
174 *
175 * The Serial Mux does not support this function.
176 */
177static void mux_enable_ms(struct uart_port *port)
178{
179}
180
181/**
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.
185 *
186 * The Serial Mux does not support this function.
187 */
188static void mux_break_ctl(struct uart_port *port, int break_state)
189{
190}
191
192/**
193 * mux_write - Write chars to the mux fifo.
194 * @port: Ptr to the uart_port.
195 *
196 * This function writes all the data from the uart buffer to
197 * the mux fifo.
198 */
199static void mux_write(struct uart_port *port)
200{
201 int count;
202 struct circ_buf *xmit = &port->info->xmit;
203
204 if(port->x_char) {
205 UART_PUT_CHAR(port, port->x_char);
206 port->icount.tx++;
207 port->x_char = 0;
208 return;
209 }
210
211 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
Russell Kingb129a8c2005-08-31 10:12:14 +0100212 mux_stop_tx(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 return;
214 }
215
216 count = (port->fifosize) - UART_GET_FIFO_CNT(port);
217 do {
218 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
219 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
220 port->icount.tx++;
221 if(uart_circ_empty(xmit))
222 break;
223
224 } while(--count > 0);
225
226 while(UART_GET_FIFO_CNT(port))
227 udelay(1);
228
229 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
230 uart_write_wakeup(port);
231
232 if (uart_circ_empty(xmit))
Russell Kingb129a8c2005-08-31 10:12:14 +0100233 mux_stop_tx(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
236/**
237 * mux_read - Read chars from the mux fifo.
238 * @port: Ptr to the uart_port.
239 *
240 * This reads all available data from the mux's fifo and pushes
241 * the data to the tty layer.
242 */
243static void mux_read(struct uart_port *port)
244{
245 int data;
Takashi Iwaia88487c2008-07-16 21:54:42 +0100246 struct tty_struct *tty = port->info->port.tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 __u32 start_count = port->icount.rx;
248
249 while(1) {
Ryan Bradetich92495c02005-11-17 16:36:52 -0500250 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
252 if (MUX_STATUS(data))
253 continue;
254
255 if (MUX_EOFIFO(data))
256 break;
257
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 port->icount.rx++;
259
260 if (MUX_BREAK(data)) {
261 port->icount.brk++;
262 if(uart_handle_break(port))
263 continue;
264 }
265
Matthew Wilcoxbe577a52006-10-06 20:47:23 -0600266 if (uart_handle_sysrq_char(port, data & 0xffu))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 continue;
268
Alan Cox33f0f882006-01-09 20:54:13 -0800269 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 }
271
272 if (start_count != port->icount.rx) {
273 tty_flip_buffer_push(tty);
274 }
275}
276
277/**
278 * mux_startup - Initialize the port.
279 * @port: Ptr to the uart_port.
280 *
281 * Grab any resources needed for this port and start the
282 * mux timer.
283 */
284static int mux_startup(struct uart_port *port)
285{
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000286 mux_ports[port->line].enabled = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 return 0;
288}
289
290/**
291 * mux_shutdown - Disable the port.
292 * @port: Ptr to the uart_port.
293 *
294 * Release any resources needed for the port.
295 */
296static void mux_shutdown(struct uart_port *port)
297{
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000298 mux_ports[port->line].enabled = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
301/**
302 * mux_set_termios - Chane port parameters.
303 * @port: Ptr to the uart_port.
304 * @termios: new termios settings.
305 * @old: old termios settings.
306 *
307 * The Serial Mux does not support this function.
308 */
309static void
Alan Cox606d0992006-12-08 02:38:45 -0800310mux_set_termios(struct uart_port *port, struct ktermios *termios,
311 struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312{
313}
314
315/**
316 * mux_type - Describe the port.
317 * @port: Ptr to the uart_port.
318 *
319 * Return a pointer to a string constant describing the
320 * specified port.
321 */
322static const char *mux_type(struct uart_port *port)
323{
324 return "Mux";
325}
326
327/**
328 * mux_release_port - Release memory and IO regions.
329 * @port: Ptr to the uart_port.
330 *
331 * Release any memory and IO region resources currently in use by
332 * the port.
333 */
334static void mux_release_port(struct uart_port *port)
335{
336}
337
338/**
339 * mux_request_port - Request memory and IO regions.
340 * @port: Ptr to the uart_port.
341 *
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.
345 */
346static int mux_request_port(struct uart_port *port)
347{
348 return 0;
349}
350
351/**
352 * mux_config_port - Perform port autoconfiguration.
353 * @port: Ptr to the uart_port.
354 * @type: Bitmask of required configurations.
355 *
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000356 * Perform any autoconfiguration steps for the port. This function is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 * 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
360 * 2.5.47.]
361 */
362static void mux_config_port(struct uart_port *port, int type)
363{
364 port->type = PORT_MUX;
365}
366
367/**
368 * mux_verify_port - Verify the port information.
369 * @port: Ptr to the uart_port.
370 * @ser: Ptr to the serial information.
371 *
372 * Verify the new serial port information contained within serinfo is
373 * suitable for this port type.
374 */
375static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
376{
377 if(port->membase == NULL)
378 return -EINVAL;
379
380 return 0;
381}
382
383/**
384 * mux_drv_poll - Mux poll function.
385 * @unused: Unused variable
386 *
387 * This function periodically polls the Serial MUX to check for new data.
388 */
389static void mux_poll(unsigned long unused)
390{
391 int i;
392
393 for(i = 0; i < port_cnt; ++i) {
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000394 if(!mux_ports[i].enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 continue;
396
Ryan Bradetich4bd5d822006-11-03 05:38:39 +0000397 mux_read(&mux_ports[i].port);
398 mux_write(&mux_ports[i].port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 }
400
401 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
402}
403
404
405#ifdef CONFIG_SERIAL_MUX_CONSOLE
406static void mux_console_write(struct console *co, const char *s, unsigned count)
407{
Ryan Bradetich3de7b642006-11-03 05:52:41 +0000408 /* Wait until the FIFO drains. */
409 while(UART_GET_FIFO_CNT(&mux_ports[0].port))
410 udelay(1);
411
412 while(count--) {
413 if(*s == '\n') {
414 UART_PUT_CHAR(&mux_ports[0].port, '\r');
415 }
416 UART_PUT_CHAR(&mux_ports[0].port, *s++);
417 }
418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419}
420
421static int mux_console_setup(struct console *co, char *options)
422{
423 return 0;
424}
425
426struct tty_driver *mux_console_device(struct console *co, int *index)
427{
428 *index = co->index;
429 return mux_driver.tty_driver;
430}
431
432static struct console mux_console = {
433 .name = "ttyB",
434 .write = mux_console_write,
435 .device = mux_console_device,
436 .setup = mux_console_setup,
437 .flags = CON_ENABLED | CON_PRINTBUFFER,
438 .index = 0,
439};
440
441#define MUX_CONSOLE &mux_console
442#else
443#define MUX_CONSOLE NULL
444#endif
445
446static 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,
458 .type = mux_type,
459 .release_port = mux_release_port,
460 .request_port = mux_request_port,
461 .config_port = mux_config_port,
462 .verify_port = mux_verify_port,
463};
464
465/**
466 * mux_probe - Determine if the Serial Mux should claim this device.
467 * @dev: The parisc device.
468 *
469 * Deterimine if the Serial Mux should claim this chip (return 0)
470 * or not (return 1).
471 */
472static int __init mux_probe(struct parisc_device *dev)
473{
Ryan Bradetich61425442006-11-10 03:08:45 +0000474 int i, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
Ryan Bradetich61425442006-11-10 03:08:45 +0000476 int port_count = get_mux_port_count(dev);
Ryan Bradetich752b9402006-11-09 04:45:08 +0000477 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Ryan Bradetichc380f052006-11-05 01:21:44 +0000479 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483 if(!port_cnt) {
484 mux_driver.cons = MUX_CONSOLE;
485
486 status = uart_register_driver(&mux_driver);
487 if(status) {
488 printk(KERN_ERR "Serial mux: Unable to register driver.\n");
489 return 1;
490 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 }
492
Ryan Bradetichc380f052006-11-05 01:21:44 +0000493 for(i = 0; i < port_count; ++i, ++port_cnt) {
494 struct uart_port *port = &mux_ports[port_cnt].port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 port->iobase = 0;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400496 port->mapbase = dev->hpa.start + MUX_OFFSET +
497 (i * MUX_LINE_OFFSET);
Helge Deller5076c152006-03-27 12:52:15 -0700498 port->membase = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
Russell King9b4a1612006-02-05 10:48:10 +0000499 port->iotype = UPIO_MEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 port->type = PORT_MUX;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400501 port->irq = NO_IRQ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 port->uartclk = 0;
503 port->fifosize = MUX_FIFO_SIZE;
504 port->ops = &mux_pops;
505 port->flags = UPF_BOOT_AUTOCONF;
506 port->line = port_cnt;
Ryan Bradeticha137ce852005-11-17 16:38:28 -0500507
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.
512 */
513 port->timeout = HZ / 50;
Matthew Wilcoxae8c75c2005-10-21 22:58:03 -0400514 spin_lock_init(&port->lock);
Ryan Bradetich752b9402006-11-09 04:45:08 +0000515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 status = uart_add_one_port(&mux_driver, port);
517 BUG_ON(status);
518 }
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 return 0;
521}
522
Ryan Bradetichc380f052006-11-05 01:21:44 +0000523static int __devexit mux_remove(struct parisc_device *dev)
524{
Ryan Bradetich752b9402006-11-09 04:45:08 +0000525 int i, j;
Ryan Bradetichc380f052006-11-05 01:21:44 +0000526 int port_count = (long)dev_get_drvdata(&dev->dev);
527
Ryan Bradetichc380f052006-11-05 01:21:44 +0000528 /* 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)
531 break;
532 }
533 BUG_ON(i + port_count > port_cnt);
534
535 /* Release the resources associated with each port on the device. */
Ryan Bradetich752b9402006-11-09 04:45:08 +0000536 for(j = 0; j < port_count; ++j, ++i) {
Ryan Bradetichc380f052006-11-05 01:21:44 +0000537 struct uart_port *port = &mux_ports[i].port;
538
539 uart_remove_one_port(&mux_driver, port);
540 if(port->membase)
541 iounmap(port->membase);
542 }
543
544 release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 return 0;
546}
547
Ryan Bradetich752b9402006-11-09 04:45:08 +0000548/* 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.
552 *
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.
555 */
556static 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 */
559 { 0, }
560};
561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562static struct parisc_device_id mux_tbl[] = {
563 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
564 { 0, }
565};
566
Ryan Bradetich752b9402006-11-09 04:45:08 +0000567MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568MODULE_DEVICE_TABLE(parisc, mux_tbl);
569
Ryan Bradetich752b9402006-11-09 04:45:08 +0000570static struct parisc_driver builtin_serial_mux_driver = {
571 .name = "builtin_serial_mux",
572 .id_table = builtin_mux_tbl,
573 .probe = mux_probe,
574 .remove = __devexit_p(mux_remove),
575};
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577static struct parisc_driver serial_mux_driver = {
Matthew Wilcoxbdad1f82005-10-21 22:36:23 -0400578 .name = "serial_mux",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 .id_table = mux_tbl,
580 .probe = mux_probe,
Ryan Bradetichc380f052006-11-05 01:21:44 +0000581 .remove = __devexit_p(mux_remove),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582};
583
584/**
Joe Perches8f4aafe2008-02-03 17:29:25 +0200585 * mux_init - Serial MUX initialization procedure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 *
587 * Register the Serial MUX driver.
588 */
589static int __init mux_init(void)
590{
Ryan Bradetich752b9402006-11-09 04:45:08 +0000591 register_parisc_driver(&builtin_serial_mux_driver);
592 register_parisc_driver(&serial_mux_driver);
Ryan Bradetichc380f052006-11-05 01:21:44 +0000593
594 if(port_cnt > 0) {
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);
599
600#ifdef CONFIG_SERIAL_MUX_CONSOLE
601 register_console(&mux_console);
602#endif
603 }
604
Ryan Bradetich752b9402006-11-09 04:45:08 +0000605 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606}
607
608/**
609 * mux_exit - Serial MUX cleanup procedure.
610 *
611 * Unregister the Serial MUX driver from the tty layer.
612 */
613static void __exit mux_exit(void)
614{
Ryan Bradetichc380f052006-11-05 01:21:44 +0000615 /* Delete the Mux timer. */
616 if(port_cnt > 0) {
617 del_timer(&mux_timer);
618#ifdef CONFIG_SERIAL_MUX_CONSOLE
619 unregister_console(&mux_console);
620#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 }
622
Ryan Bradetich752b9402006-11-09 04:45:08 +0000623 unregister_parisc_driver(&builtin_serial_mux_driver);
Ryan Bradetichc380f052006-11-05 01:21:44 +0000624 unregister_parisc_driver(&serial_mux_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 uart_unregister_driver(&mux_driver);
626}
627
628module_init(mux_init);
629module_exit(mux_exit);
630
631MODULE_AUTHOR("Ryan Bradetich");
632MODULE_DESCRIPTION("Serial MUX driver");
633MODULE_LICENSE("GPL");
634MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);