[go: up one dir, main page]
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#include "proto.h"
25
26
27static DEFINE_SPINLOCK(srmcons_callback_lock);
28static int srm_is_registered_console = 0;
29
30/*
31 * The TTY driver
32 */
33#define MAX_SRM_CONSOLE_DEVICES 1 /* only support 1 console device */
34
35struct srmcons_private {
36 struct tty_port port;
37 struct timer_list timer;
38} srmcons_singleton;
39
40typedef union _srmcons_result {
41 struct {
42 unsigned long c :61;
43 unsigned long status :3;
44 } bits;
45 long as_long;
46} srmcons_result;
47
48/* called with callback_lock held */
49static int
50srmcons_do_receive_chars(struct tty_port *port)
51{
52 srmcons_result result;
53 int count = 0, loops = 0;
54
55 do {
56 result.as_long = callback_getc(0);
57 if (result.bits.status < 2) {
58 tty_insert_flip_char(port, ch: (u8)result.bits.c, flag: 0);
59 count++;
60 }
61 } while((result.bits.status & 1) && (++loops < 10));
62
63 if (count)
64 tty_flip_buffer_push(port);
65
66 return count;
67}
68
69static void
70srmcons_receive_chars(struct timer_list *t)
71{
72 struct srmcons_private *srmconsp = timer_container_of(srmconsp, t,
73 timer);
74 struct tty_port *port = &srmconsp->port;
75 unsigned long flags;
76 int incr = 10;
77
78 local_irq_save(flags);
79 if (spin_trylock(lock: &srmcons_callback_lock)) {
80 if (!srmcons_do_receive_chars(port))
81 incr = 100;
82 spin_unlock(lock: &srmcons_callback_lock);
83 }
84
85 spin_lock(lock: &port->lock);
86 if (port->tty)
87 mod_timer(timer: &srmconsp->timer, expires: jiffies + incr);
88 spin_unlock(lock: &port->lock);
89
90 local_irq_restore(flags);
91}
92
93/* called with callback_lock held */
94static void
95srmcons_do_write(struct tty_port *port, const u8 *buf, size_t count)
96{
97 size_t c;
98 srmcons_result result;
99
100 while (count > 0) {
101 bool need_cr = false;
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(size_t, 128U, count) && !need_cr; c++)
107 if (buf[c] == '\n')
108 need_cr = true;
109
110 while (c > 0) {
111 result.as_long = callback_puts(0, buf, c);
112 c -= result.bits.c;
113 count -= result.bits.c;
114 buf += 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, "\r", 1);
125 if (result.bits.c > 0)
126 need_cr = false;
127 }
128 }
129}
130
131static ssize_t
132srmcons_write(struct tty_struct *tty, const u8 *buf, size_t count)
133{
134 unsigned long flags;
135
136 spin_lock_irqsave(&srmcons_callback_lock, flags);
137 srmcons_do_write(port: tty->port, buf, count);
138 spin_unlock_irqrestore(lock: &srmcons_callback_lock, flags);
139
140 return count;
141}
142
143static unsigned int
144srmcons_write_room(struct tty_struct *tty)
145{
146 return 512;
147}
148
149static int
150srmcons_open(struct tty_struct *tty, struct file *filp)
151{
152 struct srmcons_private *srmconsp = &srmcons_singleton;
153 struct tty_port *port = &srmconsp->port;
154 unsigned long flags;
155
156 spin_lock_irqsave(&port->lock, flags);
157
158 if (!port->tty) {
159 tty->driver_data = srmconsp;
160 tty->port = port;
161 port->tty = tty; /* XXX proper refcounting */
162 mod_timer(timer: &srmconsp->timer, expires: jiffies + 10);
163 }
164
165 spin_unlock_irqrestore(lock: &port->lock, flags);
166
167 return 0;
168}
169
170static void
171srmcons_close(struct tty_struct *tty, struct file *filp)
172{
173 struct srmcons_private *srmconsp = tty->driver_data;
174 struct tty_port *port = &srmconsp->port;
175 unsigned long flags;
176
177 spin_lock_irqsave(&port->lock, flags);
178
179 if (tty->count == 1) {
180 port->tty = NULL;
181 timer_delete(timer: &srmconsp->timer);
182 }
183
184 spin_unlock_irqrestore(lock: &port->lock, flags);
185}
186
187
188static struct tty_driver *srmcons_driver;
189
190static const struct tty_operations srmcons_ops = {
191 .open = srmcons_open,
192 .close = srmcons_close,
193 .write = srmcons_write,
194 .write_room = srmcons_write_room,
195};
196
197static int __init
198srmcons_init(void)
199{
200 struct tty_driver *driver;
201 int err;
202
203 timer_setup(&srmcons_singleton.timer, srmcons_receive_chars, 0);
204
205 if (!srm_is_registered_console)
206 return -ENODEV;
207
208 driver = tty_alloc_driver(MAX_SRM_CONSOLE_DEVICES, 0);
209 if (IS_ERR(ptr: driver))
210 return PTR_ERR(ptr: driver);
211
212 tty_port_init(port: &srmcons_singleton.port);
213
214 driver->driver_name = "srm";
215 driver->name = "srm";
216 driver->major = 0; /* dynamic */
217 driver->minor_start = 0;
218 driver->type = TTY_DRIVER_TYPE_SYSTEM;
219 driver->subtype = SYSTEM_TYPE_SYSCONS;
220 driver->init_termios = tty_std_termios;
221 tty_set_operations(driver, op: &srmcons_ops);
222 tty_port_link_device(port: &srmcons_singleton.port, driver, index: 0);
223 err = tty_register_driver(driver);
224 if (err)
225 goto err_free_drv;
226
227 srmcons_driver = driver;
228
229 return 0;
230err_free_drv:
231 tty_driver_kref_put(driver);
232 tty_port_destroy(port: &srmcons_singleton.port);
233
234 return err;
235}
236device_initcall(srmcons_init);
237
238/*
239 * The console driver
240 */
241static void
242srm_console_write(struct console *co, const char *s, unsigned count)
243{
244 unsigned long flags;
245
246 spin_lock_irqsave(&srmcons_callback_lock, flags);
247 srmcons_do_write(NULL, buf: s, count);
248 spin_unlock_irqrestore(lock: &srmcons_callback_lock, flags);
249}
250
251static struct tty_driver *
252srm_console_device(struct console *co, int *index)
253{
254 *index = co->index;
255 return srmcons_driver;
256}
257
258static int
259srm_console_setup(struct console *co, char *options)
260{
261 return 0;
262}
263
264static struct console srmcons = {
265 .name = "srm",
266 .write = srm_console_write,
267 .device = srm_console_device,
268 .setup = srm_console_setup,
269 .flags = CON_PRINTBUFFER | CON_BOOT,
270 .index = -1,
271};
272
273void __init
274register_srm_console(void)
275{
276 if (!srm_is_registered_console) {
277 callback_open_console();
278 register_console(&srmcons);
279 srm_is_registered_console = 1;
280 }
281}
282
283void __init
284unregister_srm_console(void)
285{
286 if (srm_is_registered_console) {
287 callback_close_console();
288 unregister_console(&srmcons);
289 srm_is_registered_console = 0;
290 }
291}
292

source code of linux/arch/alpha/kernel/srmcons.c