arch/alpha/kernel/srmcons.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *      linux/arch/alpha/kernel/srmcons.c
   4  *
   5  * Callback based driver for SRM Console console device.
   6  * (TTY driver and console driver)
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/init.h>
  11 #include <linux/console.h>
  12 #include <linux/delay.h>
  13 #include <linux/mm.h>
  14 #include <linux/slab.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/timer.h>
  17 #include <linux/tty.h>
  18 #include <linux/tty_driver.h>
  19 #include <linux/tty_flip.h>
  20
  21 #include <asm/console.h>
  22 #include <linux/uaccess.h>
  23
  24
  25 static DEFINE_SPINLOCK(srmcons_callback_lock);
  26 static int srm_is_registered_console = 0;
  27
  28 /*
  29  * The TTY driver
  30  */
  31 #define MAX_SRM_CONSOLE_DEVICES 1       /* only support 1 console device */
  32
  33 struct srmcons_private {
  34         struct tty_port port;
  35         struct timer_list timer;
  36 } srmcons_singleton;
  37
  38 typedef union _srmcons_result {
  39         struct {
  40                 unsigned long c :61;
  41                 unsigned long status :3;
  42         } bits;
  43         long as_long;
  44 } srmcons_result;
  45
  46 /* called with callback_lock held */
  47 static int
  48 srmcons_do_receive_chars(struct tty_port *port)
  49 {
  50         srmcons_result result;
  51         int count = 0, loops = 0;
  52
  53         do {
  54                 result.as_long = callback_getc(0);
  55                 if (result.bits.status < 2) {
  56                         tty_insert_flip_char(port, (char)result.bits.c, 0);
  57                         count++;
  58                 }
  59         } while((result.bits.status & 1) && (++loops < 10));
  60
  61         if (count)
  62                 tty_flip_buffer_push(port);
  63
  64         return count;
  65 }
  66
  67 static void
  68 srmcons_receive_chars(struct timer_list *t)
  69 {
  70         struct srmcons_private *srmconsp = from_timer(srmconsp, t, timer);
  71         struct tty_port *port = &srmconsp->port;
  72         unsigned long flags;
  73         int incr = 10;
  74
  75         local_irq_save(flags);
  76         if (spin_trylock(&srmcons_callback_lock)) {
  77                 if (!srmcons_do_receive_chars(port))
  78                         incr = 100;
  79                 spin_unlock(&srmcons_callback_lock);
  80         }
  81
  82         spin_lock(&port->lock);
  83         if (port->tty)
  84                 mod_timer(&srmconsp->timer, jiffies + incr);
  85         spin_unlock(&port->lock);
  86
  87         local_irq_restore(flags);
  88 }
  89
  90 /* called with callback_lock held */
  91 static int
  92 srmcons_do_write(struct tty_port *port, const char *buf, int count)
  93 {
  94         static char str_cr[1] = "\r";
  95         long c, remaining = count;
  96         srmcons_result result;
  97         char *cur;
  98         int need_cr;
  99
 100         for (cur = (char *)buf; remaining > 0; ) {
 101                 need_cr = 0;
 102                 /*
 103                  * Break it up into reasonable size chunks to allow a chance
 104                  * for input to get in
 105                  */
 106                 for (c = 0; c < min_t(long, 128L, remaining) && !need_cr; c++)
 107                         if (cur[c] == '\n')
 108                                 need_cr = 1;
 109
 110                 while (c > 0) {
 111                         result.as_long = callback_puts(0, cur, c);
 112                         c -= result.bits.c;
 113                         remaining -= result.bits.c;
 114                         cur += result.bits.c;
 115
 116                         /*
 117                          * Check for pending input iff a tty port was provided
 118                          */
 119                         if (port)
 120                                 srmcons_do_receive_chars(port);
 121                 }
 122
 123                 while (need_cr) {
 124                         result.as_long = callback_puts(0, str_cr, 1);
 125                         if (result.bits.c > 0)
 126                                 need_cr = 0;
 127                 }
 128         }
 129         return count;
 130 }
 131
 132 static ssize_t
 133 srmcons_write(struct tty_struct *tty, const u8 *buf, size_t count)
 134 {
 135         unsigned long flags;
 136
 137         spin_lock_irqsave(&srmcons_callback_lock, flags);
 138         srmcons_do_write(tty->port, (const char *) buf, count);
 139         spin_unlock_irqrestore(&srmcons_callback_lock, flags);
 140
 141         return count;
 142 }
 143
 144 static unsigned int
 145 srmcons_write_room(struct tty_struct *tty)
 146 {
 147         return 512;
 148 }
 149
 150 static int
 151 srmcons_open(struct tty_struct *tty, struct file *filp)
 152 {
 153         struct srmcons_private *srmconsp = &srmcons_singleton;
 154         struct tty_port *port = &srmconsp->port;
 155         unsigned long flags;
 156
 157         spin_lock_irqsave(&port->lock, flags);
 158
 159         if (!port->tty) {
 160                 tty->driver_data = srmconsp;
 161                 tty->port = port;
 162                 port->tty = tty; /* XXX proper refcounting */
 163                 mod_timer(&srmconsp->timer, jiffies + 10);
 164         }
 165
 166         spin_unlock_irqrestore(&port->lock, flags);
 167
 168         return 0;
 169 }
 170
 171 static void
 172 srmcons_close(struct tty_struct *tty, struct file *filp)
 173 {
 174         struct srmcons_private *srmconsp = tty->driver_data;
 175         struct tty_port *port = &srmconsp->port;
 176         unsigned long flags;
 177
 178         spin_lock_irqsave(&port->lock, flags);
 179
 180         if (tty->count == 1) {
 181                 port->tty = NULL;
 182                 del_timer(&srmconsp->timer);
 183         }
 184
 185         spin_unlock_irqrestore(&port->lock, flags);
 186 }
 187
 188
 189 static struct tty_driver *srmcons_driver;
 190
 191 static const struct tty_operations srmcons_ops = {
 192         .open           = srmcons_open,
 193         .close          = srmcons_close,
 194         .write          = srmcons_write,
 195         .write_room     = srmcons_write_room,
 196 };
 197
 198 static int __init
 199 srmcons_init(void)
 200 {
 201         timer_setup(&srmcons_singleton.timer, srmcons_receive_chars, 0);
 202         if (srm_is_registered_console) {
 203                 struct tty_driver *driver;
 204                 int err;
 205
 206                 driver = tty_alloc_driver(MAX_SRM_CONSOLE_DEVICES, 0);
 207                 if (IS_ERR(driver))
 208                         return PTR_ERR(driver);
 209
 210                 tty_port_init(&srmcons_singleton.port);
 211
 212                 driver->driver_name = "srm";
 213                 driver->name = "srm";
 214                 driver->major = 0;      /* dynamic */
 215                 driver->minor_start = 0;
 216                 driver->type = TTY_DRIVER_TYPE_SYSTEM;
 217                 driver->subtype = SYSTEM_TYPE_SYSCONS;
 218                 driver->init_termios = tty_std_termios;
 219                 tty_set_operations(driver, &srmcons_ops);
 220                 tty_port_link_device(&srmcons_singleton.port, driver, 0);
 221                 err = tty_register_driver(driver);
 222                 if (err) {
 223                         tty_driver_kref_put(driver);
 224                         tty_port_destroy(&srmcons_singleton.port);
 225                         return err;
 226                 }
 227                 srmcons_driver = driver;
 228         }
 229
 230         return -ENODEV;
 231 }
 232 device_initcall(srmcons_init);
 233
 234 \f
 235 /*
 236  * The console driver
 237  */
 238 static void
 239 srm_console_write(struct console *co, const char *s, unsigned count)
 240 {
 241         unsigned long flags;
 242
 243         spin_lock_irqsave(&srmcons_callback_lock, flags);
 244         srmcons_do_write(NULL, s, count);
 245         spin_unlock_irqrestore(&srmcons_callback_lock, flags);
 246 }
 247
 248 static struct tty_driver *
 249 srm_console_device(struct console *co, int *index)
 250 {
 251         *index = co->index;
 252         return srmcons_driver;
 253 }
 254
 255 static int
 256 srm_console_setup(struct console *co, char *options)
 257 {
 258         return 0;
 259 }
 260
 261 static struct console srmcons = {
 262         .name           = "srm",
 263         .write          = srm_console_write,
 264         .device         = srm_console_device,
 265         .setup          = srm_console_setup,
 266         .flags          = CON_PRINTBUFFER | CON_BOOT,
 267         .index          = -1,
 268 };
 269
 270 void __init
 271 register_srm_console(void)
 272 {
 273         if (!srm_is_registered_console) {
 274                 callback_open_console();
 275                 register_console(&srmcons);
 276                 srm_is_registered_console = 1;
 277         }
 278 }
 279
 280 void __init
 281 unregister_srm_console(void)
 282 {
 283         if (srm_is_registered_console) {
 284                 callback_close_console();
 285                 unregister_console(&srmcons);
 286                 srm_is_registered_console = 0;
 287         }
 288 }