1
2
3
4
5
6
7
8
9
10
11
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>
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
72
73
74
75
76
77
78
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
87
88
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
97 return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8;
98}
99
100
101
102
103
104
105
106
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
115
116
117
118
119
120
121static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
122{
123}
124
125
126
127
128
129
130
131
132static unsigned int mux_get_mctrl(struct uart_port *port)
133{
134 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
135}
136
137
138
139
140
141
142
143static void mux_stop_tx(struct uart_port *port)
144{
145}
146
147
148
149
150
151
152
153static void mux_start_tx(struct uart_port *port)
154{
155}
156
157
158
159
160
161
162
163static void mux_stop_rx(struct uart_port *port)
164{
165}
166
167
168
169
170
171
172
173
174static void mux_break_ctl(struct uart_port *port, int break_state)
175{
176}
177
178
179
180
181
182
183
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
224
225
226
227
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
264
265
266
267
268
269static int mux_startup(struct uart_port *port)
270{
271 mux_ports[port->line].enabled = 1;
272 return 0;
273}
274
275
276
277
278
279
280
281static void mux_shutdown(struct uart_port *port)
282{
283 mux_ports[port->line].enabled = 0;
284}
285
286
287
288
289
290
291
292
293
294static void
295mux_set_termios(struct uart_port *port, struct ktermios *termios,
296 struct ktermios *old)
297{
298}
299
300
301
302
303
304
305
306
307static const char *mux_type(struct uart_port *port)
308{
309 return "Mux";
310}
311
312
313
314
315
316
317
318
319static void mux_release_port(struct uart_port *port)
320{
321}
322
323
324
325
326
327
328
329
330
331static int mux_request_port(struct uart_port *port)
332{
333 return 0;
334}
335
336
337
338
339
340
341
342
343
344
345
346
347static void mux_config_port(struct uart_port *port, int type)
348{
349 port->type = PORT_MUX;
350}
351
352
353
354
355
356
357
358
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
370
371
372
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
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
446
447
448
449
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
488
489
490
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
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
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
528
529
530
531
532
533
534
535static const struct parisc_device_id builtin_mux_tbl[] __initconst = {
536 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D },
537 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D },
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
565
566
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
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
588
589
590
591static void __exit mux_exit(void)
592{
593
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);
613