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