[mirror_ubuntu-bionic-kernel.git] / drivers / s390 / char / sclp_con.c

// SPDX-License-Identifier: GPL-2.0
/*
 * SCLP line mode console driver
 *
 * Copyright IBM Corp. 1999, 2009
 * Author(s): Martin Peschke <mpeschke@de.ibm.com>
 *	      Martin Schwidefsky <schwidefsky@de.ibm.com>
 */

#include <linux/kmod.h>
#include <linux/console.h>
#include <linux/init.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/termios.h>
#include <linux/err.h>
#include <linux/reboot.h>
#include <linux/gfp.h>

#include "sclp.h"
#include "sclp_rw.h"
#include "sclp_tty.h"

#define sclp_console_major 4		/* TTYAUX_MAJOR */
#define sclp_console_minor 64
#define sclp_console_name  "ttyS"

/* Lock to guard over changes to global variables */
static spinlock_t sclp_con_lock;
/* List of free pages that can be used for console output buffering */
static struct list_head sclp_con_pages;
/* List of full struct sclp_buffer structures ready for output */
static struct list_head sclp_con_outqueue;
/* Pointer to current console buffer */
static struct sclp_buffer *sclp_conbuf;
/* Timer for delayed output of console messages */
static struct timer_list sclp_con_timer;
/* Suspend mode flag */
static int sclp_con_suspended;
/* Flag that output queue is currently running */
static int sclp_con_queue_running;

/* Output format for console messages */
static unsigned short sclp_con_columns;
static unsigned short sclp_con_width_htab;

static void
sclp_conbuf_callback(struct sclp_buffer *buffer, int rc)
{
	unsigned long flags;
	void *page;

	do {
		page = sclp_unmake_buffer(buffer);
		spin_lock_irqsave(&sclp_con_lock, flags);

		/* Remove buffer from outqueue */
		list_del(&buffer->list);
		list_add_tail((struct list_head *) page, &sclp_con_pages);

		/* Check if there is a pending buffer on the out queue. */
		buffer = NULL;
		if (!list_empty(&sclp_con_outqueue))
			buffer = list_first_entry(&sclp_con_outqueue,
						  struct sclp_buffer, list);
		if (!buffer || sclp_con_suspended) {
			sclp_con_queue_running = 0;
			spin_unlock_irqrestore(&sclp_con_lock, flags);
			break;
		}
		spin_unlock_irqrestore(&sclp_con_lock, flags);
	} while (sclp_emit_buffer(buffer, sclp_conbuf_callback));
}

/*
 * Finalize and emit first pending buffer.
 */
static void sclp_conbuf_emit(void)
{
	struct sclp_buffer* buffer;
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&sclp_con_lock, flags);
	if (sclp_conbuf)
		list_add_tail(&sclp_conbuf->list, &sclp_con_outqueue);
	sclp_conbuf = NULL;
	if (sclp_con_queue_running || sclp_con_suspended)
		goto out_unlock;
	if (list_empty(&sclp_con_outqueue))
		goto out_unlock;
	buffer = list_first_entry(&sclp_con_outqueue, struct sclp_buffer,
				  list);
	sclp_con_queue_running = 1;
	spin_unlock_irqrestore(&sclp_con_lock, flags);

	rc = sclp_emit_buffer(buffer, sclp_conbuf_callback);
	if (rc)
		sclp_conbuf_callback(buffer, rc);
	return;
out_unlock:
	spin_unlock_irqrestore(&sclp_con_lock, flags);
}

/*
 * Wait until out queue is empty
 */
static void sclp_console_sync_queue(void)
{
	unsigned long flags;

	spin_lock_irqsave(&sclp_con_lock, flags);
	if (timer_pending(&sclp_con_timer))
		del_timer(&sclp_con_timer);
	while (sclp_con_queue_running) {
		spin_unlock_irqrestore(&sclp_con_lock, flags);
		sclp_sync_wait();
		spin_lock_irqsave(&sclp_con_lock, flags);
	}
	spin_unlock_irqrestore(&sclp_con_lock, flags);
}

/*
 * When this routine is called from the timer then we flush the
 * temporary write buffer without further waiting on a final new line.
 */
