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