blob: 72b59511e59aa350cc58d568cf896edba4f53602 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#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
24static DEFINE_SPINLOCK(srmcons_callback_lock);
25static 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
32struct srmcons_private {
Jiri Slaby54089d4c2012-03-05 14:51:59 +010033 struct tty_port port;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 struct timer_list timer;
Jiri Slabyee024d42012-03-05 14:51:58 +010035} srmcons_singleton;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37typedef 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 */
46static int
Jiri Slaby6732c8b2013-01-03 15:53:07 +010047srmcons_do_receive_chars(struct tty_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -070048{
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) {
Jiri Slaby92a19f92013-01-03 15:53:03 +010055 tty_insert_flip_char(port, (char)result.bits.c, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 count++;
57 }
58 } while((result.bits.status & 1) && (++loops < 10));
59
60 if (count)
Jiri Slaby6732c8b2013-01-03 15:53:07 +010061 tty_schedule_flip(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63 return count;
64}
65
66static void
67srmcons_receive_chars(unsigned long data)
68{
69 struct srmcons_private *srmconsp = (struct srmcons_private *)data;
Jiri Slaby54089d4c2012-03-05 14:51:59 +010070 struct tty_port *port = &srmconsp->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 unsigned long flags;
72 int incr = 10;
73
74 local_irq_save(flags);
75 if (spin_trylock(&srmcons_callback_lock)) {
Jiri Slaby6732c8b2013-01-03 15:53:07 +010076 if (!srmcons_do_receive_chars(port))
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 incr = 100;
78 spin_unlock(&srmcons_callback_lock);
79 }
80
Jiri Slaby54089d4c2012-03-05 14:51:59 +010081 spin_lock(&port->lock);
82 if (port->tty)
Jiri Slaby5e88e6c2012-03-05 14:51:57 +010083 mod_timer(&srmconsp->timer, jiffies + incr);
Jiri Slaby54089d4c2012-03-05 14:51:59 +010084 spin_unlock(&port->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86 local_irq_restore(flags);
87}
88
89/* called with callback_lock held */
90static int
Jiri Slaby6732c8b2013-01-03 15:53:07 +010091srmcons_do_write(struct tty_port *port, const char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
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 /*
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100116 * Check for pending input iff a tty port was provided
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 */
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100118 if (port)
119 srmcons_do_receive_chars(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 }
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
131static int
132srmcons_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);
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100138 srmcons_do_write(tty->port, (const char *) buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 spin_unlock_irqrestore(&srmcons_callback_lock, flags);
140
141 return count;
142}
143
144static int
145srmcons_write_room(struct tty_struct *tty)
146{
147 return 512;
148}
149
150static int
151srmcons_chars_in_buffer(struct tty_struct *tty)
152{
153 return 0;
154}
155
156static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157srmcons_open(struct tty_struct *tty, struct file *filp)
158{
Jiri Slabyee024d42012-03-05 14:51:58 +0100159 struct srmcons_private *srmconsp = &srmcons_singleton;
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100160 struct tty_port *port = &srmconsp->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100163 spin_lock_irqsave(&port->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100165 if (!port->tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 tty->driver_data = srmconsp;
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100167 tty->port = port;
168 port->tty = tty; /* XXX proper refcounting */
Jiri Slaby5e88e6c2012-03-05 14:51:57 +0100169 mod_timer(&srmconsp->timer, jiffies + 10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 }
171
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100172 spin_unlock_irqrestore(&port->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
174 return 0;
175}
176
177static void
178srmcons_close(struct tty_struct *tty, struct file *filp)
179{
180 struct srmcons_private *srmconsp = tty->driver_data;
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100181 struct tty_port *port = &srmconsp->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 unsigned long flags;
183
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100184 spin_lock_irqsave(&port->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
186 if (tty->count == 1) {
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100187 port->tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 del_timer(&srmconsp->timer);
189 }
190
Jiri Slaby54089d4c2012-03-05 14:51:59 +0100191 spin_unlock_irqrestore(&port->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192}
193
194
195static struct tty_driver *srmcons_driver;
196
Jeff Dikeb68e31d2006-10-02 02:17:18 -0700197static const struct tty_operations srmcons_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 .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
205static int __init
206srmcons_init(void)
207{
Jiri Slabyee024d42012-03-05 14:51:58 +0100208 setup_timer(&srmcons_singleton.timer, srmcons_receive_chars,
209 (unsigned long)&srmcons_singleton);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 if (srm_is_registered_console) {
211 struct tty_driver *driver;
212 int err;
213
214 driver = alloc_tty_driver(MAX_SRM_CONSOLE_DEVICES);
215 if (!driver)
216 return -ENOMEM;
Jiri Slaby191c5f12012-11-15 09:49:56 +0100217
218 tty_port_init(&srmcons_singleton.port);
219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 driver->driver_name = "srm";
221 driver->name = "srm";
222 driver->major = 0; /* dynamic */
223 driver->minor_start = 0;
224 driver->type = TTY_DRIVER_TYPE_SYSTEM;
225 driver->subtype = SYSTEM_TYPE_SYSCONS;
226 driver->init_termios = tty_std_termios;
227 tty_set_operations(driver, &srmcons_ops);
Jiri Slabyb19e2ca2012-08-07 21:47:51 +0200228 tty_port_link_device(&srmcons_singleton.port, driver, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 err = tty_register_driver(driver);
230 if (err) {
231 put_tty_driver(driver);
Jiri Slaby191c5f12012-11-15 09:49:56 +0100232 tty_port_destroy(&srmcons_singleton.port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 return err;
234 }
235 srmcons_driver = driver;
236 }
237
238 return -ENODEV;
239}
Paul Gortmaker11447c72014-01-10 17:02:02 -0500240device_initcall(srmcons_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
242
243/*
244 * The console driver
245 */
246static void
247srm_console_write(struct console *co, const char *s, unsigned count)
248{
249 unsigned long flags;
250
251 spin_lock_irqsave(&srmcons_callback_lock, flags);
252 srmcons_do_write(NULL, s, count);
253 spin_unlock_irqrestore(&srmcons_callback_lock, flags);
254}
255
256static struct tty_driver *
257srm_console_device(struct console *co, int *index)
258{
259 *index = co->index;
260 return srmcons_driver;
261}
262
Sam Ravnborgebaf4fc2007-07-15 23:38:37 -0700263static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264srm_console_setup(struct console *co, char *options)
265{
266 return 0;
267}
268
269static struct console srmcons = {
270 .name = "srm",
271 .write = srm_console_write,
272 .device = srm_console_device,
273 .setup = srm_console_setup,
Gerd Hoffmann69331af2007-05-08 00:26:49 -0700274 .flags = CON_PRINTBUFFER | CON_BOOT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 .index = -1,
276};
277
278void __init
279register_srm_console(void)
280{
281 if (!srm_is_registered_console) {
282 callback_open_console();
283 register_console(&srmcons);
284 srm_is_registered_console = 1;
285 }
286}
287
288void __init
289unregister_srm_console(void)
290{
291 if (srm_is_registered_console) {
292 callback_close_console();
293 unregister_console(&srmcons);
294 srm_is_registered_console = 0;
295 }
296}