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 <asm/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
45 static unsigned int port_cnt __read_mostly;
46 struct mux_port {
47 	struct uart_port port;
48 	int enabled;
49 };
50 static struct mux_port mux_ports[MUX_NR];
51 
52 static 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 
61 static 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  */
get_mux_port_count(struct parisc_device * dev)76 static 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  */
mux_tx_empty(struct uart_port * port)104 static 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  */
mux_set_mctrl(struct uart_port * port,unsigned int mctrl)117 static 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  */
mux_get_mctrl(struct uart_port * port)128 static 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  */
mux_stop_tx(struct uart_port * port)139 static 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  */
mux_start_tx(struct uart_port * port)149 static 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  */
mux_stop_rx(struct uart_port * port)159 static 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  */
mux_break_ctl(struct uart_port * port,int break_state)170 static void mux_break_ctl(struct uart_port *port, int break_state)
171 {
172 }
173 
174 /**
175  * mux_write - Write chars to the mux fifo.
176  * @port: Ptr to the uart_port.
177  *
178  * This function writes all the data from the uart buffer to
179  * the mux fifo.
180  */
mux_write(struct uart_port * port)181 static void mux_write(struct uart_port *port)
182 {
183 	int count;
184 	struct circ_buf *xmit = &port->state->xmit;
185 
186 	if(port->x_char) {
187 		UART_PUT_CHAR(port, port->x_char);
188 		port->icount.tx++;
189 		port->x_char = 0;
190 		return;
191 	}
192 
193 	if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
194 		mux_stop_tx(port);
195 		return;
196 	}
197 
198 	count = (port->fifosize) - UART_GET_FIFO_CNT(port);
199 	do {
200 		UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
201 		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
202 		port->icount.tx++;
203 		if(uart_circ_empty(xmit))
204 			break;
205 
206 	} while(--count > 0);
207 
208 	while(UART_GET_FIFO_CNT(port))
209 		udelay(1);
210 
211 	if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
212 		uart_write_wakeup(port);
213 
214 	if (uart_circ_empty(xmit))
215 		mux_stop_tx(port);
216 }
217 
218 /**
219  * mux_read - Read chars from the mux fifo.
220  * @port: Ptr to the uart_port.
221  *
222  * This reads all available data from the mux's fifo and pushes
223  * the data to the tty layer.
224  */
mux_read(struct uart_port * port)225 static void mux_read(struct uart_port *port)
226 {
227 	struct tty_port *tport = &port->state->port;
228 	int data;
229 	__u32 start_count = port->icount.rx;
230 
231 	while(1) {
232 		data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
233 
234 		if (MUX_STATUS(data))
235 			continue;
236 
237 		if (MUX_EOFIFO(data))
238 			break;
239 
240 		port->icount.rx++;
241 
242 		if (MUX_BREAK(data)) {
243 			port->icount.brk++;
244 			if(uart_handle_break(port))
245 				continue;
246 		}
247 
248 		if (uart_handle_sysrq_char(port, data & 0xffu))
249 			continue;
250 
251 		tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL);
252 	}
253 
254 	if (start_count != port->icount.rx)
255 		tty_flip_buffer_push(tport);
256 }
257 
258 /**
259  * mux_startup - Initialize the port.
260  * @port: Ptr to the uart_port.
261  *
262  * Grab any resources needed for this port and start the
263  * mux timer.
264  */
mux_startup(struct uart_port * port)265 static int mux_startup(struct uart_port *port)
266 {
267 	mux_ports[port->line].enabled = 1;
268 	return 0;
269 }
270 
271 /**
272  * mux_shutdown - Disable the port.
273  * @port: Ptr to the uart_port.
274  *
275  * Release any resources needed for the port.
276  */
mux_shutdown(struct uart_port * port)277 static void mux_shutdown(struct uart_port *port)
278 {
279 	mux_ports[port->line].enabled = 0;
280 }
281 
282 /**
283  * mux_set_termios - Chane port parameters.
284  * @port: Ptr to the uart_port.
285  * @termios: new termios settings.
286  * @old: old termios settings.
287  *
288  * The Serial Mux does not support this function.
289  */
290 static void
mux_set_termios(struct uart_port * port,struct ktermios * termios,struct ktermios * old)291 mux_set_termios(struct uart_port *port, struct ktermios *termios,
292 	        struct ktermios *old)
293 {
294 }
295 
296 /**
297  * mux_type - Describe the port.
298  * @port: Ptr to the uart_port.
299  *
300  * Return a pointer to a string constant describing the
301  * specified port.
302  */
mux_type(struct uart_port * port)303 static const char *mux_type(struct uart_port *port)
304 {
305 	return "Mux";
306 }
307 
308 /**
309  * mux_release_port - Release memory and IO regions.
310  * @port: Ptr to the uart_port.
311  *
312  * Release any memory and IO region resources currently in use by
313  * the port.
314  */
mux_release_port(struct uart_port * port)315 static void mux_release_port(struct uart_port *port)
316 {
317 }
318 
319 /**
320  * mux_request_port - Request memory and IO regions.
321  * @port: Ptr to the uart_port.
322  *
323  * Request any memory and IO region resources required by the port.
324  * If any fail, no resources should be registered when this function
325  * returns, and it should return -EBUSY on failure.
326  */
mux_request_port(struct uart_port * port)327 static int mux_request_port(struct uart_port *port)
328 {
329 	return 0;
330 }
331 
332 /**
333  * mux_config_port - Perform port autoconfiguration.
334  * @port: Ptr to the uart_port.
335  * @type: Bitmask of required configurations.
336  *
337  * Perform any autoconfiguration steps for the port.  This function is
338  * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
339  * [Note: This is required for now because of a bug in the Serial core.
340  *  rmk has already submitted a patch to linus, should be available for
341  *  2.5.47.]
342  */
mux_config_port(struct uart_port * port,int type)343 static void mux_config_port(struct uart_port *port, int type)
344 {
345 	port->type = PORT_MUX;
346 }
347 
348 /**
349  * mux_verify_port - Verify the port information.
350  * @port: Ptr to the uart_port.
351  * @ser: Ptr to the serial information.
352  *
353  * Verify the new serial port information contained within serinfo is
354  * suitable for this port type.
355  */
mux_verify_port(struct uart_port * port,struct serial_struct * ser)356 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
357 {
358 	if(port->membase == NULL)
359 		return -EINVAL;
360 
361 	return 0;
362 }
363 
364 /**
365  * mux_drv_poll - Mux poll function.
366  * @unused: Unused variable
367  *
368  * This function periodically polls the Serial MUX to check for new data.
369  */
mux_poll(struct timer_list * unused)370 static void mux_poll(struct timer_list *unused)
371 {
372 	int i;
373 
374 	for(i = 0; i < port_cnt; ++i) {
375 		if(!mux_ports[i].enabled)
376 			continue;
377 
378 		mux_read(&mux_ports[i].port);
379 		mux_write(&mux_ports[i].port);
380 	}
381 
382 	mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
383 }
384 
385 
386 #ifdef CONFIG_SERIAL_MUX_CONSOLE
mux_console_write(struct console * co,const char * s,unsigned count)387 static void mux_console_write(struct console *co, const char *s, unsigned count)
388 {
389 	/* Wait until the FIFO drains. */
390 	while(UART_GET_FIFO_CNT(&mux_ports[0].port))
391 		udelay(1);
392 
393 	while(count--) {
394 		if(*s == '\n') {
395 			UART_PUT_CHAR(&mux_ports[0].port, '\r');
396 		}
397 		UART_PUT_CHAR(&mux_ports[0].port, *s++);
398 	}
399 
400 }
401 
mux_console_setup(struct console * co,char * options)402 static int mux_console_setup(struct console *co, char *options)
403 {
404         return 0;
405 }
406 
407 static struct console mux_console = {
408 	.name =		"ttyB",
409 	.write =	mux_console_write,
410 	.device =	uart_console_device,
411 	.setup =	mux_console_setup,
412 	.flags =	CON_ENABLED | CON_PRINTBUFFER,
413 	.index =	0,
414 	.data =		&mux_driver,
415 };
416 
417 #define MUX_CONSOLE	&mux_console
418 #else
419 #define MUX_CONSOLE	NULL
420 #endif
421 
422 static const struct uart_ops mux_pops = {
423 	.tx_empty =		mux_tx_empty,
424 	.set_mctrl =		mux_set_mctrl,
425 	.get_mctrl =		mux_get_mctrl,
426 	.stop_tx =		mux_stop_tx,
427 	.start_tx =		mux_start_tx,
428 	.stop_rx =		mux_stop_rx,
429 	.break_ctl =		mux_break_ctl,
430 	.startup =		mux_startup,
431 	.shutdown =		mux_shutdown,
432 	.set_termios =		mux_set_termios,
433 	.type =			mux_type,
434 	.release_port =		mux_release_port,
435 	.request_port =		mux_request_port,
436 	.config_port =		mux_config_port,
437 	.verify_port =		mux_verify_port,
438 };
439 
440 /**
441  * mux_probe - Determine if the Serial Mux should claim this device.
442  * @dev: The parisc device.
443  *
444  * Deterimine if the Serial Mux should claim this chip (return 0)
445  * or not (return 1).
446  */
mux_probe(struct parisc_device * dev)447 static int __init mux_probe(struct parisc_device *dev)
448 {
449 	int i, status;
450 
451 	int port_count = get_mux_port_count(dev);
452 	printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
453 
454 	dev_set_drvdata(&dev->dev, (void *)(long)port_count);
455 	request_mem_region(dev->hpa.start + MUX_OFFSET,
456                            port_count * MUX_LINE_OFFSET, "Mux");
457 
458 	if(!port_cnt) {
459 		mux_driver.cons = MUX_CONSOLE;
460 
461 		status = uart_register_driver(&mux_driver);
462 		if(status) {
463 			printk(KERN_ERR "Serial mux: Unable to register driver.\n");
464 			return 1;
465 		}
466 	}
467 
468 	for(i = 0; i < port_count; ++i, ++port_cnt) {
469 		struct uart_port *port = &mux_ports[port_cnt].port;
470 		port->iobase	= 0;
471 		port->mapbase	= dev->hpa.start + MUX_OFFSET +
472 						(i * MUX_LINE_OFFSET);
473 		port->membase	= ioremap(port->mapbase, MUX_LINE_OFFSET);
474 		port->iotype	= UPIO_MEM;
475 		port->type	= PORT_MUX;
476 		port->irq	= 0;
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 		port->has_sysrq = IS_ENABLED(CONFIG_SERIAL_MUX_CONSOLE);
483 
484 		/* The port->timeout needs to match what is present in
485 		 * uart_wait_until_sent in serial_core.c.  Otherwise
486 		 * the time spent in msleep_interruptable will be very
487 		 * long, causing the appearance of a console hang.
488 		 */
489 		port->timeout   = HZ / 50;
490 		spin_lock_init(&port->lock);
491 
492 		status = uart_add_one_port(&mux_driver, port);
493 		BUG_ON(status);
494 	}
495 
496 	return 0;
497 }
498 
mux_remove(struct parisc_device * dev)499 static int __exit mux_remove(struct parisc_device *dev)
500 {
501 	int i, j;
502 	int port_count = (long)dev_get_drvdata(&dev->dev);
503 
504 	/* Find Port 0 for this card in the mux_ports list. */
505 	for(i = 0; i < port_cnt; ++i) {
506 		if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
507 			break;
508 	}
509 	BUG_ON(i + port_count > port_cnt);
510 
511 	/* Release the resources associated with each port on the device. */
512 	for(j = 0; j < port_count; ++j, ++i) {
513 		struct uart_port *port = &mux_ports[i].port;
514 
515 		uart_remove_one_port(&mux_driver, port);
516 		if(port->membase)
517 			iounmap(port->membase);
518 	}
519 
520 	release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
521 	return 0;
522 }
523 
524 /* Hack.  This idea was taken from the 8250_gsc.c on how to properly order
525  * the serial port detection in the proper order.   The idea is we always
526  * want the builtin mux to be detected before addin mux cards, so we
527  * specifically probe for the builtin mux cards first.
528  *
529  * This table only contains the parisc_device_id of known builtin mux
530  * devices.  All other mux cards will be detected by the generic mux_tbl.
531  */
532 static const struct parisc_device_id builtin_mux_tbl[] __initconst = {
533 	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
534 	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
535 	{ 0, }
536 };
537 
538 static const struct parisc_device_id mux_tbl[] __initconst = {
539 	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
540 	{ 0, }
541 };
542 
543 MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
544 MODULE_DEVICE_TABLE(parisc, mux_tbl);
545 
546 static struct parisc_driver builtin_serial_mux_driver __refdata = {
547 	.name =		"builtin_serial_mux",
548 	.id_table =	builtin_mux_tbl,
549 	.probe =	mux_probe,
550 	.remove =       __exit_p(mux_remove),
551 };
552 
553 static struct parisc_driver serial_mux_driver __refdata = {
554 	.name =		"serial_mux",
555 	.id_table =	mux_tbl,
556 	.probe =	mux_probe,
557 	.remove =       __exit_p(mux_remove),
558 };
559 
560 /**
561  * mux_init - Serial MUX initialization procedure.
562  *
563  * Register the Serial MUX driver.
564  */
mux_init(void)565 static int __init mux_init(void)
566 {
567 	register_parisc_driver(&builtin_serial_mux_driver);
568 	register_parisc_driver(&serial_mux_driver);
569 
570 	if(port_cnt > 0) {
571 		/* Start the Mux timer */
572 		timer_setup(&mux_timer, mux_poll, 0);
573 		mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
574 
575 #ifdef CONFIG_SERIAL_MUX_CONSOLE
576 	        register_console(&mux_console);
577 #endif
578 	}
579 
580 	return 0;
581 }
582 
583 /**
584  * mux_exit - Serial MUX cleanup procedure.
585  *
586  * Unregister the Serial MUX driver from the tty layer.
587  */
mux_exit(void)588 static void __exit mux_exit(void)
589 {
590 	/* Delete the Mux timer. */
591 	if(port_cnt > 0) {
592 		del_timer_sync(&mux_timer);
593 #ifdef CONFIG_SERIAL_MUX_CONSOLE
594 		unregister_console(&mux_console);
595 #endif
596 	}
597 
598 	unregister_parisc_driver(&builtin_serial_mux_driver);
599 	unregister_parisc_driver(&serial_mux_driver);
600 	uart_unregister_driver(&mux_driver);
601 }
602 
603 module_init(mux_init);
604 module_exit(mux_exit);
605 
606 MODULE_AUTHOR("Ryan Bradetich");
607 MODULE_DESCRIPTION("Serial MUX driver");
608 MODULE_LICENSE("GPL");
609 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);
610