This source file includes following definitions.
- get_mux_port_count
- mux_tx_empty
- mux_set_mctrl
- mux_get_mctrl
- mux_stop_tx
- mux_start_tx
- mux_stop_rx
- mux_break_ctl
- mux_write
- mux_read
- mux_startup
- mux_shutdown
- mux_set_termios
- mux_type
- mux_release_port
- mux_request_port
- mux_config_port
- mux_verify_port
- mux_poll
- mux_console_write
- mux_console_setup
- mux_probe
- mux_remove
- mux_init
- mux_exit
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
49 static unsigned int port_cnt __read_mostly;
50 struct mux_port {
51 struct uart_port port;
52 int enabled;
53 };
54 static struct mux_port mux_ports[MUX_NR];
55
56 static 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
65 static 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
80 static 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
108 static 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
121 static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
122 {
123 }
124
125
126
127
128
129
130
131
132 static 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
143 static void mux_stop_tx(struct uart_port *port)
144 {
145 }
146
147
148
149
150
151
152
153 static void mux_start_tx(struct uart_port *port)
154 {
155 }
156
157
158
159
160
161
162
163 static void mux_stop_rx(struct uart_port *port)
164 {
165 }
166
167
168
169
170
171
172
173
174 static void mux_break_ctl(struct uart_port *port, int break_state)
175 {
176 }
177
178
179
180
181
182
183
184
185 static 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
229 static 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
269 static 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
281 static 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
294 static void
295 mux_set_termios(struct uart_port *port, struct ktermios *termios,
296 struct ktermios *old)
297 {
298 }
299
300
301
302
303
304
305
306
307 static const char *mux_type(struct uart_port *port)
308 {
309 return "Mux";
310 }
311
312
313
314
315
316
317
318
319 static void mux_release_port(struct uart_port *port)
320 {
321 }
322
323
324
325
326
327
328
329
330
331 static 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
347 static 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
360 static 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
374 static 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
391 static 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
406 static int mux_console_setup(struct console *co, char *options)
407 {
408 return 0;
409 }
410
411 static 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
426 static 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
451 static 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
502 static 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
535 static 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
541 static const struct parisc_device_id mux_tbl[] __initconst = {
542 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
543 { 0, }
544 };
545
546 MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
547 MODULE_DEVICE_TABLE(parisc, mux_tbl);
548
549 static 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
556 static 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
568 static 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
591 static 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
606 module_init(mux_init);
607 module_exit(mux_exit);
608
609 MODULE_AUTHOR("Ryan Bradetich");
610 MODULE_DESCRIPTION("Serial MUX driver");
611 MODULE_LICENSE("GPL");
612 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);