298 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * SCLP line mode console driver4 *5 * Copyright IBM Corp. 1999, 20096 * Author(s): Martin Peschke <mpeschke@de.ibm.com>7 * Martin Schwidefsky <schwidefsky@de.ibm.com>8 */9 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>20 21#include "sclp.h"22#include "sclp_rw.h"23#include "sclp_tty.h"24 25#define sclp_console_major 4 /* TTYAUX_MAJOR */26#define sclp_console_minor 6427#define sclp_console_name "ttyS"28 29/* Lock to guard over changes to global variables */30static DEFINE_SPINLOCK(sclp_con_lock);31/* List of free pages that can be used for console output buffering */32static LIST_HEAD(sclp_con_pages);33/* List of full struct sclp_buffer structures ready for output */34static LIST_HEAD(sclp_con_outqueue);35/* Pointer to current console buffer */36static struct sclp_buffer *sclp_conbuf;37/* Timer for delayed output of console messages */38static struct timer_list sclp_con_timer;39/* Flag that output queue is currently running */40static int sclp_con_queue_running;41 42/* Output format for console messages */43#define SCLP_CON_COLUMNS 32044#define SPACES_PER_TAB 845 46static void47sclp_conbuf_callback(struct sclp_buffer *buffer, int rc)48{49 unsigned long flags;50 void *page;51 52 do {53 page = sclp_unmake_buffer(buffer);54 spin_lock_irqsave(&sclp_con_lock, flags);55 56 /* Remove buffer from outqueue */57 list_del(&buffer->list);58 list_add_tail((struct list_head *) page, &sclp_con_pages);59 60 /* Check if there is a pending buffer on the out queue. */61 buffer = NULL;62 if (!list_empty(&sclp_con_outqueue))63 buffer = list_first_entry(&sclp_con_outqueue,64 struct sclp_buffer, list);65 if (!buffer) {66 sclp_con_queue_running = 0;67 spin_unlock_irqrestore(&sclp_con_lock, flags);68 break;69 }70 spin_unlock_irqrestore(&sclp_con_lock, flags);71 } while (sclp_emit_buffer(buffer, sclp_conbuf_callback));72}73 74/*75 * Finalize and emit first pending buffer.76 */77static void sclp_conbuf_emit(void)78{79 struct sclp_buffer* buffer;80 unsigned long flags;81 int rc;82 83 spin_lock_irqsave(&sclp_con_lock, flags);84 if (sclp_conbuf)85 list_add_tail(&sclp_conbuf->list, &sclp_con_outqueue);86 sclp_conbuf = NULL;87 if (sclp_con_queue_running)88 goto out_unlock;89 if (list_empty(&sclp_con_outqueue))90 goto out_unlock;91 buffer = list_first_entry(&sclp_con_outqueue, struct sclp_buffer,92 list);93 sclp_con_queue_running = 1;94 spin_unlock_irqrestore(&sclp_con_lock, flags);95 96 rc = sclp_emit_buffer(buffer, sclp_conbuf_callback);97 if (rc)98 sclp_conbuf_callback(buffer, rc);99 return;100out_unlock:101 spin_unlock_irqrestore(&sclp_con_lock, flags);102}103 104/*105 * Wait until out queue is empty106 */107static void sclp_console_sync_queue(void)108{109 unsigned long flags;110 111 spin_lock_irqsave(&sclp_con_lock, flags);112 del_timer(&sclp_con_timer);113 while (sclp_con_queue_running) {114 spin_unlock_irqrestore(&sclp_con_lock, flags);115 sclp_sync_wait();116 spin_lock_irqsave(&sclp_con_lock, flags);117 }118 spin_unlock_irqrestore(&sclp_con_lock, flags);119}120 121/*122 * When this routine is called from the timer then we flush the123 * temporary write buffer without further waiting on a final new line.124 */125static void126sclp_console_timeout(struct timer_list *unused)127{128 sclp_conbuf_emit();129}130 131/*132 * Drop oldest console buffer if sclp_con_drop is set133 */134static int135sclp_console_drop_buffer(void)136{137 struct list_head *list;138 struct sclp_buffer *buffer;139 void *page;140 141 if (!sclp_console_drop)142 return 0;143 list = sclp_con_outqueue.next;144 if (sclp_con_queue_running)145 /* The first element is in I/O */146 list = list->next;147 if (list == &sclp_con_outqueue)148 return 0;149 list_del(list);150 buffer = list_entry(list, struct sclp_buffer, list);151 page = sclp_unmake_buffer(buffer);152 list_add_tail((struct list_head *) page, &sclp_con_pages);153 return 1;154}155 156/*157 * Writes the given message to S390 system console158 */159static void160sclp_console_write(struct console *console, const char *message,161 unsigned int count)162{163 unsigned long flags;164 void *page;165 int written;166 167 if (count == 0)168 return;169 spin_lock_irqsave(&sclp_con_lock, flags);170 /*171 * process escape characters, write message into buffer,172 * send buffer to SCLP173 */174 do {175 /* make sure we have a console output buffer */176 if (sclp_conbuf == NULL) {177 if (list_empty(&sclp_con_pages))178 sclp_console_full++;179 while (list_empty(&sclp_con_pages)) {180 if (sclp_console_drop_buffer())181 break;182 spin_unlock_irqrestore(&sclp_con_lock, flags);183 sclp_sync_wait();184 spin_lock_irqsave(&sclp_con_lock, flags);185 }186 page = sclp_con_pages.next;187 list_del((struct list_head *) page);188 sclp_conbuf = sclp_make_buffer(page, SCLP_CON_COLUMNS,189 SPACES_PER_TAB);190 }191 /* try to write the string to the current output buffer */192 written = sclp_write(sclp_conbuf, (const unsigned char *)193 message, count);194 if (written == count)195 break;196 /*197 * Not all characters could be written to the current198 * output buffer. Emit the buffer, create a new buffer199 * and then output the rest of the string.200 */201 spin_unlock_irqrestore(&sclp_con_lock, flags);202 sclp_conbuf_emit();203 spin_lock_irqsave(&sclp_con_lock, flags);204 message += written;205 count -= written;206 } while (count > 0);207 /* Setup timer to output current console buffer after 1/10 second */208 if (sclp_conbuf != NULL && sclp_chars_in_buffer(sclp_conbuf) != 0 &&209 !timer_pending(&sclp_con_timer)) {210 mod_timer(&sclp_con_timer, jiffies + HZ / 10);211 }212 spin_unlock_irqrestore(&sclp_con_lock, flags);213}214 215static struct tty_driver *216sclp_console_device(struct console *c, int *index)217{218 *index = c->index;219 return sclp_tty_driver;220}221 222/*223 * This panic/reboot notifier makes sure that all buffers224 * will be flushed to the SCLP.225 */226static int sclp_console_notify(struct notifier_block *self,227 unsigned long event, void *data)228{229 /*230 * Perform the lock check before effectively getting the231 * lock on sclp_conbuf_emit() / sclp_console_sync_queue()232 * to prevent potential lockups in atomic context.233 */234 if (spin_is_locked(&sclp_con_lock))235 return NOTIFY_DONE;236 237 sclp_conbuf_emit();238 sclp_console_sync_queue();239 240 return NOTIFY_DONE;241}242 243static struct notifier_block on_panic_nb = {244 .notifier_call = sclp_console_notify,245 .priority = INT_MIN + 1, /* run the callback late */246};247 248static struct notifier_block on_reboot_nb = {249 .notifier_call = sclp_console_notify,250 .priority = INT_MIN + 1, /* run the callback late */251};252 253/*254 * used to register the SCLP console to the kernel and to255 * give printk necessary information256 */257static struct console sclp_console =258{259 .name = sclp_console_name,260 .write = sclp_console_write,261 .device = sclp_console_device,262 .flags = CON_PRINTBUFFER,263 .index = 0 /* ttyS0 */264};265 266/*267 * called by console_init() in drivers/char/tty_io.c at boot-time.268 */269static int __init270sclp_console_init(void)271{272 void *page;273 int i;274 int rc;275 276 /* SCLP consoles are handled together */277 if (!(CONSOLE_IS_SCLP || CONSOLE_IS_VT220))278 return 0;279 rc = sclp_rw_init();280 if (rc)281 return rc;282 /* Allocate pages for output buffering */283 for (i = 0; i < sclp_console_pages; i++) {284 page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);285 list_add_tail(page, &sclp_con_pages);286 }287 sclp_conbuf = NULL;288 timer_setup(&sclp_con_timer, sclp_console_timeout, 0);289 290 /* enable printk-access to this driver */291 atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);292 register_reboot_notifier(&on_reboot_nb);293 register_console(&sclp_console);294 return 0;295}296 297console_initcall(sclp_console_init);298