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