root/drivers/s390/char/sclp_con.c

DEFINITIONS

1. sclp_conbuf_callback
2. sclp_conbuf_emit
3. sclp_console_sync_queue
4. sclp_console_timeout
5. sclp_console_drop_buffer
6. sclp_console_write
7. sclp_console_device
8. sclp_console_flush
9. sclp_console_resume
10. sclp_console_suspend
11. sclp_console_notify
12. sclp_console_pm_event
13. sclp_console_init

   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/timer.h>
  14 #include <linux/jiffies.h>
  15 #include <linux/termios.h>
  16 #include <linux/err.h>
  17 #include <linux/reboot.h>
  18 #include <linux/gfp.h>
  19 
  20 #include "sclp.h"
  21 #include "sclp_rw.h"
  22 #include "sclp_tty.h"
  23 
  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;
  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;
  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;
  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);
  56 
  57                 /* Remove buffer from outqueue */
  58                 list_del(&buffer->list);
  59                 list_add_tail((struct list_head *) page, &sclp_con_pages);
  60 
  61                 /* Check if there is a pending buffer on the out queue. */
  62                 buffer = NULL;
  63                 if (!list_empty(&sclp_con_outqueue))
  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                 }
  71                 spin_unlock_irqrestore(&sclp_con_lock, flags);
  72         } while (sclp_emit_buffer(buffer, sclp_conbuf_callback));
  73 }
  74 
  75 /*
  76  * Finalize and emit first pending buffer.
  77  */
  78 static void sclp_conbuf_emit(void)
  79 {
  80         struct sclp_buffer* buffer;
  81         unsigned long flags;
  82         int rc;
  83 
  84         spin_lock_irqsave(&sclp_con_lock, flags);
  85         if (sclp_conbuf)
  86                 list_add_tail(&sclp_conbuf->list, &sclp_con_outqueue);
  87         sclp_conbuf = NULL;
  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;
  95         spin_unlock_irqrestore(&sclp_con_lock, flags);
  96 
  97         rc = sclp_emit_buffer(buffer, sclp_conbuf_callback);
  98         if (rc)
  99                 sclp_conbuf_callback(buffer, rc);
 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))
 114                 del_timer(&sclp_con_timer);
 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);
 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
 128 sclp_console_timeout(struct timer_list *unused)
 129 {
 130         sclp_conbuf_emit();
 131 }
 132 
 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 
 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) {
 179                         if (list_empty(&sclp_con_pages))
 180                                 sclp_console_full++;
 181                         while (list_empty(&sclp_con_pages)) {
 182                                 if (sclp_con_suspended)
 183                                         goto out;
 184                                 if (sclp_console_drop_buffer())
 185                                         break;
 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)) {
 214                 mod_timer(&sclp_con_timer, jiffies + HZ / 10);
 215         }
 216 out:
 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 /*
 228  * Make sure that all buffers will be flushed to the SCLP.
 229  */
 230 static void
 231 sclp_console_flush(void)
 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)
 241 {
 242         unsigned long flags;
 243 
 244         spin_lock_irqsave(&sclp_con_lock, flags);
 245         sclp_con_suspended = 0;
 246         spin_unlock_irqrestore(&sclp_con_lock, flags);
 247         sclp_conbuf_emit();
 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 
 257         spin_lock_irqsave(&sclp_con_lock, flags);
 258         sclp_con_suspended = 1;
 259         spin_unlock_irqrestore(&sclp_con_lock, flags);
 260         sclp_console_flush();
 261 }
 262 
 263 static int sclp_console_notify(struct notifier_block *self,
 264                                unsigned long event, void *data)
 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,
 272         .priority = SCLP_PANIC_PRIO_CLIENT,
 273 };
 274 
 275 static struct notifier_block on_reboot_nb = {
 276         .notifier_call = sclp_console_notify,
 277         .priority = 1,
 278 };
 279 
 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,
 289         .flags = CON_PRINTBUFFER,
 290         .index = 0 /* ttyS0 */
 291 };
 292 
 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 
 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 
 319         /* SCLP consoles are handled together */
 320         if (!(CONSOLE_IS_SCLP || CONSOLE_IS_VT220))
 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);
 327         for (i = 0; i < sclp_console_pages; i++) {
 328                 page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 329                 list_add_tail(page, &sclp_con_pages);
 330         }
 331         INIT_LIST_HEAD(&sclp_con_outqueue);
 332         spin_lock_init(&sclp_con_lock);
 333         sclp_conbuf = NULL;
 334         timer_setup(&sclp_con_timer, sclp_console_timeout, 0);
 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 */
 348         atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
 349         register_reboot_notifier(&on_reboot_nb);
 350         register_console(&sclp_console);
 351         return 0;
 352 }
 353 
 354 console_initcall(sclp_console_init);