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
415struct tty_driver *mux_console_device(struct console *co, int *index)
416{
417        *index = co->index;
418	return mux_driver.tty_driver;
419}
420
421static struct console mux_console = {
422	.name =		"ttyB",
423	.write =	mux_console_write,
424	.device =	mux_console_device,
425	.setup =	mux_console_setup,
426	.flags =	CON_ENABLED | CON_PRINTBUFFER,
427	.index =	0,
428};
429
430#define MUX_CONSOLE	&mux_console
431#else
432#define MUX_CONSOLE	NULL
433#endif
434
435static struct uart_ops mux_pops = {
436	.tx_empty =		mux_tx_empty,
437	.set_mctrl =		mux_set_mctrl,
438	.get_mctrl =		mux_get_mctrl,
439	.stop_tx =		mux_stop_tx,
440	.start_tx =		mux_start_tx,
441	.stop_rx =		mux_stop_rx,
442	.break_ctl =		mux_break_ctl,
443	.startup =		mux_startup,
444	.shutdown =		mux_shutdown,
445	.set_termios =		mux_set_termios,
446	.type =			mux_type,
447	.release_port =		mux_release_port,
448	.request_port =		mux_request_port,
449	.config_port =		mux_config_port,
450	.verify_port =		mux_verify_port,
451};
452
453/**
454 * mux_probe - Determine if the Serial Mux should claim this device.
455 * @dev: The parisc device.
456 *
457 * Deterimine if the Serial Mux should claim this chip (return 0)
458 * or not (return 1).
459 */
460static int __init mux_probe(struct parisc_device *dev)
461{
462	int i, status;
463
464	int port_count = get_mux_port_count(dev);
465	printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
466
467	dev_set_drvdata(&dev->dev, (void *)(long)port_count);
468	request_mem_region(dev->hpa.start + MUX_OFFSET,
469                           port_count * MUX_LINE_OFFSET, "Mux");
470
471	if(!port_cnt) {
472		mux_driver.cons = MUX_CONSOLE;
473
474		status = uart_register_driver(&mux_driver);
475		if(status) {
476			printk(KERN_ERR "Serial mux: Unable to register driver.\n");
477			return 1;
478		}
479	}
480
481	for(i = 0; i < port_count; ++i, ++port_cnt) {
482		struct uart_port *port = &mux_ports[port_cnt].port;
483		port->iobase	= 0;
484		port->mapbase	= dev->hpa.start + MUX_OFFSET +
485						(i * MUX_LINE_OFFSET);
486		port->membase	= ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
487		port->iotype	= UPIO_MEM;
488		port->type	= PORT_MUX;
489		port->irq	= 0;
490		port->uartclk	= 0;
491		port->fifosize	= MUX_FIFO_SIZE;
492		port->ops	= &mux_pops;
493		port->flags	= UPF_BOOT_AUTOCONF;
494		port->line	= port_cnt;
495
496		/* The port->timeout needs to match what is present in
497		 * uart_wait_until_sent in serial_core.c.  Otherwise
498		 * the time spent in msleep_interruptable will be very
499		 * long, causing the appearance of a console hang.
500		 */
501		port->timeout   = HZ / 50;
502		spin_lock_init(&port->lock);
503
504		status = uart_add_one_port(&mux_driver, port);
505		BUG_ON(status);
506	}
507
508	return 0;
509}
510
511static int mux_remove(struct parisc_device *dev)
512{
513	int i, j;
514	int port_count = (long)dev_get_drvdata(&dev->dev);
515
516	/* Find Port 0 for this card in the mux_ports list. */
517	for(i = 0; i < port_cnt; ++i) {
518		if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
519			break;
520	}
521	BUG_ON(i + port_count > port_cnt);
522
523	/* Release the resources associated with each port on the device. */
524	for(j = 0; j < port_count; ++j, ++i) {
525		struct uart_port *port = &mux_ports[i].port;
526
527		uart_remove_one_port(&mux_driver, port);
528		if(port->membase)
529			iounmap(port->membase);
530	}
531
532	release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
533	return 0;
534}
535
536/* Hack.  This idea was taken from the 8250_gsc.c on how to properly order
537 * the serial port detection in the proper order.   The idea is we always
538 * want the builtin mux to be detected before addin mux cards, so we
539 * specifically probe for the builtin mux cards first.
540 *
541 * This table only contains the parisc_device_id of known builtin mux
542 * devices.  All other mux cards will be detected by the generic mux_tbl.
543 */
544static struct parisc_device_id builtin_mux_tbl[] = {
545	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
546	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
547	{ 0, }
548};
549
550static struct parisc_device_id mux_tbl[] = {
551	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
552	{ 0, }
553};
554
555MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
556MODULE_DEVICE_TABLE(parisc, mux_tbl);
557
558static struct parisc_driver builtin_serial_mux_driver = {
559	.name =		"builtin_serial_mux",
560	.id_table =	builtin_mux_tbl,
561	.probe =	mux_probe,
562	.remove =       mux_remove,
563};
564
565static struct parisc_driver serial_mux_driver = {
566	.name =		"serial_mux",
567	.id_table =	mux_tbl,
568	.probe =	mux_probe,
569	.remove =       mux_remove,
570};
571
572/**
573 * mux_init - Serial MUX initialization procedure.
574 *
575 * Register the Serial MUX driver.
576 */
577static int __init mux_init(void)
578{
579	register_parisc_driver(&builtin_serial_mux_driver);
580	register_parisc_driver(&serial_mux_driver);
581
582	if(port_cnt > 0) {
583		/* Start the Mux timer */
584		init_timer(&mux_timer);
585		mux_timer.function = mux_poll;
586		mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
587
588#ifdef CONFIG_SERIAL_MUX_CONSOLE
589	        register_console(&mux_console);
590#endif
591	}
592
593	return 0;
594}
595
596/**
597 * mux_exit - Serial MUX cleanup procedure.
598 *
599 * Unregister the Serial MUX driver from the tty layer.
600 */
601static void __exit mux_exit(void)
602{
603	/* Delete the Mux timer. */
604	if(port_cnt > 0) {
605		del_timer_sync(&mux_timer);
606#ifdef CONFIG_SERIAL_MUX_CONSOLE
607		unregister_console(&mux_console);
608#endif
609	}
610
611	unregister_parisc_driver(&builtin_serial_mux_driver);
612	unregister_parisc_driver(&serial_mux_driver);
613	uart_unregister_driver(&mux_driver);
614}
615
616module_init(mux_init);
617module_exit(mux_exit);
618
619MODULE_AUTHOR("Ryan Bradetich");
620MODULE_DESCRIPTION("Serial MUX driver");
621MODULE_LICENSE("GPL");
622MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);
623