2 * linux/arch/alpha/kernel/srmcons.c
4 * Callback based driver for SRM Console console device.
5 * (TTY driver and console driver)
8 #include <linux/config.h>
9 #include <linux/kernel.h>
10 #include <linux/init.h>
11 #include <linux/console.h>
12 #include <linux/delay.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>
21 #include <asm/console.h>
22 #include <asm/uaccess.h>
25 static spinlock_t srmcons_callback_lock = SPIN_LOCK_UNLOCKED;
26 static int srm_is_registered_console = 0;
31 #define MAX_SRM_CONSOLE_DEVICES 1 /* only support 1 console device */
33 struct srmcons_private {
34 struct tty_struct *tty;
35 struct timer_list timer;
39 typedef union _srmcons_result {
42 unsigned long status :3;
47 /* called with callback_lock held */
49 srmcons_do_receive_chars(struct tty_struct *tty)
51 srmcons_result result;
52 int count = 0, loops = 0;
55 result.as_long = callback_getc(0);
56 if (result.bits.status < 2) {
57 tty_insert_flip_char(tty, (char)result.bits.c, 0);
60 } while((result.bits.status & 1) && (++loops < 10));
63 tty_schedule_flip(tty);
69 srmcons_receive_chars(unsigned long data)
71 struct srmcons_private *srmconsp = (struct srmcons_private *)data;
75 local_irq_save(flags);
76 if (spin_trylock(&srmcons_callback_lock)) {
77 if (!srmcons_do_receive_chars(srmconsp->tty))
79 spin_unlock(&srmcons_callback_lock);
82 spin_lock(&srmconsp->lock);
84 srmconsp->timer.expires = jiffies + incr;
85 add_timer(&srmconsp->timer);
87 spin_unlock(&srmconsp->lock);
89 local_irq_restore(flags);
92 /* called with callback_lock held */
94 srmcons_do_write(struct tty_struct *tty, const char *buf, int count)
96 static char str_cr[1] = "\r";
97 long c, remaining = count;
98 srmcons_result result;
102 for (cur = (char *)buf; remaining > 0; ) {
105 * Break it up into reasonable size chunks to allow a chance
106 * for input to get in
108 for (c = 0; c < min_t(long, 128L, remaining) && !need_cr; c++)
113 result.as_long = callback_puts(0, cur, c);
115 remaining -= result.bits.c;
116 cur += result.bits.c;
119 * Check for pending input iff a tty was provided
122 srmcons_do_receive_chars(tty);
126 result.as_long = callback_puts(0, str_cr, 1);
127 if (result.bits.c > 0)
135 srmcons_write(struct tty_struct *tty, int from_user,
136 const unsigned char *buf, int count)
145 while ((c = count) > 0) {
149 c -= copy_from_user(tmp, (const char __user *) buf, c);
152 printk("%s: EFAULT (count %d)\n",
153 __FUNCTION__, count);
157 spin_lock_irqsave(&srmcons_callback_lock, flags);
158 srmcons_do_write(tty, tmp, c);
159 spin_unlock_irqrestore(&srmcons_callback_lock, flags);
169 spin_lock_irqsave(&srmcons_callback_lock, flags);
170 srmcons_do_write(tty, (const char *) buf, count);
171 spin_unlock_irqrestore(&srmcons_callback_lock, flags);
177 srmcons_write_room(struct tty_struct *tty)
183 srmcons_chars_in_buffer(struct tty_struct *tty)
189 srmcons_get_private_struct(struct srmcons_private **ps)
191 static struct srmcons_private *srmconsp = NULL;
192 static spinlock_t srmconsp_lock = SPIN_LOCK_UNLOCKED;
196 spin_lock_irqsave(&srmconsp_lock, flags);
199 if (srmconsp != NULL) {
204 srmconsp = kmalloc(sizeof(*srmconsp), GFP_KERNEL);
205 if (srmconsp == NULL) {
210 srmconsp->tty = NULL;
211 srmconsp->lock = SPIN_LOCK_UNLOCKED;
212 init_timer(&srmconsp->timer);
217 spin_unlock_irqrestore(&srmconsp_lock, flags);
223 srmcons_open(struct tty_struct *tty, struct file *filp)
225 struct srmcons_private *srmconsp;
229 retval = srmcons_get_private_struct(&srmconsp);
233 spin_lock_irqsave(&srmconsp->lock, flags);
235 if (!srmconsp->tty) {
236 tty->driver_data = srmconsp;
239 srmconsp->timer.function = srmcons_receive_chars;
240 srmconsp->timer.data = (unsigned long)srmconsp;
241 srmconsp->timer.expires = jiffies + 10;
242 add_timer(&srmconsp->timer);
245 spin_unlock_irqrestore(&srmconsp->lock, flags);
251 srmcons_close(struct tty_struct *tty, struct file *filp)
253 struct srmcons_private *srmconsp = tty->driver_data;
256 spin_lock_irqsave(&srmconsp->lock, flags);
258 if (tty->count == 1) {
259 srmconsp->tty = NULL;
260 del_timer(&srmconsp->timer);
263 spin_unlock_irqrestore(&srmconsp->lock, flags);
267 static struct tty_driver *srmcons_driver;
269 static struct tty_operations srmcons_ops = {
270 .open = srmcons_open,
271 .close = srmcons_close,
272 .write = srmcons_write,
273 .write_room = srmcons_write_room,
274 .chars_in_buffer= srmcons_chars_in_buffer,
280 if (srm_is_registered_console) {
281 struct tty_driver *driver;
284 driver = alloc_tty_driver(MAX_SRM_CONSOLE_DEVICES);
287 driver->driver_name = "srm";
288 driver->name = "srm";
289 driver->major = 0; /* dynamic */
290 driver->minor_start = 0;
291 driver->type = TTY_DRIVER_TYPE_SYSTEM;
292 driver->subtype = SYSTEM_TYPE_SYSCONS;
293 driver->init_termios = tty_std_termios;
294 tty_set_operations(driver, &srmcons_ops);
295 err = tty_register_driver(driver);
297 put_tty_driver(driver);
300 srmcons_driver = driver;
306 module_init(srmcons_init);
313 srm_console_write(struct console *co, const char *s, unsigned count)
317 spin_lock_irqsave(&srmcons_callback_lock, flags);
318 srmcons_do_write(NULL, s, count);
319 spin_unlock_irqrestore(&srmcons_callback_lock, flags);
322 static struct tty_driver *
323 srm_console_device(struct console *co, int *index)
326 return srmcons_driver;
330 srm_console_setup(struct console *co, char *options)
335 static struct console srmcons = {
337 .write = srm_console_write,
338 .device = srm_console_device,
339 .setup = srm_console_setup,
340 .flags = CON_PRINTBUFFER,
345 register_srm_console(void)
347 if (!srm_is_registered_console) {
348 callback_open_console();
349 register_console(&srmcons);
350 srm_is_registered_console = 1;
355 unregister_srm_console(void)
357 if (srm_is_registered_console) {
358 callback_close_console();
359 unregister_console(&srmcons);
360 srm_is_registered_console = 0;