static void
sclp_console_timeout(struct timer_list *unused)
{
	sclp_conbuf_emit();
}

/*
 * Drop oldest console buffer if sclp_con_drop is set
 */
static int
sclp_console_drop_buffer(void)
{
	struct list_head *list;
	struct sclp_buffer *buffer;
	void *page;

	if (!sclp_console_drop)
		return 0;
	list = sclp_con_outqueue.next;
	if (sclp_con_queue_running)
		/* The first element is in I/O */
		list = list->next;
	if (list == &sclp_con_outqueue)
		return 0;
	list_del(list);
	buffer = list_entry(list, struct sclp_buffer, list);
	page = sclp_unmake_buffer(buffer);
	list_add_tail((struct list_head *) page, &sclp_con_pages);
	return 1;
}

/*
 * Writes the given message to S390 system console
 */
static void
sclp_console_write(struct console *console, const char *message,
		   unsigned int count)
{
	unsigned long flags;
	void *page;
	int written;

	if (count == 0)
		return;
	spin_lock_irqsave(&sclp_con_lock, flags);
	/*
	 * process escape characters, write message into buffer,
	 * send buffer to SCLP
	 */
	do {
		/* make sure we have a console output buffer */
		if (sclp_conbuf == NULL) {
			if (list_empty(&sclp_con_pages))
				sclp_console_full++;
			while (list_empty(&sclp_con_pages)) {
				if (sclp_con_suspended)
					goto out;
				if (sclp_console_drop_buffer())
					break;
				spin_unlock_irqrestore(&sclp_con_lock, flags);
				sclp_sync_wait();
				spin_lock_irqsave(&sclp_con_lock, flags);
			}
			page = sclp_con_pages.next;
			list_del((struct list_head *) page);
			sclp_conbuf = sclp_make_buffer(page, sclp_con_columns,
						       sclp_con_width_htab);
		}
		/* try to write the string to the current output buffer */
		written = sclp_write(sclp_conbuf, (const unsigned char *)
				     message, count);
		if (written == count)
			break;
		/*
		 * Not all characters could be written to the current
		 * output buffer. Emit the buffer, create a new buffer
		 * and then output the rest of the string.
		 */
		spin_unlock_irqrestore(&sclp_con_lock, flags);
		sclp_conbuf_emit();
		spin_lock_irqsave(&sclp_con_lock, flags);
		message += written;
		count -= written;
	} while (count > 0);
	/* Setup timer to output current console buffer after 1/10 second */
	if (sclp_conbuf != NULL && sclp_chars_in_buffer(sclp_conbuf) != 0 &&
	    !timer_pending(&sclp_con_timer)) {
		mod_timer(&sclp_con_timer, jiffies + HZ / 10);
	}
out:
	spin_unlock_irqrestore(&sclp_con_lock, flags);
}

static struct tty_driver *
sclp_console_device(struct console *c, int *index)
{
	*index = c->index;
	return sclp_tty_driver;
}

/*
 * Make sure that all buffers will be flushed to the SCLP.
 */
static void
sclp_console_flush(void)
{
	sclp_conbuf_emit();
	sclp_console_sync_queue();
}

/*
 * Resume console: If there are cached messages, emit them.
 */
static void sclp_console_resume(void)
{
	unsigned long flags;

	spin_lock_irqsave(&sclp_con_lock, flags);
	sclp_con_suspended = 0;
	spin_unlock_irqrestore(&sclp_con_lock, flags);
	sclp_conbuf_emit();
}

/*
 * Suspend console: Set suspend flag and flush console
 */
static void sclp_console_suspend(void)
{
	unsigned long flags;

	spin_lock_irqsave(&sclp_con_lock, flags);
	sclp_con_suspended = 1;
	spin_unlock_irqrestore(&sclp_con_lock, flags);
	sclp_console_flush();
}

static int sclp_console_notify(struct notifier_block *self,
			       unsigned long event, void *data)
{
	sclp_console_flush();
	return NOTIFY_OK;
}

static struct notifier_block on_panic_nb = {
	.notifier_call = sclp_console_notify,
	.priority = SCLP_PANIC_PRIO_CLIENT,
};

