1 // SPDX-License-Identifier: GPL-2.0
3 * SCLP line mode console driver
5 * Copyright IBM Corp. 1999, 2009
6 * Author(s): Martin Peschke <mpeschke@de.ibm.com>
7 * Martin Schwidefsky <schwidefsky@de.ibm.com>
10 #include <linux/kmod.h>
11 #include <linux/console.h>
12 #include <linux/init.h>
13 #include <linux/panic_notifier.h>
14 #include <linux/timer.h>
15 #include <linux/jiffies.h>
16 #include <linux/termios.h>
17 #include <linux/err.h>
18 #include <linux/reboot.h>
19 #include <linux/gfp.h>
25 #define sclp_console_major 4 /* TTYAUX_MAJOR */
26 #define sclp_console_minor 64
27 #define sclp_console_name "ttyS"
29 /* Lock to guard over changes to global variables */
30 static DEFINE_SPINLOCK(sclp_con_lock);
31 /* List of free pages that can be used for console output buffering */
32 static LIST_HEAD(sclp_con_pages);
33 /* List of full struct sclp_buffer structures ready for output */
34 static LIST_HEAD(sclp_con_outqueue);
35 /* Pointer to current console buffer */
36 static struct sclp_buffer *sclp_conbuf;
37 /* Timer for delayed output of console messages */
38 static struct timer_list sclp_con_timer;
39 /* Flag that output queue is currently running */
40 static int sclp_con_queue_running;
42 /* Output format for console messages */
43 #define SCLP_CON_COLUMNS 320
44 #define SPACES_PER_TAB 8
47 sclp_conbuf_callback(struct sclp_buffer *buffer, int rc)
53 page = sclp_unmake_buffer(buffer);
54 spin_lock_irqsave(&sclp_con_lock, flags);
56 /* Remove buffer from outqueue */
57 list_del(&buffer->list);
58 list_add_tail((struct list_head *) page, &sclp_con_pages);
60 /* Check if there is a pending buffer on the out queue. */
62 if (!list_empty(&sclp_con_outqueue))
63 buffer = list_first_entry(&sclp_con_outqueue,
64 struct sclp_buffer, list);
66 sclp_con_queue_running = 0;
67 spin_unlock_irqrestore(&sclp_con_lock, flags);
70 spin_unlock_irqrestore(&sclp_con_lock, flags);
71 } while (sclp_emit_buffer(buffer, sclp_conbuf_callback));
75 * Finalize and emit first pending buffer.
77 static void sclp_conbuf_emit(void)
79 struct sclp_buffer* buffer;
83 spin_lock_irqsave(&sclp_con_lock, flags);
85 list_add_tail(&sclp_conbuf->list, &sclp_con_outqueue);
87 if (sclp_con_queue_running)
89 if (list_empty(&sclp_con_outqueue))
91 buffer = list_first_entry(&sclp_con_outqueue, struct sclp_buffer,
93 sclp_con_queue_running = 1;
94 spin_unlock_irqrestore(&sclp_con_lock, flags);
96 rc = sclp_emit_buffer(buffer, sclp_conbuf_callback);
98 sclp_conbuf_callback(buffer, rc);
101 spin_unlock_irqrestore(&sclp_con_lock, flags);
105 * Wait until out queue is empty
107 static void sclp_console_sync_queue(void)
111 spin_lock_irqsave(&sclp_con_lock, flags);
112 if (timer_pending(&sclp_con_timer))
113 del_timer(&sclp_con_timer);
114 while (sclp_con_queue_running) {
115 spin_unlock_irqrestore(&sclp_con_lock, flags);
117 spin_lock_irqsave(&sclp_con_lock, flags);
119 spin_unlock_irqrestore(&sclp_con_lock, flags);
123 * When this routine is called from the timer then we flush the
124 * temporary write buffer without further waiting on a final new line.
127 sclp_console_timeout(struct timer_list *unused)
133 * Drop oldest console buffer if sclp_con_drop is set
136 sclp_console_drop_buffer(void)
138 struct list_head *list;
139 struct sclp_buffer *buffer;
142 if (!sclp_console_drop)
144 list = sclp_con_outqueue.next;
145 if (sclp_con_queue_running)
146 /* The first element is in I/O */
148 if (list == &sclp_con_outqueue)
151 buffer = list_entry(list, struct sclp_buffer, list);
152 page = sclp_unmake_buffer(buffer);
153 list_add_tail((struct list_head *) page, &sclp_con_pages);
158 * Writes the given message to S390 system console
161 sclp_console_write(struct console *console, const char *message,
170 spin_lock_irqsave(&sclp_con_lock, flags);
172 * process escape characters, write message into buffer,
173 * send buffer to SCLP
176 /* make sure we have a console output buffer */
177 if (sclp_conbuf == NULL) {
178 if (list_empty(&sclp_con_pages))
180 while (list_empty(&sclp_con_pages)) {
181 if (sclp_console_drop_buffer())
183 spin_unlock_irqrestore(&sclp_con_lock, flags);
185 spin_lock_irqsave(&sclp_con_lock, flags);
187 page = sclp_con_pages.next;
188 list_del((struct list_head *) page);
189 sclp_conbuf = sclp_make_buffer(page, SCLP_CON_COLUMNS,
192 /* try to write the string to the current output buffer */
193 written = sclp_write(sclp_conbuf, (const unsigned char *)
195 if (written == count)
198 * Not all characters could be written to the current
199 * output buffer. Emit the buffer, create a new buffer
200 * and then output the rest of the string.
202 spin_unlock_irqrestore(&sclp_con_lock, flags);
204 spin_lock_irqsave(&sclp_con_lock, flags);
208 /* Setup timer to output current console buffer after 1/10 second */
209 if (sclp_conbuf != NULL && sclp_chars_in_buffer(sclp_conbuf) != 0 &&
210 !timer_pending(&sclp_con_timer)) {
211 mod_timer(&sclp_con_timer, jiffies + HZ / 10);
213 spin_unlock_irqrestore(&sclp_con_lock, flags);
216 static struct tty_driver *
217 sclp_console_device(struct console *c, int *index)
220 return sclp_tty_driver;
224 * Make sure that all buffers will be flushed to the SCLP.
227 sclp_console_flush(void)
230 sclp_console_sync_queue();
233 static int sclp_console_notify(struct notifier_block *self,
234 unsigned long event, void *data)
236 sclp_console_flush();
240 static struct notifier_block on_panic_nb = {
241 .notifier_call = sclp_console_notify,
245 static struct notifier_block on_reboot_nb = {
246 .notifier_call = sclp_console_notify,
251 * used to register the SCLP console to the kernel and to
252 * give printk necessary information
254 static struct console sclp_console =
256 .name = sclp_console_name,
257 .write = sclp_console_write,
258 .device = sclp_console_device,
259 .flags = CON_PRINTBUFFER,
260 .index = 0 /* ttyS0 */
264 * called by console_init() in drivers/char/tty_io.c at boot-time.
267 sclp_console_init(void)
273 /* SCLP consoles are handled together */
274 if (!(CONSOLE_IS_SCLP || CONSOLE_IS_VT220))
279 /* Allocate pages for output buffering */
280 for (i = 0; i < sclp_console_pages; i++) {
281 page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
282 list_add_tail(page, &sclp_con_pages);
285 timer_setup(&sclp_con_timer, sclp_console_timeout, 0);
287 /* enable printk-access to this driver */
288 atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
289 register_reboot_notifier(&on_reboot_nb);
290 register_console(&sclp_console);
294 console_initcall(sclp_console_init);