drivers/s390/char/sclp_con.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * SCLP line mode console driver
   4  *
   5  * Copyright IBM Corp. 1999, 2009
   6  * 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 64
  27 #define sclp_console_name  "ttyS"
  28
  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;
  41
  42 /* Output format for console messages */
  43 #define SCLP_CON_COLUMNS        320
  44 #define SPACES_PER_TAB          8
  45
  46 static void
  47 sclp_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  */
  77 static 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;
 100 out_unlock:
 101         spin_unlock_irqrestore(&sclp_con_lock, flags);
 102 }
 103
 104 /*
 105  * Wait until out queue is empty
 106  */
 107 static 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 the
 123  * temporary write buffer without further waiting on a final new line.
 124  */
 125 static void
 126 sclp_console_timeout(struct timer_list *unused)
 127 {
 128         sclp_conbuf_emit();
 129 }
 130
 131 /*
 132  * Drop oldest console buffer if sclp_con_drop is set
 133  */
 134 static int
 135 sclp_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 console
 158  */
 159 static void
 160 sclp_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 SCLP
 173          */
 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 current
 198                  * output buffer. Emit the buffer, create a new buffer
 199                  * 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
 215 static struct tty_driver *
 216 sclp_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 buffers
 224  * will be flushed to the SCLP.
 225  */
 226 static int sclp_console_notify(struct notifier_block *self,
 227                                unsigned long event, void *data)
 228 {
 229         /*
 230          * Perform the lock check before effectively getting the
 231          * 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
 243 static struct notifier_block on_panic_nb = {
 244         .notifier_call = sclp_console_notify,
 245         .priority = INT_MIN + 1, /* run the callback late */
 246 };
 247
 248 static 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 to
 255  * give printk necessary information
 256  */
 257 static 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  */
 269 static int __init
 270 sclp_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
 297 console_initcall(sclp_console_init);