static struct notifier_block on_reboot_nb = {
	.notifier_call = sclp_console_notify,
	.priority = 1,
};

/*
 * used to register the SCLP console to the kernel and to
 * give printk necessary information
 */
static struct console sclp_console =
{
	.name = sclp_console_name,
	.write = sclp_console_write,
	.device = sclp_console_device,
	.flags = CON_PRINTBUFFER,
	.index = 0 /* ttyS0 */
};

/*
 * This function is called for SCLP suspend and resume events.
 */
void sclp_console_pm_event(enum sclp_pm_event sclp_pm_event)
{
	switch (sclp_pm_event) {
	case SCLP_PM_EVENT_FREEZE:
		sclp_console_suspend();
		break;
	case SCLP_PM_EVENT_RESTORE:
	case SCLP_PM_EVENT_THAW:
		sclp_console_resume();
		break;
	}
}

/*
 * called by console_init() in drivers/char/tty_io.c at boot-time.
 */
static int __init
sclp_console_init(void)
{
	void *page;
	int i;
	int rc;

	/* SCLP consoles are handled together */
	if (!(CONSOLE_IS_SCLP || CONSOLE_IS_VT220))
		return 0;
	rc = sclp_rw_init();
	if (rc)
		return rc;
	/* Allocate pages for output buffering */
	INIT_LIST_HEAD(&sclp_con_pages);
	for (i = 0; i < sclp_console_pages; i++) {
		page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
		list_add_tail(page, &sclp_con_pages);
	}
	INIT_LIST_HEAD(&sclp_con_outqueue);
	spin_lock_init(&sclp_con_lock);
	sclp_conbuf = NULL;
	timer_setup(&sclp_con_timer, sclp_console_timeout, 0);

	/* Set output format */
	if (MACHINE_IS_VM)
		/*
		 * save 4 characters for the CPU number
		 * written at start of each line by VM/CP
		 */
		sclp_con_columns = 76;
	else
		sclp_con_columns = 80;
	sclp_con_width_htab = 8;

	/* enable printk-access to this driver */
	atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
	register_reboot_notifier(&on_reboot_nb);
	register_console(&sclp_console);
	return 0;
}

console_initcall(sclp_console_init);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/*
62b74942	3	* SCLP line mode console driver
1da177e4	4	*
62b74942 MH	5	* Copyright IBM Corp. 1999, 2009
	6	* Author(s): Martin Peschke <mpeschke@de.ibm.com>
	7	* Martin Schwidefsky <schwidefsky@de.ibm.com>
1da177e4 LT	8	*/
1da177e4 LT	9
1da177e4 LT	10	#include <linux/kmod.h>
	11	#include <linux/console.h>
	12	#include <linux/init.h>
	13	#include <linux/timer.h>
	14	#include <linux/jiffies.h>
095761d2	15	#include <linux/termios.h>
1da177e4	16	#include <linux/err.h>
2332ce1a	17	#include <linux/reboot.h>
5a0e3ad6	18	#include <linux/gfp.h>
1da177e4 LT	19
	20	#include "sclp.h"
	21	#include "sclp_rw.h"
	22	#include "sclp_tty.h"
	23
1da177e4 LT	24	#define sclp_console_major 4 /* TTYAUX_MAJOR */
	25	#define sclp_console_minor 64
	26	#define sclp_console_name "ttyS"
	27
	28	/* Lock to guard over changes to global variables */
	29	static spinlock_t sclp_con_lock;
	30	/* List of free pages that can be used for console output buffering */
	31	static struct list_head sclp_con_pages;
	32	/* List of full struct sclp_buffer structures ready for output */
	33	static struct list_head sclp_con_outqueue;
1da177e4 LT	34	/* Pointer to current console buffer */
	35	static struct sclp_buffer *sclp_conbuf;
	36	/* Timer for delayed output of console messages */
	37	static struct timer_list sclp_con_timer;
62b74942 MH	38	/* Suspend mode flag */
	39	static int sclp_con_suspended;
	40	/* Flag that output queue is currently running */
	41	static int sclp_con_queue_running;
