21b57a66e809ae9168ef4ba06fb715c158db3c40
[linux-3.10.git] / arch / alpha / kernel / srmcons.c
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         struct tty_port *port = tty->port;
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_schedule_flip(tty);
63
64         return count;
65 }
66
67 static void
68 srmcons_receive_chars(unsigned long data)
69 {
70         struct srmcons_private *srmconsp = (struct srmcons_private *)data;
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->tty))
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_struct *tty, 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 was provided
118                          */
119                         if (tty)
120                                 srmcons_do_receive_chars(tty);
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 int
133 srmcons_write(struct tty_struct *tty,
134               const unsigned char *buf, int count)
135 {
136         unsigned long flags;
137
138         spin_lock_irqsave(&srmcons_callback_lock, flags);
139         srmcons_do_write(tty, (const char *) buf, count);
140         spin_unlock_irqrestore(&srmcons_callback_lock, flags);
141
142         return count;
143 }
144
145 static int
146 srmcons_write_room(struct tty_struct *tty)
147 {
148         return 512;
149 }
150
151 static int
152 srmcons_chars_in_buffer(struct tty_struct *tty)
153 {
154         return 0;
155 }
156
157 static int
158 srmcons_open(struct tty_struct *tty, struct file *filp)
159 {
160         struct srmcons_private *srmconsp = &srmcons_singleton;
161         struct tty_port *port = &srmconsp->port;
162         unsigned long flags;
163
164         spin_lock_irqsave(&port->lock, flags);
165
166         if (!port->tty) {
167                 tty->driver_data = srmconsp;
168                 tty->port = port;
169                 port->tty = tty; /* XXX proper refcounting */
170                 mod_timer(&srmconsp->timer, jiffies + 10);
171         }
172
173         spin_unlock_irqrestore(&port->lock, flags);
174
175         return 0;
176 }
177
178 static void
179 srmcons_close(struct tty_struct *tty, struct file *filp)
180 {
181         struct srmcons_private *srmconsp = tty->driver_data;
182         struct tty_port *port = &srmconsp->port;
183         unsigned long flags;
184
185         spin_lock_irqsave(&port->lock, flags);
186
187         if (tty->count == 1) {
188                 port->tty = NULL;
189                 del_timer(&srmconsp->timer);
190         }
191
192         spin_unlock_irqrestore(&port->lock, flags);
193 }
194
195
196 static struct tty_driver *srmcons_driver;
197
198 static const struct tty_operations srmcons_ops = {
199         .open           = srmcons_open,
200         .close          = srmcons_close,
201         .write          = srmcons_write,
202         .write_room     = srmcons_write_room,
203         .chars_in_buffer= srmcons_chars_in_buffer,
204 };
205
206 static int __init
207 srmcons_init(void)
208 {
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
219                 tty_port_init(&srmcons_singleton.port);
220
221                 driver->driver_name = "srm";
222                 driver->name = "srm";
223                 driver->major = 0;      /* dynamic */
224                 driver->minor_start = 0;
225                 driver->type = TTY_DRIVER_TYPE_SYSTEM;
226                 driver->subtype = SYSTEM_TYPE_SYSCONS;
227                 driver->init_termios = tty_std_termios;
228                 tty_set_operations(driver, &srmcons_ops);
229                 tty_port_link_device(&srmcons_singleton.port, driver, 0);
230                 err = tty_register_driver(driver);
231                 if (err) {
232                         put_tty_driver(driver);
233                         tty_port_destroy(&srmcons_singleton.port);
234                         return err;
235                 }
236                 srmcons_driver = driver;
237         }
238
239         return -ENODEV;
240 }
241
242 module_init(srmcons_init);
243
244 \f
245 /*
246  * The console driver
247  */
248 static void
249 srm_console_write(struct console *co, const char *s, unsigned count)
250 {
251         unsigned long flags;
252
253         spin_lock_irqsave(&srmcons_callback_lock, flags);
254         srmcons_do_write(NULL, s, count);
255         spin_unlock_irqrestore(&srmcons_callback_lock, flags);
256 }
257
258 static struct tty_driver *
259 srm_console_device(struct console *co, int *index)
260 {
261         *index = co->index;
262         return srmcons_driver;
263 }
264
265 static int
266 srm_console_setup(struct console *co, char *options)
267 {
268         return 0;
269 }
270
271 static struct console srmcons = {
272         .name           = "srm",
273         .write          = srm_console_write,
274         .device         = srm_console_device,
275         .setup          = srm_console_setup,
276         .flags          = CON_PRINTBUFFER | CON_BOOT,
277         .index          = -1,
278 };
279
280 void __init
281 register_srm_console(void)
282 {
283         if (!srm_is_registered_console) {
284                 callback_open_console();
285                 register_console(&srmcons);
286                 srm_is_registered_console = 1;
287         }
288 }
289
290 void __init
291 unregister_srm_console(void)
292 {
293         if (srm_is_registered_console) {
294                 callback_close_console();
295                 unregister_console(&srmcons);
296                 srm_is_registered_console = 0;
297         }
298 }