Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3** mux.c:
4** serial driver for the Mux console found in some PA-RISC servers.
5**
6** (c) Copyright 2002 Ryan Bradetich
7** (c) Copyright 2002 Hewlett-Packard Company
8**
9** This Driver currently only supports the console (port 0) on the MUX.
10** Additional work will be needed on this driver to enable the full
11** functionality of the MUX.
12**
13*/
14
15#include <linux/module.h>
16#include <linux/ioport.h>
17#include <linux/init.h>
18#include <linux/serial.h>
19#include <linux/tty.h>
20#include <linux/tty_flip.h>
21#include <linux/console.h>
22#include <linux/delay.h> /* for udelay */
23#include <linux/device.h>
24#include <asm/io.h>
25#include <asm/irq.h>
26#include <asm/parisc-device.h>
27
28#if defined(CONFIG_SERIAL_MUX_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
29#include <linux/sysrq.h>
30#define SUPPORT_SYSRQ
31#endif
32
33#include <linux/serial_core.h>
34
35#define MUX_OFFSET 0x800
36#define MUX_LINE_OFFSET 0x80
37
38#define MUX_FIFO_SIZE 255
39#define MUX_POLL_DELAY (30 * HZ / 1000)
40
41#define IO_DATA_REG_OFFSET 0x3c
42#define IO_DCOUNT_REG_OFFSET 0x40
43
44#define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
45#define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
46#define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
47
48#define MUX_NR 256
49static unsigned int port_cnt __read_mostly;
50struct mux_port {
51 struct uart_port port;
52 int enabled;
53};
54static struct mux_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
67#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)
69
70/**
71 * get_mux_port_count - Get the number of available ports on the Mux.
72 * @dev: The parisc device.
73 *
74 * This function is used to determine the number of ports the Mux
75 * supports. The IODC data reports the number of ports the Mux
76 * can support, but there are cases where not all the Mux ports
77 * are connected. This function can override the IODC and
78 * return the true port count.
79 */
80static int __init get_mux_port_count(struct parisc_device *dev)
81{
82 int status;
83 u8 iodc_data[32];
84 unsigned long bytecnt;
85
86 /* If this is the built-in Mux for the K-Class (Eole CAP/MUX),
87 * we only need to allocate resources for 1 port since the
88 * other 7 ports are not connected.
89 */
90 if(dev->id.hversion == 0x15)
91 return 1;
92
93 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
94 BUG_ON(status != PDC_OK);
95
96 /* Return the number of ports specified in the iodc data. */
97 return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8;
98}
99
100/**
101 * mux_tx_empty - Check if the transmitter fifo is empty.
102 * @port: Ptr to the uart_port.
103 *
104 * This function test if the transmitter fifo for the port
105 * described by 'port' is empty. If it is empty, this function
106 * should return TIOCSER_TEMT, otherwise return 0.
107 */
108static unsigned int mux_tx_empty(struct uart_port *port)
109{
110 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
111}
112
113/**
114 * mux_set_mctrl - Set the current state of the modem control inputs.
115 * @ports: Ptr to the uart_port.
116 * @mctrl: Modem control bits.
117 *
118 * The Serial MUX does not support CTS, DCD or DSR so this function
119 * is ignored.
120 */
121static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
122{
123}
124
125/**
126 * mux_get_mctrl - Returns the current state of modem control inputs.
127 * @port: Ptr to the uart_port.
128 *
129 * The Serial MUX does not support CTS, DCD or DSR so these lines are
130 * treated as permanently active.
131 */
132static unsigned int mux_get_mctrl(struct uart_port *port)
133{
134 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
135}
136
137/**
138 * mux_stop_tx - Stop transmitting characters.
139 * @port: Ptr to the uart_port.
140 *
141 * The Serial MUX does not support this function.
142 */
143static void mux_stop_tx(struct uart_port *port)
144{
145}
146
147/**
148 * mux_start_tx - Start transmitting characters.
149 * @port: Ptr to the uart_port.
150 *
151 * The Serial Mux does not support this function.
152 */
153static void mux_start_tx(struct uart_port *port)
154{
155}
156
157/**
158 * mux_stop_rx - Stop receiving characters.
159 * @port: Ptr to the uart_port.
160 *
161 * The Serial Mux does not support this function.
162 */
163static void mux_stop_rx(struct uart_port *port)
164{
165}
166
167/**
168 * mux_break_ctl - Control the transmitssion of a break signal.
169 * @port: Ptr to the uart_port.
170 * @break_state: Raise/Lower the break signal.
171 *
172 * The Serial Mux does not support this function.
173 */
174static void mux_break_ctl(struct uart_port *port, int break_state)
175{
176}
177
178/**
179 * mux_write - Write chars to the mux fifo.
180 * @port: Ptr to the uart_port.
181 *
182 * This function writes all the data from the uart buffer to
183 * the mux fifo.
184 */
185static void mux_write(struct uart_port *port)
186{
187 int count;
188 struct circ_buf *xmit = &port->state->xmit;
189
190 if(port->x_char) {
191 UART_PUT_CHAR(port, port->x_char);
192 port->icount.tx++;
193 port->x_char = 0;
194 return;
195 }
196
197 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
198 mux_stop_tx(port);
199 return;
200 }
201
202 count = (port->fifosize) - UART_GET_FIFO_CNT(port);
203 do {
204 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
205 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
206 port->icount.tx++;
207 if(uart_circ_empty(xmit))
208 break;
209
210 } while(--count > 0);
211
212 while(UART_GET_FIFO_CNT(port))
213 udelay(1);
214
215 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
216 uart_write_wakeup(port);
217
218 if (uart_circ_empty(xmit))
219 mux_stop_tx(port);
220}
221
222/**
223 * mux_read - Read chars from the mux fifo.
224 * @port: Ptr to the uart_port.
225 *
226 * This reads all available data from the mux's fifo and pushes
227 * the data to the tty layer.
228 */
229static void mux_read(struct uart_port *port)
230{
231 struct tty_port *tport = &port->state->port;
232 int data;
233 __u32 start_count = port->icount.rx;
234
235 while(1) {
236 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
237
238 if (MUX_STATUS(data))
239 continue;
240
241 if (MUX_EOFIFO(data))
242 break;
243
244 port->icount.rx++;
245
246 if (MUX_BREAK(data)) {
247 port->icount.brk++;
248 if(uart_handle_break(port))
249 continue;
250 }
251
252 if (uart_handle_sysrq_char(port, data & 0xffu))
253 continue;
254
255 tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL);
256 }
257
258 if (start_count != port->icount.rx)
259 tty_flip_buffer_push(tport);
260}
261
262/**
263 * mux_startup - Initialize the port.
264 * @port: Ptr to the uart_port.
265 *
266 * Grab any resources needed for this port and start the
267 * mux timer.
268 */
269static int mux_startup(struct uart_port *port)
270{
271 mux_ports[port->line].enabled = 1;
272 return 0;
273}
274
275/**
276 * mux_shutdown - Disable the port.
277 * @port: Ptr to the uart_port.
278 *
279 * Release any resources needed for the port.
280 */
281static void mux_shutdown(struct uart_port *port)
282{
283 mux_ports[port->line].enabled = 0;
284}
285
286/**
287 * mux_set_termios - Chane port parameters.
288 * @port: Ptr to the uart_port.
289 * @termios: new termios settings.
290 * @old: old termios settings.
291 *
292 * The Serial Mux does not support this function.
293 */
294static void
295mux_set_termios(struct uart_port *port, struct ktermios *termios,
296 struct ktermios *old)
297{
298}
299
300/**
301 * mux_type - Describe the port.
302 * @port: Ptr to the uart_port.
303 *
304 * Return a pointer to a string constant describing the
305 * specified port.
306 */
307static const char *mux_type(struct uart_port *port)
308{
309 return "Mux";
310}
311
312/**
313 * mux_release_port - Release memory and IO regions.
314 * @port: Ptr to the uart_port.
315 *
316 * Release any memory and IO region resources currently in use by
317 * the port.
318 */
319static void mux_release_port(struct uart_port *port)
320{
321}
322
323/**
324 * mux_request_port - Request memory and IO regions.
325 * @port: Ptr to the uart_port.
326 *
327 * Request any memory and IO region resources required by the port.
328 * If any fail, no resources should be registered when this function
329 * returns, and it should return -EBUSY on failure.
330 */
331static int mux_request_port(struct uart_port *port)
332{
333 return 0;
334}
335
336/**
337 * mux_config_port - Perform port autoconfiguration.
338 * @port: Ptr to the uart_port.
339 * @type: Bitmask of required configurations.
340 *
341 * Perform any autoconfiguration steps for the port. This function is
342 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
343 * [Note: This is required for now because of a bug in the Serial core.
344 * rmk has already submitted a patch to linus, should be available for
345 * 2.5.47.]
346 */
347static void mux_config_port(struct uart_port *port, int type)
348{
349 port->type = PORT_MUX;
350}
351
352/**
353 * mux_verify_port - Verify the port information.
354 * @port: Ptr to the uart_port.
355 * @ser: Ptr to the serial information.
356 *
357 * Verify the new serial port information contained within serinfo is
358 * suitable for this port type.
359 */
360static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
361{
362 if(port->membase == NULL)
363 return -EINVAL;
364
365 return 0;
366}
367
368/**
369 * mux_drv_poll - Mux poll function.
370 * @unused: Unused variable
371 *
372 * This function periodically polls the Serial MUX to check for new data.
373 */
374static void mux_poll(struct timer_list *unused)
375{
376 int i;
377
378 for(i = 0; i < port_cnt; ++i) {
379 if(!mux_ports[i].enabled)
380 continue;
381
382 mux_read(&mux_ports[i].port);
383 mux_write(&mux_ports[i].port);
384 }
385
386 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
387}
388
389
390#ifdef CONFIG_SERIAL_MUX_CONSOLE
391static void mux_console_write(struct console *co, const char *s, unsigned count)
392{
393 /* Wait until the FIFO drains. */
394 while(UART_GET_FIFO_CNT(&mux_ports[0].port))
395 udelay(1);
396
397 while(count--) {
398 if(*s == '\n') {
399 UART_PUT_CHAR(&mux_ports[0].port, '\r');
400 }
401 UART_PUT_CHAR(&mux_ports[0].port, *s++);
402 }
403
404}
405
406static int mux_console_setup(struct console *co, char *options)
407{
408 return 0;
409}
410
411static struct console mux_console = {
412 .name = "ttyB",
413 .write = mux_console_write,
414 .device = uart_console_device,
415 .setup = mux_console_setup,
416 .flags = CON_ENABLED | CON_PRINTBUFFER,
417 .index = 0,
418 .data = &mux_driver,
419};
420
421#define MUX_CONSOLE &mux_console
422#else
423#define MUX_CONSOLE NULL
424#endif
425
426static const struct uart_ops mux_pops = {
427 .tx_empty = mux_tx_empty,
428 .set_mctrl = mux_set_mctrl,
429 .get_mctrl = mux_get_mctrl,
430 .stop_tx = mux_stop_tx,
431 .start_tx = mux_start_tx,
432 .stop_rx = mux_stop_rx,
433 .break_ctl = mux_break_ctl,
434 .startup = mux_startup,
435 .shutdown = mux_shutdown,
436 .set_termios = mux_set_termios,
437 .type = mux_type,
438 .release_port = mux_release_port,
439 .request_port = mux_request_port,
440 .config_port = mux_config_port,
441 .verify_port = mux_verify_port,
442};
443
444/**
445 * mux_probe - Determine if the Serial Mux should claim this device.
446 * @dev: The parisc device.
447 *
448 * Deterimine if the Serial Mux should claim this chip (return 0)
449 * or not (return 1).
450 */
451static int __init mux_probe(struct parisc_device *dev)
452{
453 int i, status;
454
455 int port_count = get_mux_port_count(dev);
456 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
457
458 dev_set_drvdata(&dev->dev, (void *)(long)port_count);
459 request_mem_region(dev->hpa.start + MUX_OFFSET,
460 port_count * MUX_LINE_OFFSET, "Mux");
461
462 if(!port_cnt) {
463 mux_driver.cons = MUX_CONSOLE;
464
465 status = uart_register_driver(&mux_driver);
466 if(status) {
467 printk(KERN_ERR "Serial mux: Unable to register driver.\n");
468 return 1;
469 }
470 }
471
472 for(i = 0; i < port_count; ++i, ++port_cnt) {
473 struct uart_port *port = &mux_ports[port_cnt].port;
474 port->iobase = 0;
475 port->mapbase = dev->hpa.start + MUX_OFFSET +
476 (i * MUX_LINE_OFFSET);
477 port->membase = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
478 port->iotype = UPIO_MEM;
479 port->type = PORT_MUX;
480 port->irq = 0;
481 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;
486
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;
493 spin_lock_init(&port->lock);
494
495 status = uart_add_one_port(&mux_driver, port);
496 BUG_ON(status);
497 }
498
499 return 0;
500}
501
502static int __exit mux_remove(struct parisc_device *dev)
503{
504 int i, j;
505 int port_count = (long)dev_get_drvdata(&dev->dev);
506
507 /* Find Port 0 for this card in the mux_ports list. */
508 for(i = 0; i < port_cnt; ++i) {
509 if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
510 break;
511 }
512 BUG_ON(i + port_count > port_cnt);
513
514 /* Release the resources associated with each port on the device. */
515 for(j = 0; j < port_count; ++j, ++i) {
516 struct uart_port *port = &mux_ports[i].port;
517
518 uart_remove_one_port(&mux_driver, port);
519 if(port->membase)
520 iounmap(port->membase);
521 }
522
523 release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
524 return 0;
525}
526
527/* Hack. This idea was taken from the 8250_gsc.c on how to properly order
528 * the serial port detection in the proper order. The idea is we always
529 * want the builtin mux to be detected before addin mux cards, so we
530 * specifically probe for the builtin mux cards first.
531 *
532 * This table only contains the parisc_device_id of known builtin mux
533 * devices. All other mux cards will be detected by the generic mux_tbl.
534 */
535static const struct parisc_device_id builtin_mux_tbl[] __initconst = {
536 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
537 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
538 { 0, }
539};
540
541static const struct parisc_device_id mux_tbl[] __initconst = {
542 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
543 { 0, }
544};
545
546MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
547MODULE_DEVICE_TABLE(parisc, mux_tbl);
548
549static struct parisc_driver builtin_serial_mux_driver __refdata = {
550 .name = "builtin_serial_mux",
551 .id_table = builtin_mux_tbl,
552 .probe = mux_probe,
553 .remove = __exit_p(mux_remove),
554};
555
556static struct parisc_driver serial_mux_driver __refdata = {
557 .name = "serial_mux",
558 .id_table = mux_tbl,
559 .probe = mux_probe,
560 .remove = __exit_p(mux_remove),
561};
562
563/**
564 * mux_init - Serial MUX initialization procedure.
565 *
566 * Register the Serial MUX driver.
567 */
568static int __init mux_init(void)
569{
570 register_parisc_driver(&builtin_serial_mux_driver);
571 register_parisc_driver(&serial_mux_driver);
572
573 if(port_cnt > 0) {
574 /* Start the Mux timer */
575 timer_setup(&mux_timer, mux_poll, 0);
576 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
577
578#ifdef CONFIG_SERIAL_MUX_CONSOLE
579 register_console(&mux_console);
580#endif
581 }
582
583 return 0;
584}
585
586/**
587 * mux_exit - Serial MUX cleanup procedure.
588 *
589 * Unregister the Serial MUX driver from the tty layer.
590 */
591static void __exit mux_exit(void)
592{
593 /* Delete the Mux timer. */
594 if(port_cnt > 0) {
595 del_timer_sync(&mux_timer);
596#ifdef CONFIG_SERIAL_MUX_CONSOLE
597 unregister_console(&mux_console);
598#endif
599 }
600
601 unregister_parisc_driver(&builtin_serial_mux_driver);
602 unregister_parisc_driver(&serial_mux_driver);
603 uart_unregister_driver(&mux_driver);
604}
605
606module_init(mux_init);
607module_exit(mux_exit);
608
609MODULE_AUTHOR("Ryan Bradetich");
610MODULE_DESCRIPTION("Serial MUX driver");
611MODULE_LICENSE("GPL");
612MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);
1/*
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
19#include <linux/module.h>
20#include <linux/ioport.h>
21#include <linux/init.h>
22#include <linux/serial.h>
23#include <linux/tty.h>
24#include <linux/tty_flip.h>
25#include <linux/console.h>
26#include <linux/delay.h> /* for udelay */
27#include <linux/device.h>
28#include <asm/io.h>
29#include <asm/irq.h>
30#include <asm/parisc-device.h>
31
32#if defined(CONFIG_SERIAL_MUX_CONSOLE) && defined(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
53static unsigned int port_cnt __read_mostly;
54struct mux_port {
55 struct uart_port port;
56 int enabled;
57};
58static struct mux_port mux_ports[MUX_NR];
59
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
71#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)
73
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{
86 int status;
87 u8 iodc_data[32];
88 unsigned long bytecnt;
89
90 /* 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 */
94 if(dev->id.hversion == 0x15)
95 return 1;
96
97 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
98 BUG_ON(status != PDC_OK);
99
100 /* Return the number of ports specified in the iodc data. */
101 return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8;
102}
103
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{
114 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
115}
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.
144 *
145 * The Serial MUX does not support this function.
146 */
147static void mux_stop_tx(struct uart_port *port)
148{
149}
150
151/**
152 * mux_start_tx - Start transmitting characters.
153 * @port: Ptr to the uart_port.
154 *
155 * The Serial Mux does not support this function.
156 */
157static void mux_start_tx(struct uart_port *port)
158{
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_break_ctl - Control the transmitssion of a break signal.
173 * @port: Ptr to the uart_port.
174 * @break_state: Raise/Lower the break signal.
175 *
176 * The Serial Mux does not support this function.
177 */
178static void mux_break_ctl(struct uart_port *port, int break_state)
179{
180}
181
182/**
183 * mux_write - Write chars to the mux fifo.
184 * @port: Ptr to the uart_port.
185 *
186 * This function writes all the data from the uart buffer to
187 * the mux fifo.
188 */
189static void mux_write(struct uart_port *port)
190{
191 int count;
192 struct circ_buf *xmit = &port->state->xmit;
193
194 if(port->x_char) {
195 UART_PUT_CHAR(port, port->x_char);
196 port->icount.tx++;
197 port->x_char = 0;
198 return;
199 }
200
201 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
202 mux_stop_tx(port);
203 return;
204 }
205
206 count = (port->fifosize) - UART_GET_FIFO_CNT(port);
207 do {
208 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
209 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
210 port->icount.tx++;
211 if(uart_circ_empty(xmit))
212 break;
213
214 } while(--count > 0);
215
216 while(UART_GET_FIFO_CNT(port))
217 udelay(1);
218
219 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
220 uart_write_wakeup(port);
221
222 if (uart_circ_empty(xmit))
223 mux_stop_tx(port);
224}
225
226/**
227 * mux_read - Read chars from the mux fifo.
228 * @port: Ptr to the uart_port.
229 *
230 * This reads all available data from the mux's fifo and pushes
231 * the data to the tty layer.
232 */
233static void mux_read(struct uart_port *port)
234{
235 struct tty_port *tport = &port->state->port;
236 int data;
237 __u32 start_count = port->icount.rx;
238
239 while(1) {
240 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
241
242 if (MUX_STATUS(data))
243 continue;
244
245 if (MUX_EOFIFO(data))
246 break;
247
248 port->icount.rx++;
249
250 if (MUX_BREAK(data)) {
251 port->icount.brk++;
252 if(uart_handle_break(port))
253 continue;
254 }
255
256 if (uart_handle_sysrq_char(port, data & 0xffu))
257 continue;
258
259 tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL);
260 }
261
262 if (start_count != port->icount.rx)
263 tty_flip_buffer_push(tport);
264}
265
266/**
267 * mux_startup - Initialize the port.
268 * @port: Ptr to the uart_port.
269 *
270 * Grab any resources needed for this port and start the
271 * mux timer.
272 */
273static int mux_startup(struct uart_port *port)
274{
275 mux_ports[port->line].enabled = 1;
276 return 0;
277}
278
279/**
280 * mux_shutdown - Disable the port.
281 * @port: Ptr to the uart_port.
282 *
283 * Release any resources needed for the port.
284 */
285static void mux_shutdown(struct uart_port *port)
286{
287 mux_ports[port->line].enabled = 0;
288}
289
290/**
291 * mux_set_termios - Chane port parameters.
292 * @port: Ptr to the uart_port.
293 * @termios: new termios settings.
294 * @old: old termios settings.
295 *
296 * The Serial Mux does not support this function.
297 */
298static void
299mux_set_termios(struct uart_port *port, struct ktermios *termios,
300 struct ktermios *old)
301{
302}
303
304/**
305 * mux_type - Describe the port.
306 * @port: Ptr to the uart_port.
307 *
308 * Return a pointer to a string constant describing the
309 * specified port.
310 */
311static const char *mux_type(struct uart_port *port)
312{
313 return "Mux";
314}
315
316/**
317 * mux_release_port - Release memory and IO regions.
318 * @port: Ptr to the uart_port.
319 *
320 * Release any memory and IO region resources currently in use by
321 * the port.
322 */
323static void mux_release_port(struct uart_port *port)
324{
325}
326
327/**
328 * mux_request_port - Request memory and IO regions.
329 * @port: Ptr to the uart_port.
330 *
331 * Request any memory and IO region resources required by the port.
332 * If any fail, no resources should be registered when this function
333 * returns, and it should return -EBUSY on failure.
334 */
335static int mux_request_port(struct uart_port *port)
336{
337 return 0;
338}
339
340/**
341 * mux_config_port - Perform port autoconfiguration.
342 * @port: Ptr to the uart_port.
343 * @type: Bitmask of required configurations.
344 *
345 * Perform any autoconfiguration steps for the port. This function is
346 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
347 * [Note: This is required for now because of a bug in the Serial core.
348 * rmk has already submitted a patch to linus, should be available for
349 * 2.5.47.]
350 */
351static void mux_config_port(struct uart_port *port, int type)
352{
353 port->type = PORT_MUX;
354}
355
356/**
357 * mux_verify_port - Verify the port information.
358 * @port: Ptr to the uart_port.
359 * @ser: Ptr to the serial information.
360 *
361 * Verify the new serial port information contained within serinfo is
362 * suitable for this port type.
363 */
364static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
365{
366 if(port->membase == NULL)
367 return -EINVAL;
368
369 return 0;
370}
371
372/**
373 * mux_drv_poll - Mux poll function.
374 * @unused: Unused variable
375 *
376 * This function periodically polls the Serial MUX to check for new data.
377 */
378static void mux_poll(unsigned long unused)
379{
380 int i;
381
382 for(i = 0; i < port_cnt; ++i) {
383 if(!mux_ports[i].enabled)
384 continue;
385
386 mux_read(&mux_ports[i].port);
387 mux_write(&mux_ports[i].port);
388 }
389
390 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
391}
392
393
394#ifdef CONFIG_SERIAL_MUX_CONSOLE
395static void mux_console_write(struct console *co, const char *s, unsigned count)
396{
397 /* Wait until the FIFO drains. */
398 while(UART_GET_FIFO_CNT(&mux_ports[0].port))
399 udelay(1);
400
401 while(count--) {
402 if(*s == '\n') {
403 UART_PUT_CHAR(&mux_ports[0].port, '\r');
404 }
405 UART_PUT_CHAR(&mux_ports[0].port, *s++);
406 }
407
408}
409
410static int mux_console_setup(struct console *co, char *options)
411{
412 return 0;
413}
414
415static struct console mux_console = {
416 .name = "ttyB",
417 .write = mux_console_write,
418 .device = uart_console_device,
419 .setup = mux_console_setup,
420 .flags = CON_ENABLED | CON_PRINTBUFFER,
421 .index = 0,
422 .data = &mux_driver,
423};
424
425#define MUX_CONSOLE &mux_console
426#else
427#define MUX_CONSOLE NULL
428#endif
429
430static struct uart_ops mux_pops = {
431 .tx_empty = mux_tx_empty,
432 .set_mctrl = mux_set_mctrl,
433 .get_mctrl = mux_get_mctrl,
434 .stop_tx = mux_stop_tx,
435 .start_tx = mux_start_tx,
436 .stop_rx = mux_stop_rx,
437 .break_ctl = mux_break_ctl,
438 .startup = mux_startup,
439 .shutdown = mux_shutdown,
440 .set_termios = mux_set_termios,
441 .type = mux_type,
442 .release_port = mux_release_port,
443 .request_port = mux_request_port,
444 .config_port = mux_config_port,
445 .verify_port = mux_verify_port,
446};
447
448/**
449 * mux_probe - Determine if the Serial Mux should claim this device.
450 * @dev: The parisc device.
451 *
452 * Deterimine if the Serial Mux should claim this chip (return 0)
453 * or not (return 1).
454 */
455static int __init mux_probe(struct parisc_device *dev)
456{
457 int i, status;
458
459 int port_count = get_mux_port_count(dev);
460 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
461
462 dev_set_drvdata(&dev->dev, (void *)(long)port_count);
463 request_mem_region(dev->hpa.start + MUX_OFFSET,
464 port_count * MUX_LINE_OFFSET, "Mux");
465
466 if(!port_cnt) {
467 mux_driver.cons = MUX_CONSOLE;
468
469 status = uart_register_driver(&mux_driver);
470 if(status) {
471 printk(KERN_ERR "Serial mux: Unable to register driver.\n");
472 return 1;
473 }
474 }
475
476 for(i = 0; i < port_count; ++i, ++port_cnt) {
477 struct uart_port *port = &mux_ports[port_cnt].port;
478 port->iobase = 0;
479 port->mapbase = dev->hpa.start + MUX_OFFSET +
480 (i * MUX_LINE_OFFSET);
481 port->membase = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
482 port->iotype = UPIO_MEM;
483 port->type = PORT_MUX;
484 port->irq = 0;
485 port->uartclk = 0;
486 port->fifosize = MUX_FIFO_SIZE;
487 port->ops = &mux_pops;
488 port->flags = UPF_BOOT_AUTOCONF;
489 port->line = port_cnt;
490
491 /* The port->timeout needs to match what is present in
492 * uart_wait_until_sent in serial_core.c. Otherwise
493 * the time spent in msleep_interruptable will be very
494 * long, causing the appearance of a console hang.
495 */
496 port->timeout = HZ / 50;
497 spin_lock_init(&port->lock);
498
499 status = uart_add_one_port(&mux_driver, port);
500 BUG_ON(status);
501 }
502
503 return 0;
504}
505
506static int mux_remove(struct parisc_device *dev)
507{
508 int i, j;
509 int port_count = (long)dev_get_drvdata(&dev->dev);
510
511 /* Find Port 0 for this card in the mux_ports list. */
512 for(i = 0; i < port_cnt; ++i) {
513 if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
514 break;
515 }
516 BUG_ON(i + port_count > port_cnt);
517
518 /* Release the resources associated with each port on the device. */
519 for(j = 0; j < port_count; ++j, ++i) {
520 struct uart_port *port = &mux_ports[i].port;
521
522 uart_remove_one_port(&mux_driver, port);
523 if(port->membase)
524 iounmap(port->membase);
525 }
526
527 release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
528 return 0;
529}
530
531/* Hack. This idea was taken from the 8250_gsc.c on how to properly order
532 * the serial port detection in the proper order. The idea is we always
533 * want the builtin mux to be detected before addin mux cards, so we
534 * specifically probe for the builtin mux cards first.
535 *
536 * This table only contains the parisc_device_id of known builtin mux
537 * devices. All other mux cards will be detected by the generic mux_tbl.
538 */
539static struct parisc_device_id builtin_mux_tbl[] = {
540 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
541 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
542 { 0, }
543};
544
545static struct parisc_device_id mux_tbl[] = {
546 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
547 { 0, }
548};
549
550MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
551MODULE_DEVICE_TABLE(parisc, mux_tbl);
552
553static struct parisc_driver builtin_serial_mux_driver = {
554 .name = "builtin_serial_mux",
555 .id_table = builtin_mux_tbl,
556 .probe = mux_probe,
557 .remove = mux_remove,
558};
559
560static struct parisc_driver serial_mux_driver = {
561 .name = "serial_mux",
562 .id_table = mux_tbl,
563 .probe = mux_probe,
564 .remove = mux_remove,
565};
566
567/**
568 * mux_init - Serial MUX initialization procedure.
569 *
570 * Register the Serial MUX driver.
571 */
572static int __init mux_init(void)
573{
574 register_parisc_driver(&builtin_serial_mux_driver);
575 register_parisc_driver(&serial_mux_driver);
576
577 if(port_cnt > 0) {
578 /* Start the Mux timer */
579 init_timer(&mux_timer);
580 mux_timer.function = mux_poll;
581 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
582
583#ifdef CONFIG_SERIAL_MUX_CONSOLE
584 register_console(&mux_console);
585#endif
586 }
587
588 return 0;
589}
590
591/**
592 * mux_exit - Serial MUX cleanup procedure.
593 *
594 * Unregister the Serial MUX driver from the tty layer.
595 */
596static void __exit mux_exit(void)
597{
598 /* Delete the Mux timer. */
599 if(port_cnt > 0) {
600 del_timer_sync(&mux_timer);
601#ifdef CONFIG_SERIAL_MUX_CONSOLE
602 unregister_console(&mux_console);
603#endif
604 }
605
606 unregister_parisc_driver(&builtin_serial_mux_driver);
607 unregister_parisc_driver(&serial_mux_driver);
608 uart_unregister_driver(&mux_driver);
609}
610
611module_init(mux_init);
612module_exit(mux_exit);
613
614MODULE_AUTHOR("Ryan Bradetich");
615MODULE_DESCRIPTION("Serial MUX driver");
616MODULE_LICENSE("GPL");
617MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);