1da177e4 LT	42
	43	/* Output format for console messages */
	44	static unsigned short sclp_con_columns;
	45	static unsigned short sclp_con_width_htab;
	46
	47	static void
	48	sclp_conbuf_callback(struct sclp_buffer *buffer, int rc)
	49	{
	50	unsigned long flags;
	51	void *page;
	52
	53	do {
	54	page = sclp_unmake_buffer(buffer);
	55	spin_lock_irqsave(&sclp_con_lock, flags);
62b74942	56
1da177e4 LT	57	/* Remove buffer from outqueue */
1da177e4 LT	58	list_del(&buffer->list);
1da177e4	59	list_add_tail((struct list_head *) page, &sclp_con_pages);
62b74942	60
1da177e4 LT	61	/* Check if there is a pending buffer on the out queue. */
	62	buffer = NULL;
	63	if (!list_empty(&sclp_con_outqueue))
62b74942 MH	64	buffer = list_first_entry(&sclp_con_outqueue,
	65	struct sclp_buffer, list);
	66	if (!buffer \|\| sclp_con_suspended) {
	67	sclp_con_queue_running = 0;
	68	spin_unlock_irqrestore(&sclp_con_lock, flags);
	69	break;
	70	}
1da177e4	71	spin_unlock_irqrestore(&sclp_con_lock, flags);
62b74942	72	} while (sclp_emit_buffer(buffer, sclp_conbuf_callback));
1da177e4 LT	73	}
1da177e4 LT	74
62b74942 MH	75	/*
	76	* Finalize and emit first pending buffer.
	77	*/
	78	static void sclp_conbuf_emit(void)
1da177e4 LT	79	{
	80	struct sclp_buffer* buffer;
	81	unsigned long flags;
1da177e4 LT	82	int rc;
	83
	84	spin_lock_irqsave(&sclp_con_lock, flags);
62b74942 MH	85	if (sclp_conbuf)
62b74942 MH	86	list_add_tail(&sclp_conbuf->list, &sclp_con_outqueue);
1da177e4	87	sclp_conbuf = NULL;
62b74942 MH	88	if (sclp_con_queue_running \|\| sclp_con_suspended)
	89	goto out_unlock;
	90	if (list_empty(&sclp_con_outqueue))
	91	goto out_unlock;
	92	buffer = list_first_entry(&sclp_con_outqueue, struct sclp_buffer,
	93	list);
	94	sclp_con_queue_running = 1;
1da177e4	95	spin_unlock_irqrestore(&sclp_con_lock, flags);
62b74942	96
1da177e4 LT	97	rc = sclp_emit_buffer(buffer, sclp_conbuf_callback);
	98	if (rc)
	99	sclp_conbuf_callback(buffer, rc);
62b74942 MH	100	return;
	101	out_unlock:
	102	spin_unlock_irqrestore(&sclp_con_lock, flags);
	103	}
	104
	105	/*
	106	* Wait until out queue is empty
	107	*/
	108	static void sclp_console_sync_queue(void)
	109	{
	110	unsigned long flags;
	111
	112	spin_lock_irqsave(&sclp_con_lock, flags);
	113	if (timer_pending(&sclp_con_timer))
f3dfa86c	114	del_timer(&sclp_con_timer);
62b74942 MH	115	while (sclp_con_queue_running) {
	116	spin_unlock_irqrestore(&sclp_con_lock, flags);
	117	sclp_sync_wait();
	118	spin_lock_irqsave(&sclp_con_lock, flags);
	119	}
	120	spin_unlock_irqrestore(&sclp_con_lock, flags);
1da177e4 LT	121	}
	122
	123	/*
	124	* When this routine is called from the timer then we flush the
	125	* temporary write buffer without further waiting on a final new line.
	126	*/
	127	static void
c9602ee7	128	sclp_console_timeout(struct timer_list *unused)
1da177e4 LT	129	{
	130	sclp_conbuf_emit();
	131	}
	132
