blob: 189064607709d9ae717cdb70646062b768ba2c0d [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
19#include <linux/config.h>
20#include <linux/module.h>
21#include <linux/tty.h>
22#include <linux/ioport.h>
23#include <linux/init.h>
24#include <linux/serial.h>
25#include <linux/console.h>
26#include <linux/slab.h>
27#include <linux/delay.h> /* for udelay */
28#include <linux/device.h>
29#include <asm/io.h>
30#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
53static unsigned int port_cnt = 0;
54static struct uart_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), (unsigned long)(p)->membase + IO_DATA_REG_OFFSET)
68#define UART_GET_FIFO_CNT(p) __raw_readl((unsigned long)(p)->membase + IO_DCOUNT_REG_OFFSET)
69#define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8
70
71/**
72 * mux_tx_empty - Check if the transmitter fifo is empty.
73 * @port: Ptr to the uart_port.
74 *
75 * This function test if the transmitter fifo for the port
76 * described by 'port' is empty. If it is empty, this function
77 * should return TIOCSER_TEMT, otherwise return 0.
78 */
79static unsigned int mux_tx_empty(struct uart_port *port)
80{
81 unsigned int cnt = __raw_readl((unsigned long)port->membase
82 + IO_DCOUNT_REG_OFFSET);
83
84 return cnt ? 0 : TIOCSER_TEMT;
85}
86
87/**
88 * mux_set_mctrl - Set the current state of the modem control inputs.
89 * @ports: Ptr to the uart_port.
90 * @mctrl: Modem control bits.
91 *
92 * The Serial MUX does not support CTS, DCD or DSR so this function
93 * is ignored.
94 */
95static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
96{
97}
98
99/**
100 * mux_get_mctrl - Returns the current state of modem control inputs.
101 * @port: Ptr to the uart_port.
102 *
103 * The Serial MUX does not support CTS, DCD or DSR so these lines are
104 * treated as permanently active.
105 */
106static unsigned int mux_get_mctrl(struct uart_port *port)
107{
108 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
109}
110
111/**
112 * mux_stop_tx - Stop transmitting characters.
113 * @port: Ptr to the uart_port.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 *
115 * The Serial MUX does not support this function.
116 */
Russell Kingb129a8c2005-08-31 10:12:14 +0100117static void mux_stop_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118{
119}
120
121/**
122 * mux_start_tx - Start transmitting characters.
123 * @port: Ptr to the uart_port.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 *
125 * The Serial Mux does not support this function.
126 */
Russell Kingb129a8c2005-08-31 10:12:14 +0100127static void mux_start_tx(struct uart_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
129}
130
131/**
132 * mux_stop_rx - Stop receiving characters.
133 * @port: Ptr to the uart_port.
134 *
135 * The Serial Mux does not support this function.
136 */
137static void mux_stop_rx(struct uart_port *port)
138{
139}
140
141/**
142 * mux_enable_ms - Enable modum status interrupts.
143 * @port: Ptr to the uart_port.
144 *
145 * The Serial Mux does not support this function.
146 */
147static void mux_enable_ms(struct uart_port *port)
148{
149}
150
151/**
152 * mux_break_ctl - Control the transmitssion of a break signal.
153 * @port: Ptr to the uart_port.
154 * @break_state: Raise/Lower the break signal.
155 *
156 * The Serial Mux does not support this function.
157 */
158static void mux_break_ctl(struct uart_port *port, int break_state)
159{
160}
161
162/**
163 * mux_write - Write chars to the mux fifo.
164 * @port: Ptr to the uart_port.
165 *
166 * This function writes all the data from the uart buffer to
167 * the mux fifo.
168 */
169static void mux_write(struct uart_port *port)
170{
171 int count;
172 struct circ_buf *xmit = &port->info->xmit;
173
174 if(port->x_char) {
175 UART_PUT_CHAR(port, port->x_char);
176 port->icount.tx++;
177 port->x_char = 0;
178 return;
179 }
180
181 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
Russell Kingb129a8c2005-08-31 10:12:14 +0100182 mux_stop_tx(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 return;
184 }
185
186 count = (port->fifosize) - UART_GET_FIFO_CNT(port);
187 do {
188 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
189 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
190 port->icount.tx++;
191 if(uart_circ_empty(xmit))
192 break;
193
194 } while(--count > 0);
195
196 while(UART_GET_FIFO_CNT(port))
197 udelay(1);
198
199 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
200 uart_write_wakeup(port);
201
202 if (uart_circ_empty(xmit))
Russell Kingb129a8c2005-08-31 10:12:14 +0100203 mux_stop_tx(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204}
205
206/**
207 * mux_read - Read chars from the mux fifo.
208 * @port: Ptr to the uart_port.
209 *
210 * This reads all available data from the mux's fifo and pushes
211 * the data to the tty layer.
212 */
213static void mux_read(struct uart_port *port)
214{
215 int data;
216 struct tty_struct *tty = port->info->tty;
217 __u32 start_count = port->icount.rx;
218
219 while(1) {
220 data = __raw_readl((unsigned long)port->membase
221 + IO_DATA_REG_OFFSET);
222
223 if (MUX_STATUS(data))
224 continue;
225
226 if (MUX_EOFIFO(data))
227 break;
228
229 if (tty->flip.count >= TTY_FLIPBUF_SIZE)
230 continue;
231
232 *tty->flip.char_buf_ptr = data & 0xffu;
233 *tty->flip.flag_buf_ptr = TTY_NORMAL;
234 port->icount.rx++;
235
236 if (MUX_BREAK(data)) {
237 port->icount.brk++;
238 if(uart_handle_break(port))
239 continue;
240 }
241
242 if (uart_handle_sysrq_char(port, data & 0xffu, NULL))
243 continue;
244
245 tty->flip.flag_buf_ptr++;
246 tty->flip.char_buf_ptr++;
247 tty->flip.count++;
248 }
249
250 if (start_count != port->icount.rx) {
251 tty_flip_buffer_push(tty);
252 }
253}
254
255/**
256 * mux_startup - Initialize the port.
257 * @port: Ptr to the uart_port.
258 *
259 * Grab any resources needed for this port and start the
260 * mux timer.
261 */
262static int mux_startup(struct uart_port *port)
263{
264 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
265 return 0;
266}
267
268/**
269 * mux_shutdown - Disable the port.
270 * @port: Ptr to the uart_port.
271 *
272 * Release any resources needed for the port.
273 */
274static void mux_shutdown(struct uart_port *port)
275{
276}
277
278/**
279 * mux_set_termios - Chane port parameters.
280 * @port: Ptr to the uart_port.
281 * @termios: new termios settings.
282 * @old: old termios settings.
283 *
284 * The Serial Mux does not support this function.
285 */
286static void
287mux_set_termios(struct uart_port *port, struct termios *termios,
288 struct termios *old)
289{
290}
291
292/**
293 * mux_type - Describe the port.
294 * @port: Ptr to the uart_port.
295 *
296 * Return a pointer to a string constant describing the
297 * specified port.
298 */
299static const char *mux_type(struct uart_port *port)
300{
301 return "Mux";
302}
303
304/**
305 * mux_release_port - Release memory and IO regions.
306 * @port: Ptr to the uart_port.
307 *
308 * Release any memory and IO region resources currently in use by
309 * the port.
310 */
311static void mux_release_port(struct uart_port *port)
312{
313}
314
315/**
316 * mux_request_port - Request memory and IO regions.
317 * @port: Ptr to the uart_port.
318 *
319 * Request any memory and IO region resources required by the port.
320 * If any fail, no resources should be registered when this function
321 * returns, and it should return -EBUSY on failure.
322 */
323static int mux_request_port(struct uart_port *port)
324{
325 return 0;
326}
327
328/**
329 * mux_config_port - Perform port autoconfiguration.
330 * @port: Ptr to the uart_port.
331 * @type: Bitmask of required configurations.
332 *
333 * Perform any autoconfiguration steps for the port. This functino is
334 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
335 * [Note: This is required for now because of a bug in the Serial core.
336 * rmk has already submitted a patch to linus, should be available for
337 * 2.5.47.]
338 */
339static void mux_config_port(struct uart_port *port, int type)
340{
341 port->type = PORT_MUX;
342}
343
344/**
345 * mux_verify_port - Verify the port information.
346 * @port: Ptr to the uart_port.
347 * @ser: Ptr to the serial information.
348 *
349 * Verify the new serial port information contained within serinfo is
350 * suitable for this port type.
351 */
352static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
353{
354 if(port->membase == NULL)
355 return -EINVAL;
356
357 return 0;
358}
359
360/**
361 * mux_drv_poll - Mux poll function.
362 * @unused: Unused variable
363 *
364 * This function periodically polls the Serial MUX to check for new data.
365 */
366static void mux_poll(unsigned long unused)
367{
368 int i;
369
370 for(i = 0; i < port_cnt; ++i) {
371 if(!mux_ports[i].info)
372 continue;
373
374 mux_read(&mux_ports[i]);
375 mux_write(&mux_ports[i]);
376 }
377
378 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
379}
380
381
382#ifdef CONFIG_SERIAL_MUX_CONSOLE
383static void mux_console_write(struct console *co, const char *s, unsigned count)
384{
385 while(count--)
386 pdc_iodc_putc(*s++);
387}
388
389static int mux_console_setup(struct console *co, char *options)
390{
391 return 0;
392}
393
394struct tty_driver *mux_console_device(struct console *co, int *index)
395{
396 *index = co->index;
397 return mux_driver.tty_driver;
398}
399
400static struct console mux_console = {
401 .name = "ttyB",
402 .write = mux_console_write,
403 .device = mux_console_device,
404 .setup = mux_console_setup,
405 .flags = CON_ENABLED | CON_PRINTBUFFER,
406 .index = 0,
407};
408
409#define MUX_CONSOLE &mux_console
410#else
411#define MUX_CONSOLE NULL
412#endif
413
414static struct uart_ops mux_pops = {
415 .tx_empty = mux_tx_empty,
416 .set_mctrl = mux_set_mctrl,
417 .get_mctrl = mux_get_mctrl,
418 .stop_tx = mux_stop_tx,
419 .start_tx = mux_start_tx,
420 .stop_rx = mux_stop_rx,
421 .enable_ms = mux_enable_ms,
422 .break_ctl = mux_break_ctl,
423 .startup = mux_startup,
424 .shutdown = mux_shutdown,
425 .set_termios = mux_set_termios,
426 .type = mux_type,
427 .release_port = mux_release_port,
428 .request_port = mux_request_port,
429 .config_port = mux_config_port,
430 .verify_port = mux_verify_port,
431};
432
433/**
434 * mux_probe - Determine if the Serial Mux should claim this device.
435 * @dev: The parisc device.
436 *
437 * Deterimine if the Serial Mux should claim this chip (return 0)
438 * or not (return 1).
439 */
440static int __init mux_probe(struct parisc_device *dev)
441{
442 int i, status, ports;
443 u8 iodc_data[32];
444 unsigned long bytecnt;
445 struct uart_port *port;
446
447 status = pdc_iodc_read(&bytecnt, dev->hpa, 0, iodc_data, 32);
448 if(status != PDC_OK) {
449 printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
450 return 1;
451 }
452
453 ports = GET_MUX_PORTS(iodc_data);
454 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);
455
456 if(!port_cnt) {
457 mux_driver.cons = MUX_CONSOLE;
458
459 status = uart_register_driver(&mux_driver);
460 if(status) {
461 printk(KERN_ERR "Serial mux: Unable to register driver.\n");
462 return 1;
463 }
464
465 init_timer(&mux_timer);
466 mux_timer.function = mux_poll;
467 }
468
469 for(i = 0; i < ports; ++i, ++port_cnt) {
470 port = &mux_ports[port_cnt];
471 port->iobase = 0;
472 port->mapbase = dev->hpa + MUX_OFFSET + (i * MUX_LINE_OFFSET);
473 port->membase = ioremap(port->mapbase, MUX_LINE_OFFSET);
474 port->iotype = SERIAL_IO_MEM;
475 port->type = PORT_MUX;
476 port->irq = SERIAL_IRQ_NONE;
477 port->uartclk = 0;
478 port->fifosize = MUX_FIFO_SIZE;
479 port->ops = &mux_pops;
480 port->flags = UPF_BOOT_AUTOCONF;
481 port->line = port_cnt;
482 status = uart_add_one_port(&mux_driver, port);
483 BUG_ON(status);
484 }
485
486#ifdef CONFIG_SERIAL_MUX_CONSOLE
487 register_console(&mux_console);
488#endif
489 return 0;
490}
491
492static struct parisc_device_id mux_tbl[] = {
493 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
494 { 0, }
495};
496
497MODULE_DEVICE_TABLE(parisc, mux_tbl);
498
499static struct parisc_driver serial_mux_driver = {
500 .name = "Serial MUX",
501 .id_table = mux_tbl,
502 .probe = mux_probe,
503};
504
505/**
506 * mux_init - Serial MUX initalization procedure.
507 *
508 * Register the Serial MUX driver.
509 */
510static int __init mux_init(void)
511{
512 return register_parisc_driver(&serial_mux_driver);
513}
514
515/**
516 * mux_exit - Serial MUX cleanup procedure.
517 *
518 * Unregister the Serial MUX driver from the tty layer.
519 */
520static void __exit mux_exit(void)
521{
522 int i;
523
524 for (i = 0; i < port_cnt; i++) {
525 uart_remove_one_port(&mux_driver, &mux_ports[i]);
526 }
527
528 uart_unregister_driver(&mux_driver);
529}
530
531module_init(mux_init);
532module_exit(mux_exit);
533
534MODULE_AUTHOR("Ryan Bradetich");
535MODULE_DESCRIPTION("Serial MUX driver");
536MODULE_LICENSE("GPL");
537MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);