blob: 09676b4e5d8964d77a4cc555cbe30e616c62e7b0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
3 * Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
4 * Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
5 * Copyright (C) 2004 IBM Corporation
6 *
7 * Additional Author(s):
8 * Ryan S. Arnold <rsa@us.ibm.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25#include <linux/console.h>
26#include <linux/cpumask.h>
27#include <linux/init.h>
28#include <linux/kbd_kern.h>
29#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/kthread.h>
31#include <linux/list.h>
32#include <linux/module.h>
33#include <linux/major.h>
34#include <linux/sysrq.h>
35#include <linux/tty.h>
36#include <linux/tty_flip.h>
37#include <linux/sched.h>
38#include <linux/spinlock.h>
39#include <linux/delay.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080040#include <linux/freezer.h>
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020041
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <asm/uaccess.h>
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020043
44#include "hvc_console.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46#define HVC_MAJOR 229
47#define HVC_MINOR 0
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049/*
50 * Wait this long per iteration while trying to push buffered data to the
51 * hypervisor before allowing the tty to complete a close operation.
52 */
53#define HVC_CLOSE_WAIT (HZ/100) /* 1/10 of a second */
54
55/*
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020056 * These sizes are most efficient for vio, because they are the
57 * native transfer size. We could make them selectable in the
58 * future to better deal with backends that want other buffer sizes.
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#define N_OUTBUF 16
61#define N_INBUF 16
62
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020063#define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Milton Miller837dcfa2005-07-07 17:56:16 -070065static struct tty_driver *hvc_driver;
66static struct task_struct *hvc_task;
67
68/* Picks up late kicks after list walk but before schedule() */
69static int hvc_kicked;
70
Rusty Russell3e6c6f62007-10-16 23:30:13 -070071static int hvc_init(void);
72
Milton Miller837dcfa2005-07-07 17:56:16 -070073#ifdef CONFIG_MAGIC_SYSRQ
74static int sysrq_pressed;
75#endif
76
Linus Torvalds1da177e2005-04-16 15:20:36 -070077/* dynamic list of hvc_struct instances */
Denis Chengbed97592008-02-06 01:37:35 -080078static LIST_HEAD(hvc_structs);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80/*
81 * Protect the list of hvc_struct instances from inserts and removals during
82 * list traversal.
83 */
84static DEFINE_SPINLOCK(hvc_structs_lock);
85
86/*
Milton Miller6f248082005-07-07 17:56:17 -070087 * This value is used to assign a tty->index value to a hvc_struct based
88 * upon order of exposure via hvc_probe(), when we can not match it to
will schmidtc3ea6922007-04-18 00:54:51 +100089 * a console candidate registered with hvc_instantiate().
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 */
Milton Miller6f248082005-07-07 17:56:17 -070091static int last_hvc = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Linus Torvalds1da177e2005-04-16 15:20:36 -070093/*
will schmidtc3ea6922007-04-18 00:54:51 +100094 * Do not call this function with either the hvc_structs_lock or the hvc_struct
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -080095 * lock held. If successful, this function increments the kref reference
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 * count against the target hvc_struct so it should be released when finished.
97 */
Adrian Bunk4fa156e2007-05-08 00:24:24 -070098static struct hvc_struct *hvc_get_by_index(int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099{
100 struct hvc_struct *hp;
101 unsigned long flags;
102
103 spin_lock(&hvc_structs_lock);
104
105 list_for_each_entry(hp, &hvc_structs, next) {
106 spin_lock_irqsave(&hp->lock, flags);
107 if (hp->index == index) {
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800108 kref_get(&hp->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 spin_unlock_irqrestore(&hp->lock, flags);
110 spin_unlock(&hvc_structs_lock);
111 return hp;
112 }
113 spin_unlock_irqrestore(&hp->lock, flags);
114 }
115 hp = NULL;
116
117 spin_unlock(&hvc_structs_lock);
118 return hp;
119}
120
Milton Miller837dcfa2005-07-07 17:56:16 -0700121
122/*
123 * Initial console vtermnos for console API usage prior to full console
124 * initialization. Any vty adapter outside this range will not have usable
125 * console interfaces but can still be used as a tty device. This has to be
126 * static because kmalloc will not work during early console init.
127 */
Milton Miller030ffad2005-07-07 17:56:25 -0700128static struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
Milton Miller64e4da52005-07-07 17:56:22 -0700129static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
130 {[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
Milton Miller837dcfa2005-07-07 17:56:16 -0700131
132/*
133 * Console APIs, NOT TTY. These APIs are available immediately when
134 * hvc_console_setup() finds adapters.
135 */
136
Adrian Bunk4fa156e2007-05-08 00:24:24 -0700137static void hvc_console_print(struct console *co, const char *b,
138 unsigned count)
Milton Miller837dcfa2005-07-07 17:56:16 -0700139{
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200140 char c[N_OUTBUF] __ALIGNED__;
Milton Miller837dcfa2005-07-07 17:56:16 -0700141 unsigned i = 0, n = 0;
Milton Miller030ffad2005-07-07 17:56:25 -0700142 int r, donecr = 0, index = co->index;
Milton Miller837dcfa2005-07-07 17:56:16 -0700143
144 /* Console access attempt outside of acceptable console range. */
Milton Miller030ffad2005-07-07 17:56:25 -0700145 if (index >= MAX_NR_HVC_CONSOLES)
Milton Miller837dcfa2005-07-07 17:56:16 -0700146 return;
147
will schmidtc3ea6922007-04-18 00:54:51 +1000148 /* This console adapter was removed so it is not usable. */
Milton Miller030ffad2005-07-07 17:56:25 -0700149 if (vtermnos[index] < 0)
Milton Miller837dcfa2005-07-07 17:56:16 -0700150 return;
151
152 while (count > 0 || i > 0) {
153 if (count > 0 && i < sizeof(c)) {
154 if (b[n] == '\n' && !donecr) {
155 c[i++] = '\r';
156 donecr = 1;
157 } else {
158 c[i++] = b[n++];
159 donecr = 0;
160 --count;
161 }
162 } else {
Milton Miller030ffad2005-07-07 17:56:25 -0700163 r = cons_ops[index]->put_chars(vtermnos[index], c, i);
Hendrik Brueckner3feebbb2008-10-13 23:12:50 +0000164 if (r <= 0) {
Milton Miller837dcfa2005-07-07 17:56:16 -0700165 /* throw away chars on error */
166 i = 0;
167 } else if (r > 0) {
168 i -= r;
169 if (i > 0)
170 memmove(c, c+r, i);
171 }
172 }
173 }
174}
175
176static struct tty_driver *hvc_console_device(struct console *c, int *index)
177{
Milton Miller7805b1b2005-07-07 17:56:23 -0700178 if (vtermnos[c->index] == -1)
179 return NULL;
180
Milton Miller837dcfa2005-07-07 17:56:16 -0700181 *index = c->index;
182 return hvc_driver;
183}
184
185static int __init hvc_console_setup(struct console *co, char *options)
186{
Milton Miller7805b1b2005-07-07 17:56:23 -0700187 if (co->index < 0 || co->index >= MAX_NR_HVC_CONSOLES)
188 return -ENODEV;
189
190 if (vtermnos[co->index] == -1)
191 return -ENODEV;
192
Milton Miller837dcfa2005-07-07 17:56:16 -0700193 return 0;
194}
195
Adrian Bunk4fa156e2007-05-08 00:24:24 -0700196static struct console hvc_con_driver = {
Milton Miller837dcfa2005-07-07 17:56:16 -0700197 .name = "hvc",
198 .write = hvc_console_print,
199 .device = hvc_console_device,
200 .setup = hvc_console_setup,
201 .flags = CON_PRINTBUFFER,
202 .index = -1,
203};
204
Milton Millerd5ee2572005-07-07 17:56:24 -0700205/*
will schmidtc3ea6922007-04-18 00:54:51 +1000206 * Early console initialization. Precedes driver initialization.
Milton Millerd5ee2572005-07-07 17:56:24 -0700207 *
208 * (1) we are first, and the user specified another driver
209 * -- index will remain -1
210 * (2) we are first and the user specified no driver
211 * -- index will be set to 0, then we will fail setup.
212 * (3) we are first and the user specified our driver
213 * -- index will be set to user specified driver, and we will fail
214 * (4) we are after driver, and this initcall will register us
215 * -- if the user didn't specify a driver then the console will match
216 *
217 * Note that for cases 2 and 3, we will match later when the io driver
218 * calls hvc_instantiate() and call register again.
219 */
Milton Miller837dcfa2005-07-07 17:56:16 -0700220static int __init hvc_console_init(void)
221{
Milton Miller837dcfa2005-07-07 17:56:16 -0700222 register_console(&hvc_con_driver);
223 return 0;
224}
225console_initcall(hvc_console_init);
226
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800227/* callback when the kboject ref count reaches zero. */
228static void destroy_hvc_struct(struct kref *kref)
229{
230 struct hvc_struct *hp = container_of(kref, struct hvc_struct, kref);
231 unsigned long flags;
232
233 spin_lock(&hvc_structs_lock);
234
235 spin_lock_irqsave(&hp->lock, flags);
236 list_del(&(hp->next));
237 spin_unlock_irqrestore(&hp->lock, flags);
238
239 spin_unlock(&hvc_structs_lock);
240
241 kfree(hp);
242}
243
Milton Miller837dcfa2005-07-07 17:56:16 -0700244/*
Milton Miller6f248082005-07-07 17:56:17 -0700245 * hvc_instantiate() is an early console discovery method which locates
246 * consoles * prior to the vio subsystem discovering them. Hotplugged
247 * vty adapters do NOT get an hvc_instantiate() callback since they
248 * appear after early console init.
Milton Miller837dcfa2005-07-07 17:56:16 -0700249 */
Milton Miller030ffad2005-07-07 17:56:25 -0700250int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops)
Milton Miller837dcfa2005-07-07 17:56:16 -0700251{
Milton Miller7805b1b2005-07-07 17:56:23 -0700252 struct hvc_struct *hp;
253
Milton Miller837dcfa2005-07-07 17:56:16 -0700254 if (index < 0 || index >= MAX_NR_HVC_CONSOLES)
255 return -1;
256
257 if (vtermnos[index] != -1)
258 return -1;
259
will schmidtc3ea6922007-04-18 00:54:51 +1000260 /* make sure no no tty has been registered in this index */
Milton Miller7805b1b2005-07-07 17:56:23 -0700261 hp = hvc_get_by_index(index);
262 if (hp) {
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800263 kref_put(&hp->kref, destroy_hvc_struct);
Milton Miller7805b1b2005-07-07 17:56:23 -0700264 return -1;
265 }
266
Milton Miller837dcfa2005-07-07 17:56:16 -0700267 vtermnos[index] = vtermno;
Milton Miller030ffad2005-07-07 17:56:25 -0700268 cons_ops[index] = ops;
Milton Miller6f248082005-07-07 17:56:17 -0700269
will schmidtc3ea6922007-04-18 00:54:51 +1000270 /* reserve all indices up to and including this index */
Milton Miller6f248082005-07-07 17:56:17 -0700271 if (last_hvc < index)
272 last_hvc = index;
273
Milton Millerd5ee2572005-07-07 17:56:24 -0700274 /* if this index is what the user requested, then register
275 * now (setup won't fail at this point). It's ok to just
276 * call register again if previously .setup failed.
277 */
278 if (index == hvc_con_driver.index)
279 register_console(&hvc_con_driver);
280
Milton Miller837dcfa2005-07-07 17:56:16 -0700281 return 0;
282}
Christian Borntraeger7721c492008-07-25 12:06:06 -0500283EXPORT_SYMBOL_GPL(hvc_instantiate);
Milton Miller837dcfa2005-07-07 17:56:16 -0700284
285/* Wake the sleeping khvcd */
Christian Borntraeger611e0972008-06-20 15:24:08 +0200286void hvc_kick(void)
Milton Miller837dcfa2005-07-07 17:56:16 -0700287{
288 hvc_kicked = 1;
289 wake_up_process(hvc_task);
290}
Christian Borntraeger7721c492008-07-25 12:06:06 -0500291EXPORT_SYMBOL_GPL(hvc_kick);
Milton Miller837dcfa2005-07-07 17:56:16 -0700292
Milton Miller837dcfa2005-07-07 17:56:16 -0700293static void hvc_unthrottle(struct tty_struct *tty)
294{
295 hvc_kick();
296}
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298/*
299 * The TTY interface won't be used until after the vio layer has exposed the vty
300 * adapter to the kernel.
301 */
302static int hvc_open(struct tty_struct *tty, struct file * filp)
303{
304 struct hvc_struct *hp;
305 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800308 /* Auto increments kref reference if found. */
Olof Johansson87fd7722006-09-07 15:18:08 -0500309 if (!(hp = hvc_get_by_index(tty->index)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
312 spin_lock_irqsave(&hp->lock, flags);
313 /* Check and then increment for fast path open. */
314 if (hp->count++ > 0) {
315 spin_unlock_irqrestore(&hp->lock, flags);
316 hvc_kick();
317 return 0;
318 } /* else count == 0 */
319
320 tty->driver_data = hp;
Milton Millerda9dc132009-01-08 02:14:24 +0000321 if (!hp->irq_requested)
322 tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */
Michal Ostrowskifb5c5942006-02-18 09:29:59 -0500323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 hp->tty = tty;
Christian Borntraeger611e0972008-06-20 15:24:08 +0200325
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 spin_unlock_irqrestore(&hp->lock, flags);
Christian Borntraeger611e0972008-06-20 15:24:08 +0200327
Christian Borntraegerb1b135c2008-08-07 09:18:34 +0200328 if (hp->ops->notifier_add)
329 rc = hp->ops->notifier_add(hp, hp->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
331 /*
Christian Borntraeger611e0972008-06-20 15:24:08 +0200332 * If the notifier fails we return an error. The tty layer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 * will call hvc_close() after a failed open but we don't want to clean
334 * up there so we'll clean up here and clear out the previously set
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800335 * tty fields and return the kref reference.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 */
337 if (rc) {
338 spin_lock_irqsave(&hp->lock, flags);
339 hp->tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 spin_unlock_irqrestore(&hp->lock, flags);
341 tty->driver_data = NULL;
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800342 kref_put(&hp->kref, destroy_hvc_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 printk(KERN_ERR "hvc_open: request_irq failed with rc %d.\n", rc);
344 }
345 /* Force wakeup of the polling thread */
346 hvc_kick();
347
348 return rc;
349}
350
351static void hvc_close(struct tty_struct *tty, struct file * filp)
352{
353 struct hvc_struct *hp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 unsigned long flags;
355
356 if (tty_hung_up_p(filp))
357 return;
358
359 /*
360 * No driver_data means that this close was issued after a failed
361 * hvc_open by the tty layer's release_dev() function and we can just
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800362 * exit cleanly because the kref reference wasn't made.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 */
364 if (!tty->driver_data)
365 return;
366
367 hp = tty->driver_data;
368 spin_lock_irqsave(&hp->lock, flags);
369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 if (--hp->count == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 /* We are done with the tty pointer now. */
372 hp->tty = NULL;
373 spin_unlock_irqrestore(&hp->lock, flags);
374
Christian Borntraegereef26222008-10-12 21:51:31 +0000375 if (hp->ops->notifier_del)
376 hp->ops->notifier_del(hp, hp->data);
377
Hendrik Bruecknerfebde372008-10-14 05:02:09 +0000378 /* cancel pending tty resize work */
379 cancel_work_sync(&hp->tty_resize);
380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 /*
382 * Chain calls chars_in_buffer() and returns immediately if
383 * there is no buffered data otherwise sleeps on a wait queue
384 * waking periodically to check chars_in_buffer().
385 */
386 tty_wait_until_sent(tty, HVC_CLOSE_WAIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 } else {
388 if (hp->count < 0)
389 printk(KERN_ERR "hvc_close %X: oops, count is %d\n",
390 hp->vtermno, hp->count);
391 spin_unlock_irqrestore(&hp->lock, flags);
392 }
393
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800394 kref_put(&hp->kref, destroy_hvc_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395}
396
397static void hvc_hangup(struct tty_struct *tty)
398{
399 struct hvc_struct *hp = tty->driver_data;
400 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 int temp_open_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
403 if (!hp)
404 return;
405
Hendrik Bruecknerfebde372008-10-14 05:02:09 +0000406 /* cancel pending tty resize work */
407 cancel_work_sync(&hp->tty_resize);
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 spin_lock_irqsave(&hp->lock, flags);
410
411 /*
412 * The N_TTY line discipline has problems such that in a close vs
413 * open->hangup case this can be called after the final close so prevent
414 * that from happening for now.
415 */
416 if (hp->count <= 0) {
417 spin_unlock_irqrestore(&hp->lock, flags);
418 return;
419 }
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 temp_open_count = hp->count;
422 hp->count = 0;
423 hp->n_outbuf = 0;
424 hp->tty = NULL;
Christian Borntraeger611e0972008-06-20 15:24:08 +0200425
Christian Borntraegereef26222008-10-12 21:51:31 +0000426 spin_unlock_irqrestore(&hp->lock, flags);
427
Hendrik Bruecknerfc362e22008-10-13 23:12:48 +0000428 if (hp->ops->notifier_hangup)
429 hp->ops->notifier_hangup(hp, hp->data);
Christian Borntraeger611e0972008-06-20 15:24:08 +0200430
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 while(temp_open_count) {
432 --temp_open_count;
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800433 kref_put(&hp->kref, destroy_hvc_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 }
435}
436
437/*
438 * Push buffered characters whether they were just recently buffered or waiting
439 * on a blocked hypervisor. Call this function with hp->lock held.
440 */
Hendrik Brueckner3feebbb2008-10-13 23:12:50 +0000441static int hvc_push(struct hvc_struct *hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
443 int n;
444
Milton Miller030ffad2005-07-07 17:56:25 -0700445 n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 if (n <= 0) {
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200447 if (n == 0) {
448 hp->do_wakeup = 1;
Hendrik Brueckner3feebbb2008-10-13 23:12:50 +0000449 return 0;
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 /* throw away output on error; this happens when
452 there is no session connected to the vterm. */
453 hp->n_outbuf = 0;
454 } else
455 hp->n_outbuf -= n;
456 if (hp->n_outbuf > 0)
457 memmove(hp->outbuf, hp->outbuf + n, hp->n_outbuf);
458 else
459 hp->do_wakeup = 1;
Hendrik Brueckner3feebbb2008-10-13 23:12:50 +0000460
461 return n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462}
463
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200464static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200466 struct hvc_struct *hp = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 unsigned long flags;
468 int rsize, written = 0;
469
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200470 /* This write was probably executed during a tty close. */
471 if (!hp)
472 return -EPIPE;
473
474 if (hp->count <= 0)
475 return -EIO;
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 spin_lock_irqsave(&hp->lock, flags);
478
479 /* Push pending writes */
480 if (hp->n_outbuf > 0)
481 hvc_push(hp);
482
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000483 while (count > 0 && (rsize = hp->outbuf_size - hp->n_outbuf) > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 if (rsize > count)
485 rsize = count;
486 memcpy(hp->outbuf + hp->n_outbuf, buf, rsize);
487 count -= rsize;
488 buf += rsize;
489 hp->n_outbuf += rsize;
490 written += rsize;
491 hvc_push(hp);
492 }
493 spin_unlock_irqrestore(&hp->lock, flags);
494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 /*
496 * Racy, but harmless, kick thread if there is still pending data.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 */
498 if (hp->n_outbuf)
499 hvc_kick();
500
501 return written;
502}
503
Hendrik Bruecknerfebde372008-10-14 05:02:09 +0000504/**
505 * hvc_set_winsz() - Resize the hvc tty terminal window.
506 * @work: work structure.
507 *
508 * The routine shall not be called within an atomic context because it
509 * might sleep.
510 *
511 * Locking: hp->lock
512 */
513static void hvc_set_winsz(struct work_struct *work)
514{
515 struct hvc_struct *hp;
516 unsigned long hvc_flags;
517 struct tty_struct *tty;
518 struct winsize ws;
519
520 hp = container_of(work, struct hvc_struct, tty_resize);
521 if (!hp)
522 return;
523
524 spin_lock_irqsave(&hp->lock, hvc_flags);
525 if (!hp->tty) {
526 spin_unlock_irqrestore(&hp->lock, hvc_flags);
527 return;
528 }
529 ws = hp->ws;
530 tty = tty_kref_get(hp->tty);
531 spin_unlock_irqrestore(&hp->lock, hvc_flags);
532
Alan Coxfc6f6232009-01-02 13:43:17 +0000533 tty_do_resize(tty, &ws);
Hendrik Bruecknerfebde372008-10-14 05:02:09 +0000534 tty_kref_put(tty);
535}
536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537/*
538 * This is actually a contract between the driver and the tty layer outlining
will schmidtc3ea6922007-04-18 00:54:51 +1000539 * how much write room the driver can guarantee will be sent OR BUFFERED. This
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 * driver MUST honor the return value.
541 */
542static int hvc_write_room(struct tty_struct *tty)
543{
544 struct hvc_struct *hp = tty->driver_data;
545
546 if (!hp)
547 return -1;
548
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000549 return hp->outbuf_size - hp->n_outbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550}
551
552static int hvc_chars_in_buffer(struct tty_struct *tty)
553{
554 struct hvc_struct *hp = tty->driver_data;
555
556 if (!hp)
557 return -1;
558 return hp->n_outbuf;
559}
560
Will Schmidtb7910722007-04-18 00:44:46 +1000561/*
562 * timeout will vary between the MIN and MAX values defined here. By default
563 * and during console activity we will use a default MIN_TIMEOUT of 10. When
564 * the console is idle, we increase the timeout value on each pass through
565 * msleep until we reach the max. This may be noticeable as a brief (average
566 * one second) delay on the console before the console responds to input when
567 * there has been no input for some time.
568 */
569#define MIN_TIMEOUT (10)
570#define MAX_TIMEOUT (2000)
571static u32 timeout = MIN_TIMEOUT;
572
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573#define HVC_POLL_READ 0x00000001
574#define HVC_POLL_WRITE 0x00000002
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Christian Borntraeger611e0972008-06-20 15:24:08 +0200576int hvc_poll(struct hvc_struct *hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577{
578 struct tty_struct *tty;
579 int i, n, poll_mask = 0;
580 char buf[N_INBUF] __ALIGNED__;
581 unsigned long flags;
582 int read_total = 0;
Hendrik Brueckner3feebbb2008-10-13 23:12:50 +0000583 int written_total = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
585 spin_lock_irqsave(&hp->lock, flags);
586
587 /* Push pending writes */
588 if (hp->n_outbuf > 0)
Hendrik Brueckner3feebbb2008-10-13 23:12:50 +0000589 written_total = hvc_push(hp);
Michael Ellermanb5374462006-06-07 17:10:03 +1000590
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 /* Reschedule us if still some write pending */
Hendrik Brueckner3feebbb2008-10-13 23:12:50 +0000592 if (hp->n_outbuf > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 poll_mask |= HVC_POLL_WRITE;
Hendrik Brueckner3feebbb2008-10-13 23:12:50 +0000594 /* If hvc_push() was not able to write, sleep a few msecs */
595 timeout = (written_total) ? 0 : MIN_TIMEOUT;
596 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 /* No tty attached, just skip */
599 tty = hp->tty;
600 if (tty == NULL)
601 goto bail;
602
603 /* Now check if we can get data (are we throttled ?) */
604 if (test_bit(TTY_THROTTLED, &tty->flags))
605 goto throttled;
606
Christian Borntraeger611e0972008-06-20 15:24:08 +0200607 /* If we aren't notifier driven and aren't throttled, we always
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 * request a reschedule
609 */
Christian Borntraeger611e0972008-06-20 15:24:08 +0200610 if (!hp->irq_requested)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 poll_mask |= HVC_POLL_READ;
612
613 /* Read data if any */
614 for (;;) {
Alan Cox33f0f882006-01-09 20:54:13 -0800615 int count = tty_buffer_request_room(tty, N_INBUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 /* If flip is full, just reschedule a later read */
618 if (count == 0) {
619 poll_mask |= HVC_POLL_READ;
620 break;
621 }
622
Milton Miller030ffad2005-07-07 17:56:25 -0700623 n = hp->ops->get_chars(hp->vtermno, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 if (n <= 0) {
625 /* Hangup the tty when disconnected from host */
626 if (n == -EPIPE) {
627 spin_unlock_irqrestore(&hp->lock, flags);
628 tty_hangup(tty);
629 spin_lock_irqsave(&hp->lock, flags);
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200630 } else if ( n == -EAGAIN ) {
631 /*
632 * Some back-ends can only ensure a certain min
633 * num of bytes read, which may be > 'count'.
634 * Let the tty clear the flip buff to make room.
635 */
636 poll_mask |= HVC_POLL_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 }
638 break;
639 }
640 for (i = 0; i < n; ++i) {
641#ifdef CONFIG_MAGIC_SYSRQ
Milton Miller2b9e0ba2005-07-07 17:56:19 -0700642 if (hp->index == hvc_con_driver.index) {
643 /* Handle the SysRq Hack */
644 /* XXX should support a sequence */
645 if (buf[i] == '\x0f') { /* ^O */
Hendrik Brueckner368c1e32008-12-16 00:09:38 +0000646 /* if ^O is pressed again, reset
647 * sysrq_pressed and flip ^O char */
648 sysrq_pressed = !sysrq_pressed;
649 if (sysrq_pressed)
650 continue;
Milton Miller2b9e0ba2005-07-07 17:56:19 -0700651 } else if (sysrq_pressed) {
David Howells7d12e782006-10-05 14:55:46 +0100652 handle_sysrq(buf[i], tty);
Milton Miller2b9e0ba2005-07-07 17:56:19 -0700653 sysrq_pressed = 0;
654 continue;
655 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 }
657#endif /* CONFIG_MAGIC_SYSRQ */
658 tty_insert_flip_char(tty, buf[i], 0);
659 }
660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 read_total += n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 }
663 throttled:
664 /* Wakeup write queue if necessary */
665 if (hp->do_wakeup) {
666 hp->do_wakeup = 0;
667 tty_wakeup(tty);
668 }
669 bail:
670 spin_unlock_irqrestore(&hp->lock, flags);
671
Will Schmidtb7910722007-04-18 00:44:46 +1000672 if (read_total) {
673 /* Activity is occurring, so reset the polling backoff value to
674 a minimum for performance. */
675 timeout = MIN_TIMEOUT;
676
Michal Ostrowskifb5c5942006-02-18 09:29:59 -0500677 tty_flip_buffer_push(tty);
Will Schmidtb7910722007-04-18 00:44:46 +1000678 }
679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return poll_mask;
681}
Christian Borntraeger7721c492008-07-25 12:06:06 -0500682EXPORT_SYMBOL_GPL(hvc_poll);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
Hendrik Bruecknerfebde372008-10-14 05:02:09 +0000684/**
685 * hvc_resize() - Update terminal window size information.
686 * @hp: HVC console pointer
687 * @ws: Terminal window size structure
688 *
689 * Stores the specified window size information in the hvc structure of @hp.
690 * The function schedule the tty resize update.
691 *
692 * Locking: Locking free; the function MUST be called holding hp->lock
693 */
694void hvc_resize(struct hvc_struct *hp, struct winsize ws)
695{
Hendrik Brueckner7947cf02008-11-18 01:28:28 +0000696 hp->ws = ws;
697 schedule_work(&hp->tty_resize);
Hendrik Bruecknerfebde372008-10-14 05:02:09 +0000698}
Christian Borntraegerc2983452008-11-25 13:36:26 +0100699EXPORT_SYMBOL_GPL(hvc_resize);
Hendrik Bruecknerfebde372008-10-14 05:02:09 +0000700
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701/*
702 * This kthread is either polling or interrupt driven. This is determined by
703 * calling hvc_poll() who determines whether a console adapter support
704 * interrupts.
705 */
Adrian Bunk5605d4d2007-07-09 11:37:38 -0700706static int khvcd(void *unused)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
708 int poll_mask;
709 struct hvc_struct *hp;
710
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700711 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 __set_current_state(TASK_RUNNING);
713 do {
714 poll_mask = 0;
715 hvc_kicked = 0;
Andrew Mortonb64074e2006-09-16 12:15:38 -0700716 try_to_freeze();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 wmb();
Michael Ellerman1c8950f2008-05-08 14:27:17 +1000718 if (!cpus_are_in_xmon()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 spin_lock(&hvc_structs_lock);
720 list_for_each_entry(hp, &hvc_structs, next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 poll_mask |= hvc_poll(hp);
722 }
723 spin_unlock(&hvc_structs_lock);
724 } else
725 poll_mask |= HVC_POLL_READ;
726 if (hvc_kicked)
727 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 set_current_state(TASK_INTERRUPTIBLE);
729 if (!hvc_kicked) {
730 if (poll_mask == 0)
731 schedule();
Will Schmidtb7910722007-04-18 00:44:46 +1000732 else {
733 if (timeout < MAX_TIMEOUT)
734 timeout += (timeout >> 6) + 1;
735
736 msleep_interruptible(timeout);
737 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 }
739 __set_current_state(TASK_RUNNING);
740 } while (!kthread_should_stop());
741
742 return 0;
743}
744
Jeff Dikeb68e31d2006-10-02 02:17:18 -0700745static const struct tty_operations hvc_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 .open = hvc_open,
747 .close = hvc_close,
748 .write = hvc_write,
749 .hangup = hvc_hangup,
750 .unthrottle = hvc_unthrottle,
751 .write_room = hvc_write_room,
752 .chars_in_buffer = hvc_chars_in_buffer,
753};
754
Christian Borntraeger611e0972008-06-20 15:24:08 +0200755struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int data,
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000756 struct hv_ops *ops, int outbuf_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757{
758 struct hvc_struct *hp;
Milton Miller6f248082005-07-07 17:56:17 -0700759 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700761 /* We wait until a driver actually comes along */
762 if (!hvc_driver) {
763 int err = hvc_init();
764 if (err)
765 return ERR_PTR(err);
766 }
767
Milton Miller2da75822009-01-08 02:14:28 +0000768 hp = kzalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000769 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 if (!hp)
Milton Milleracad9552005-07-07 17:56:24 -0700771 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Milton Milleracad9552005-07-07 17:56:24 -0700773 hp->vtermno = vtermno;
Christian Borntraeger611e0972008-06-20 15:24:08 +0200774 hp->data = data;
Milton Miller030ffad2005-07-07 17:56:25 -0700775 hp->ops = ops;
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000776 hp->outbuf_size = outbuf_size;
777 hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800779 kref_init(&hp->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Hendrik Bruecknerfebde372008-10-14 05:02:09 +0000781 INIT_WORK(&hp->tty_resize, hvc_set_winsz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 spin_lock_init(&hp->lock);
783 spin_lock(&hvc_structs_lock);
Milton Miller6f248082005-07-07 17:56:17 -0700784
785 /*
786 * find index to use:
787 * see if this vterm id matches one registered for console.
788 */
789 for (i=0; i < MAX_NR_HVC_CONSOLES; i++)
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200790 if (vtermnos[i] == hp->vtermno &&
791 cons_ops[i] == hp->ops)
Milton Miller6f248082005-07-07 17:56:17 -0700792 break;
793
794 /* no matching slot, just use a counter */
795 if (i >= MAX_NR_HVC_CONSOLES)
796 i = ++last_hvc;
797
798 hp->index = i;
799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 list_add_tail(&(hp->next), &hvc_structs);
801 spin_unlock(&hvc_structs_lock);
802
Milton Milleracad9552005-07-07 17:56:24 -0700803 return hp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
Christian Borntraeger7721c492008-07-25 12:06:06 -0500805EXPORT_SYMBOL_GPL(hvc_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
Hendrik Brueckner934752d2008-10-13 23:12:52 +0000807int hvc_remove(struct hvc_struct *hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 struct tty_struct *tty;
811
812 spin_lock_irqsave(&hp->lock, flags);
813 tty = hp->tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
815 if (hp->index < MAX_NR_HVC_CONSOLES)
816 vtermnos[hp->index] = -1;
817
818 /* Don't whack hp->irq because tty_hangup() will need to free the irq. */
819
820 spin_unlock_irqrestore(&hp->lock, flags);
821
822 /*
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800823 * We 'put' the instance that was grabbed when the kref instance
824 * was initialized using kref_init(). Let the last holder of this
825 * kref cause it to be removed, which will probably be the tty_hangup
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 * below.
827 */
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800828 kref_put(&hp->kref, destroy_hvc_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830 /*
831 * This function call will auto chain call hvc_hangup. The tty should
832 * always be valid at this time unless a simultaneous tty close already
833 * cleaned up the hvc_struct.
834 */
835 if (tty)
836 tty_hangup(tty);
837 return 0;
838}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700840/* Driver initialization: called as soon as someone uses hvc_alloc(). */
841static int hvc_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
Michael Neuling55aab8c2006-03-25 17:30:00 +1100843 struct tty_driver *drv;
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700844 int err;
Michael Neuling55aab8c2006-03-25 17:30:00 +1100845
Milton Miller5f6d9c02005-07-07 17:56:21 -0700846 /* We need more than hvc_count adapters due to hotplug additions. */
Michael Neuling55aab8c2006-03-25 17:30:00 +1100847 drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS);
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700848 if (!drv) {
849 err = -ENOMEM;
850 goto out;
851 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Michael Neuling55aab8c2006-03-25 17:30:00 +1100853 drv->owner = THIS_MODULE;
Michael Neuling55aab8c2006-03-25 17:30:00 +1100854 drv->driver_name = "hvc";
855 drv->name = "hvc";
856 drv->major = HVC_MAJOR;
857 drv->minor_start = HVC_MINOR;
858 drv->type = TTY_DRIVER_TYPE_SYSTEM;
859 drv->init_termios = tty_std_termios;
Hendrik Brueckner56ce9e22008-10-13 23:12:49 +0000860 drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
Michael Neuling55aab8c2006-03-25 17:30:00 +1100861 tty_set_operations(drv, &hvc_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 /* Always start the kthread because there can be hotplug vty adapters
864 * added later. */
865 hvc_task = kthread_run(khvcd, NULL, "khvcd");
866 if (IS_ERR(hvc_task)) {
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700867 printk(KERN_ERR "Couldn't create kthread for console.\n");
868 err = PTR_ERR(hvc_task);
869 goto put_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 }
871
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700872 err = tty_register_driver(drv);
873 if (err) {
874 printk(KERN_ERR "Couldn't register hvc console driver\n");
875 goto stop_thread;
876 }
Anton Blanchardef4cbee2005-09-14 14:19:18 -0700877
Milton Miller9fef3d22009-01-08 02:14:18 +0000878 /*
879 * Make sure tty is fully registered before allowing it to be
880 * found by hvc_console_device.
881 */
882 smp_mb();
Michael Neuling55aab8c2006-03-25 17:30:00 +1100883 hvc_driver = drv;
Milton Milleracad9552005-07-07 17:56:24 -0700884 return 0;
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700885
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700886stop_thread:
887 kthread_stop(hvc_task);
888 hvc_task = NULL;
Julia Lawall2571cd6a2008-10-13 10:31:49 +0100889put_tty:
890 put_tty_driver(drv);
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700891out:
892 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893}
894
will schmidtc3ea6922007-04-18 00:54:51 +1000895/* This isn't particularly necessary due to this being a console driver
Milton Miller320da0d2005-07-07 17:56:20 -0700896 * but it is nice to be thorough.
897 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898static void __exit hvc_exit(void)
899{
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700900 if (hvc_driver) {
901 kthread_stop(hvc_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700903 tty_unregister_driver(hvc_driver);
904 /* return tty_struct instances allocated in hvc_init(). */
905 put_tty_driver(hvc_driver);
906 unregister_console(&hvc_con_driver);
907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909module_exit(hvc_exit);