25b41a7b MS	133	/*
	134	* Drop oldest console buffer if sclp_con_drop is set
	135	*/
	136	static int
	137	sclp_console_drop_buffer(void)
	138	{
	139	struct list_head *list;
	140	struct sclp_buffer *buffer;
	141	void *page;
	142
	143	if (!sclp_console_drop)
	144	return 0;
	145	list = sclp_con_outqueue.next;
	146	if (sclp_con_queue_running)
	147	/* The first element is in I/O */
	148	list = list->next;
	149	if (list == &sclp_con_outqueue)
	150	return 0;
	151	list_del(list);
	152	buffer = list_entry(list, struct sclp_buffer, list);
	153	page = sclp_unmake_buffer(buffer);
	154	list_add_tail((struct list_head *) page, &sclp_con_pages);
	155	return 1;
	156	}
	157
1da177e4 LT	158	/*
	159	* Writes the given message to S390 system console
	160	*/
	161	static void
	162	sclp_console_write(struct console console, const char message,
	163	unsigned int count)
	164	{
	165	unsigned long flags;
	166	void *page;
	167	int written;
	168
	169	if (count == 0)
	170	return;
	171	spin_lock_irqsave(&sclp_con_lock, flags);
	172	/*
	173	* process escape characters, write message into buffer,
	174	* send buffer to SCLP
	175	*/
	176	do {
	177	/* make sure we have a console output buffer */
	178	if (sclp_conbuf == NULL) {
25b41a7b MS	179	if (list_empty(&sclp_con_pages))
25b41a7b MS	180	sclp_console_full++;
1da177e4	181	while (list_empty(&sclp_con_pages)) {
62b74942 MH	182	if (sclp_con_suspended)
62b74942 MH	183	goto out;
25b41a7b MS	184	if (sclp_console_drop_buffer())
25b41a7b MS	185	break;
1da177e4 LT	186	spin_unlock_irqrestore(&sclp_con_lock, flags);
	187	sclp_sync_wait();
	188	spin_lock_irqsave(&sclp_con_lock, flags);
	189	}
	190	page = sclp_con_pages.next;
	191	list_del((struct list_head *) page);
	192	sclp_conbuf = sclp_make_buffer(page, sclp_con_columns,
	193	sclp_con_width_htab);
	194	}
	195	/* try to write the string to the current output buffer */
	196	written = sclp_write(sclp_conbuf, (const unsigned char *)
	197	message, count);
	198	if (written == count)
	199	break;
	200	/*
	201	* Not all characters could be written to the current
	202	* output buffer. Emit the buffer, create a new buffer
	203	* and then output the rest of the string.
	204	*/
	205	spin_unlock_irqrestore(&sclp_con_lock, flags);
	206	sclp_conbuf_emit();
	207	spin_lock_irqsave(&sclp_con_lock, flags);
	208	message += written;
	209	count -= written;
	210	} while (count > 0);
	211	/* Setup timer to output current console buffer after 1/10 second */
	212	if (sclp_conbuf != NULL && sclp_chars_in_buffer(sclp_conbuf) != 0 &&
	213	!timer_pending(&sclp_con_timer)) {
8179c7ba	214	mod_timer(&sclp_con_timer, jiffies + HZ / 10);
1da177e4	215	}
62b74942	216	out:
1da177e4 LT	217	spin_unlock_irqrestore(&sclp_con_lock, flags);
	218	}
	219
	220	static struct tty_driver *
	221	sclp_console_device(struct console c, int index)
	222	{
	223	*index = c->index;
	224	return sclp_tty_driver;
	225	}
	226
	227	/*
62b74942	228	* Make sure that all buffers will be flushed to the SCLP.
1da177e4 LT	229	*/
1da177e4 LT	230	static void
2332ce1a	231	sclp_console_flush(void)
62b74942 MH	232	{
	233	sclp_conbuf_emit();
	234	sclp_console_sync_queue();
	235	}
	236
	237	/*
	238	* Resume console: If there are cached messages, emit them.
	239	*/
	240	static void sclp_console_resume(void)
1da177e4 LT	241	{
	242	unsigned long flags;
	243
62b74942 MH	244	spin_lock_irqsave(&sclp_con_lock, flags);
	245	sclp_con_suspended = 0;
	246	spin_unlock_irqrestore(&sclp_con_lock, flags);
1da177e4	247	sclp_conbuf_emit();
62b74942 MH	248	}
	249
	250	/*
	251	* Suspend console: Set suspend flag and flush console
	252	*/
	253	static void sclp_console_suspend(void)
	254	{
	255	unsigned long flags;
	256
1da177e4	257	spin_lock_irqsave(&sclp_con_lock, flags);
62b74942	258	sclp_con_suspended = 1;
1da177e4	259	spin_unlock_irqrestore(&sclp_con_lock, flags);
62b74942	260	sclp_console_flush();
1da177e4 LT	261	}
1da177e4 LT	262
62b74942 MH	263	static int sclp_console_notify(struct notifier_block *self,
62b74942 MH	264	unsigned long event, void *data)
2332ce1a HS	265	{
	266	sclp_console_flush();
	267	return NOTIFY_OK;
	268	}
	269
	270	static struct notifier_block on_panic_nb = {
	271	.notifier_call = sclp_console_notify,
62b74942	272	.priority = SCLP_PANIC_PRIO_CLIENT,
2332ce1a HS	273	};
	274
	275	static struct notifier_block on_reboot_nb = {
	276	.notifier_call = sclp_console_notify,
	277	.priority = 1,
	278	};
	279
1da177e4 LT	280	/*
	281	* used to register the SCLP console to the kernel and to
	282	* give printk necessary information
	283	*/
	284	static struct console sclp_console =
	285	{
	286	.name = sclp_console_name,
	287	.write = sclp_console_write,
	288	.device = sclp_console_device,
1da177e4 LT	289	.flags = CON_PRINTBUFFER,
	290	.index = 0 /* ttyS0 */
	291	};
	292
62b74942 MH	293	/*
	294	* This function is called for SCLP suspend and resume events.
	295	*/
	296	void sclp_console_pm_event(enum sclp_pm_event sclp_pm_event)
	297	{
	298	switch (sclp_pm_event) {
	299	case SCLP_PM_EVENT_FREEZE:
	300	sclp_console_suspend();
	301	break;
	302	case SCLP_PM_EVENT_RESTORE:
	303	case SCLP_PM_EVENT_THAW:
	304	sclp_console_resume();
	305	break;
	306	}
	307	}
	308
1da177e4 LT	309	/*
	310	* called by console_init() in drivers/char/tty_io.c at boot-time.
	311	*/
	312	static int __init
	313	sclp_console_init(void)
	314	{
	315	void *page;
	316	int i;
	317	int rc;
	318
8f50af49 PO	319	/* SCLP consoles are handled together */
8f50af49 PO	320	if (!(CONSOLE_IS_SCLP \|\| CONSOLE_IS_VT220))
1da177e4 LT	321	return 0;
	322	rc = sclp_rw_init();
	323	if (rc)
	324	return rc;
	325	/* Allocate pages for output buffering */
	326	INIT_LIST_HEAD(&sclp_con_pages);
25b41a7b	327	for (i = 0; i < sclp_console_pages; i++) {
4c8f4794 HC	328	page = (void *) get_zeroed_page(GFP_KERNEL \| GFP_DMA);
4c8f4794 HC	329	list_add_tail(page, &sclp_con_pages);
1da177e4 LT	330	}
	331	INIT_LIST_HEAD(&sclp_con_outqueue);
	332	spin_lock_init(&sclp_con_lock);
1da177e4	333	sclp_conbuf = NULL;
c9602ee7	334	timer_setup(&sclp_con_timer, sclp_console_timeout, 0);
1da177e4 LT	335
	336	/* Set output format */
	337	if (MACHINE_IS_VM)
	338	/*
	339	* save 4 characters for the CPU number
	340	* written at start of each line by VM/CP
	341	*/
	342	sclp_con_columns = 76;
	343	else
	344	sclp_con_columns = 80;
	345	sclp_con_width_htab = 8;
	346
	347	/* enable printk-access to this driver */
2332ce1a HS	348	atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
2332ce1a HS	349	register_reboot_notifier(&on_reboot_nb);
1da177e4 LT	350	register_console(&sclp_console);
	351	return 0;
	352	}
	353
	354	console_initcall(sclp_console_init);