blob: 44160d5ebca06dbcd7e300c9835cbeb1763c1a4c [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>
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -080030#include <linux/kref.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/kthread.h>
32#include <linux/list.h>
33#include <linux/module.h>
34#include <linux/major.h>
35#include <linux/sysrq.h>
36#include <linux/tty.h>
37#include <linux/tty_flip.h>
38#include <linux/sched.h>
39#include <linux/spinlock.h>
40#include <linux/delay.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080041#include <linux/freezer.h>
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020042
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <asm/uaccess.h>
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020044
45#include "hvc_console.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#define HVC_MAJOR 229
48#define HVC_MINOR 0
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050/*
51 * Wait this long per iteration while trying to push buffered data to the
52 * hypervisor before allowing the tty to complete a close operation.
53 */
54#define HVC_CLOSE_WAIT (HZ/100) /* 1/10 of a second */
55
56/*
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020057 * These sizes are most efficient for vio, because they are the
58 * native transfer size. We could make them selectable in the
59 * future to better deal with backends that want other buffer sizes.
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#define N_OUTBUF 16
62#define N_INBUF 16
63
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020064#define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Milton Miller837dcfa2005-07-07 17:56:16 -070066static struct tty_driver *hvc_driver;
67static struct task_struct *hvc_task;
68
69/* Picks up late kicks after list walk but before schedule() */
70static int hvc_kicked;
71
Rusty Russell3e6c6f62007-10-16 23:30:13 -070072static int hvc_init(void);
73
Milton Miller837dcfa2005-07-07 17:56:16 -070074#ifdef CONFIG_MAGIC_SYSRQ
75static int sysrq_pressed;
76#endif
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078struct hvc_struct {
79 spinlock_t lock;
80 int index;
81 struct tty_struct *tty;
82 unsigned int count;
83 int do_wakeup;
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +100084 char *outbuf;
85 int outbuf_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 int n_outbuf;
87 uint32_t vtermno;
Milton Miller030ffad2005-07-07 17:56:25 -070088 struct hv_ops *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 int irq_requested;
90 int irq;
91 struct list_head next;
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -080092 struct kref kref; /* ref count & hvc_struct lifetime */
Linus Torvalds1da177e2005-04-16 15:20:36 -070093};
94
95/* dynamic list of hvc_struct instances */
Denis Chengbed97592008-02-06 01:37:35 -080096static LIST_HEAD(hvc_structs);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98/*
99 * Protect the list of hvc_struct instances from inserts and removals during
100 * list traversal.
101 */
102static DEFINE_SPINLOCK(hvc_structs_lock);
103
104/*
Milton Miller6f248082005-07-07 17:56:17 -0700105 * This value is used to assign a tty->index value to a hvc_struct based
106 * upon order of exposure via hvc_probe(), when we can not match it to
will schmidtc3ea6922007-04-18 00:54:51 +1000107 * a console candidate registered with hvc_instantiate().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 */
Milton Miller6f248082005-07-07 17:56:17 -0700109static int last_hvc = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111/*
will schmidtc3ea6922007-04-18 00:54:51 +1000112 * Do not call this function with either the hvc_structs_lock or the hvc_struct
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800113 * lock held. If successful, this function increments the kref reference
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 * count against the target hvc_struct so it should be released when finished.
115 */
Adrian Bunk4fa156e2007-05-08 00:24:24 -0700116static struct hvc_struct *hvc_get_by_index(int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
118 struct hvc_struct *hp;
119 unsigned long flags;
120
121 spin_lock(&hvc_structs_lock);
122
123 list_for_each_entry(hp, &hvc_structs, next) {
124 spin_lock_irqsave(&hp->lock, flags);
125 if (hp->index == index) {
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800126 kref_get(&hp->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 spin_unlock_irqrestore(&hp->lock, flags);
128 spin_unlock(&hvc_structs_lock);
129 return hp;
130 }
131 spin_unlock_irqrestore(&hp->lock, flags);
132 }
133 hp = NULL;
134
135 spin_unlock(&hvc_structs_lock);
136 return hp;
137}
138
Milton Miller837dcfa2005-07-07 17:56:16 -0700139
140/*
141 * Initial console vtermnos for console API usage prior to full console
142 * initialization. Any vty adapter outside this range will not have usable
143 * console interfaces but can still be used as a tty device. This has to be
144 * static because kmalloc will not work during early console init.
145 */
Milton Miller030ffad2005-07-07 17:56:25 -0700146static struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
Milton Miller64e4da52005-07-07 17:56:22 -0700147static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
148 {[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
Milton Miller837dcfa2005-07-07 17:56:16 -0700149
150/*
151 * Console APIs, NOT TTY. These APIs are available immediately when
152 * hvc_console_setup() finds adapters.
153 */
154
Adrian Bunk4fa156e2007-05-08 00:24:24 -0700155static void hvc_console_print(struct console *co, const char *b,
156 unsigned count)
Milton Miller837dcfa2005-07-07 17:56:16 -0700157{
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200158 char c[N_OUTBUF] __ALIGNED__;
Milton Miller837dcfa2005-07-07 17:56:16 -0700159 unsigned i = 0, n = 0;
Milton Miller030ffad2005-07-07 17:56:25 -0700160 int r, donecr = 0, index = co->index;
Milton Miller837dcfa2005-07-07 17:56:16 -0700161
162 /* Console access attempt outside of acceptable console range. */
Milton Miller030ffad2005-07-07 17:56:25 -0700163 if (index >= MAX_NR_HVC_CONSOLES)
Milton Miller837dcfa2005-07-07 17:56:16 -0700164 return;
165
will schmidtc3ea6922007-04-18 00:54:51 +1000166 /* This console adapter was removed so it is not usable. */
Milton Miller030ffad2005-07-07 17:56:25 -0700167 if (vtermnos[index] < 0)
Milton Miller837dcfa2005-07-07 17:56:16 -0700168 return;
169
170 while (count > 0 || i > 0) {
171 if (count > 0 && i < sizeof(c)) {
172 if (b[n] == '\n' && !donecr) {
173 c[i++] = '\r';
174 donecr = 1;
175 } else {
176 c[i++] = b[n++];
177 donecr = 0;
178 --count;
179 }
180 } else {
Milton Miller030ffad2005-07-07 17:56:25 -0700181 r = cons_ops[index]->put_chars(vtermnos[index], c, i);
Milton Miller837dcfa2005-07-07 17:56:16 -0700182 if (r < 0) {
183 /* throw away chars on error */
184 i = 0;
185 } else if (r > 0) {
186 i -= r;
187 if (i > 0)
188 memmove(c, c+r, i);
189 }
190 }
191 }
192}
193
194static struct tty_driver *hvc_console_device(struct console *c, int *index)
195{
Milton Miller7805b1b2005-07-07 17:56:23 -0700196 if (vtermnos[c->index] == -1)
197 return NULL;
198
Milton Miller837dcfa2005-07-07 17:56:16 -0700199 *index = c->index;
200 return hvc_driver;
201}
202
203static int __init hvc_console_setup(struct console *co, char *options)
204{
Milton Miller7805b1b2005-07-07 17:56:23 -0700205 if (co->index < 0 || co->index >= MAX_NR_HVC_CONSOLES)
206 return -ENODEV;
207
208 if (vtermnos[co->index] == -1)
209 return -ENODEV;
210
Milton Miller837dcfa2005-07-07 17:56:16 -0700211 return 0;
212}
213
Adrian Bunk4fa156e2007-05-08 00:24:24 -0700214static struct console hvc_con_driver = {
Milton Miller837dcfa2005-07-07 17:56:16 -0700215 .name = "hvc",
216 .write = hvc_console_print,
217 .device = hvc_console_device,
218 .setup = hvc_console_setup,
219 .flags = CON_PRINTBUFFER,
220 .index = -1,
221};
222
Milton Millerd5ee2572005-07-07 17:56:24 -0700223/*
will schmidtc3ea6922007-04-18 00:54:51 +1000224 * Early console initialization. Precedes driver initialization.
Milton Millerd5ee2572005-07-07 17:56:24 -0700225 *
226 * (1) we are first, and the user specified another driver
227 * -- index will remain -1
228 * (2) we are first and the user specified no driver
229 * -- index will be set to 0, then we will fail setup.
230 * (3) we are first and the user specified our driver
231 * -- index will be set to user specified driver, and we will fail
232 * (4) we are after driver, and this initcall will register us
233 * -- if the user didn't specify a driver then the console will match
234 *
235 * Note that for cases 2 and 3, we will match later when the io driver
236 * calls hvc_instantiate() and call register again.
237 */
Milton Miller837dcfa2005-07-07 17:56:16 -0700238static int __init hvc_console_init(void)
239{
Milton Miller837dcfa2005-07-07 17:56:16 -0700240 register_console(&hvc_con_driver);
241 return 0;
242}
243console_initcall(hvc_console_init);
244
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800245/* callback when the kboject ref count reaches zero. */
246static void destroy_hvc_struct(struct kref *kref)
247{
248 struct hvc_struct *hp = container_of(kref, struct hvc_struct, kref);
249 unsigned long flags;
250
251 spin_lock(&hvc_structs_lock);
252
253 spin_lock_irqsave(&hp->lock, flags);
254 list_del(&(hp->next));
255 spin_unlock_irqrestore(&hp->lock, flags);
256
257 spin_unlock(&hvc_structs_lock);
258
259 kfree(hp);
260}
261
Milton Miller837dcfa2005-07-07 17:56:16 -0700262/*
Milton Miller6f248082005-07-07 17:56:17 -0700263 * hvc_instantiate() is an early console discovery method which locates
264 * consoles * prior to the vio subsystem discovering them. Hotplugged
265 * vty adapters do NOT get an hvc_instantiate() callback since they
266 * appear after early console init.
Milton Miller837dcfa2005-07-07 17:56:16 -0700267 */
Milton Miller030ffad2005-07-07 17:56:25 -0700268int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops)
Milton Miller837dcfa2005-07-07 17:56:16 -0700269{
Milton Miller7805b1b2005-07-07 17:56:23 -0700270 struct hvc_struct *hp;
271
Milton Miller837dcfa2005-07-07 17:56:16 -0700272 if (index < 0 || index >= MAX_NR_HVC_CONSOLES)
273 return -1;
274
275 if (vtermnos[index] != -1)
276 return -1;
277
will schmidtc3ea6922007-04-18 00:54:51 +1000278 /* make sure no no tty has been registered in this index */
Milton Miller7805b1b2005-07-07 17:56:23 -0700279 hp = hvc_get_by_index(index);
280 if (hp) {
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800281 kref_put(&hp->kref, destroy_hvc_struct);
Milton Miller7805b1b2005-07-07 17:56:23 -0700282 return -1;
283 }
284
Milton Miller837dcfa2005-07-07 17:56:16 -0700285 vtermnos[index] = vtermno;
Milton Miller030ffad2005-07-07 17:56:25 -0700286 cons_ops[index] = ops;
Milton Miller6f248082005-07-07 17:56:17 -0700287
will schmidtc3ea6922007-04-18 00:54:51 +1000288 /* reserve all indices up to and including this index */
Milton Miller6f248082005-07-07 17:56:17 -0700289 if (last_hvc < index)
290 last_hvc = index;
291
Milton Millerd5ee2572005-07-07 17:56:24 -0700292 /* if this index is what the user requested, then register
293 * now (setup won't fail at this point). It's ok to just
294 * call register again if previously .setup failed.
295 */
296 if (index == hvc_con_driver.index)
297 register_console(&hvc_con_driver);
298
Milton Miller837dcfa2005-07-07 17:56:16 -0700299 return 0;
300}
301
302/* Wake the sleeping khvcd */
303static void hvc_kick(void)
304{
305 hvc_kicked = 1;
306 wake_up_process(hvc_task);
307}
308
Milton Miller8b67f8c2005-07-07 17:56:18 -0700309static int hvc_poll(struct hvc_struct *hp);
310
Milton Miller837dcfa2005-07-07 17:56:16 -0700311/*
312 * NOTE: This API isn't used if the console adapter doesn't support interrupts.
313 * In this case the console is poll driven.
314 */
David Howells7d12e782006-10-05 14:55:46 +0100315static irqreturn_t hvc_handle_interrupt(int irq, void *dev_instance)
Milton Miller837dcfa2005-07-07 17:56:16 -0700316{
Milton Miller8b67f8c2005-07-07 17:56:18 -0700317 /* if hvc_poll request a repoll, then kick the hvcd thread */
318 if (hvc_poll(dev_instance))
319 hvc_kick();
Milton Miller837dcfa2005-07-07 17:56:16 -0700320 return IRQ_HANDLED;
321}
322
323static void hvc_unthrottle(struct tty_struct *tty)
324{
325 hvc_kick();
326}
327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328/*
329 * The TTY interface won't be used until after the vio layer has exposed the vty
330 * adapter to the kernel.
331 */
332static int hvc_open(struct tty_struct *tty, struct file * filp)
333{
334 struct hvc_struct *hp;
335 unsigned long flags;
Rusty Russell8cd0ae02007-02-23 14:12:02 +1100336 int irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800339 /* Auto increments kref reference if found. */
Olof Johansson87fd7722006-09-07 15:18:08 -0500340 if (!(hp = hvc_get_by_index(tty->index)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
343 spin_lock_irqsave(&hp->lock, flags);
344 /* Check and then increment for fast path open. */
345 if (hp->count++ > 0) {
346 spin_unlock_irqrestore(&hp->lock, flags);
347 hvc_kick();
348 return 0;
349 } /* else count == 0 */
350
351 tty->driver_data = hp;
Michal Ostrowskifb5c5942006-02-18 09:29:59 -0500352 tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 hp->tty = tty;
355 /* Save for request_irq outside of spin_lock. */
356 irq = hp->irq;
Rusty Russell8cd0ae02007-02-23 14:12:02 +1100357 if (irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 hp->irq_requested = 1;
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 spin_unlock_irqrestore(&hp->lock, flags);
361 /* check error, fallback to non-irq */
Rusty Russell8cd0ae02007-02-23 14:12:02 +1100362 if (irq)
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -0700363 rc = request_irq(irq, hvc_handle_interrupt, IRQF_DISABLED, "hvc_console", hp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
365 /*
366 * If the request_irq() fails and we return an error. The tty layer
367 * will call hvc_close() after a failed open but we don't want to clean
368 * up there so we'll clean up here and clear out the previously set
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800369 * tty fields and return the kref reference.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 */
371 if (rc) {
372 spin_lock_irqsave(&hp->lock, flags);
373 hp->tty = NULL;
374 hp->irq_requested = 0;
375 spin_unlock_irqrestore(&hp->lock, flags);
376 tty->driver_data = NULL;
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800377 kref_put(&hp->kref, destroy_hvc_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 printk(KERN_ERR "hvc_open: request_irq failed with rc %d.\n", rc);
379 }
380 /* Force wakeup of the polling thread */
381 hvc_kick();
382
383 return rc;
384}
385
386static void hvc_close(struct tty_struct *tty, struct file * filp)
387{
388 struct hvc_struct *hp;
Rusty Russell8cd0ae02007-02-23 14:12:02 +1100389 int irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 unsigned long flags;
391
392 if (tty_hung_up_p(filp))
393 return;
394
395 /*
396 * No driver_data means that this close was issued after a failed
397 * hvc_open by the tty layer's release_dev() function and we can just
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800398 * exit cleanly because the kref reference wasn't made.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 */
400 if (!tty->driver_data)
401 return;
402
403 hp = tty->driver_data;
404 spin_lock_irqsave(&hp->lock, flags);
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 if (--hp->count == 0) {
407 if (hp->irq_requested)
408 irq = hp->irq;
409 hp->irq_requested = 0;
410
411 /* We are done with the tty pointer now. */
412 hp->tty = NULL;
413 spin_unlock_irqrestore(&hp->lock, flags);
414
415 /*
416 * Chain calls chars_in_buffer() and returns immediately if
417 * there is no buffered data otherwise sleeps on a wait queue
418 * waking periodically to check chars_in_buffer().
419 */
420 tty_wait_until_sent(tty, HVC_CLOSE_WAIT);
421
Rusty Russell8cd0ae02007-02-23 14:12:02 +1100422 if (irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 free_irq(irq, hp);
424
425 } else {
426 if (hp->count < 0)
427 printk(KERN_ERR "hvc_close %X: oops, count is %d\n",
428 hp->vtermno, hp->count);
429 spin_unlock_irqrestore(&hp->lock, flags);
430 }
431
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800432 kref_put(&hp->kref, destroy_hvc_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433}
434
435static void hvc_hangup(struct tty_struct *tty)
436{
437 struct hvc_struct *hp = tty->driver_data;
438 unsigned long flags;
Rusty Russell8cd0ae02007-02-23 14:12:02 +1100439 int irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 int temp_open_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 if (!hp)
443 return;
444
445 spin_lock_irqsave(&hp->lock, flags);
446
447 /*
448 * The N_TTY line discipline has problems such that in a close vs
449 * open->hangup case this can be called after the final close so prevent
450 * that from happening for now.
451 */
452 if (hp->count <= 0) {
453 spin_unlock_irqrestore(&hp->lock, flags);
454 return;
455 }
456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 temp_open_count = hp->count;
458 hp->count = 0;
459 hp->n_outbuf = 0;
460 hp->tty = NULL;
461 if (hp->irq_requested)
462 /* Saved for use outside of spin_lock. */
463 irq = hp->irq;
464 hp->irq_requested = 0;
465 spin_unlock_irqrestore(&hp->lock, flags);
Rusty Russell8cd0ae02007-02-23 14:12:02 +1100466 if (irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 free_irq(irq, hp);
468 while(temp_open_count) {
469 --temp_open_count;
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800470 kref_put(&hp->kref, destroy_hvc_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 }
472}
473
474/*
475 * Push buffered characters whether they were just recently buffered or waiting
476 * on a blocked hypervisor. Call this function with hp->lock held.
477 */
478static void hvc_push(struct hvc_struct *hp)
479{
480 int n;
481
Milton Miller030ffad2005-07-07 17:56:25 -0700482 n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 if (n <= 0) {
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200484 if (n == 0) {
485 hp->do_wakeup = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 return;
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200487 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 /* throw away output on error; this happens when
489 there is no session connected to the vterm. */
490 hp->n_outbuf = 0;
491 } else
492 hp->n_outbuf -= n;
493 if (hp->n_outbuf > 0)
494 memmove(hp->outbuf, hp->outbuf + n, hp->n_outbuf);
495 else
496 hp->do_wakeup = 1;
497}
498
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200499static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200501 struct hvc_struct *hp = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 unsigned long flags;
503 int rsize, written = 0;
504
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200505 /* This write was probably executed during a tty close. */
506 if (!hp)
507 return -EPIPE;
508
509 if (hp->count <= 0)
510 return -EIO;
511
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 spin_lock_irqsave(&hp->lock, flags);
513
514 /* Push pending writes */
515 if (hp->n_outbuf > 0)
516 hvc_push(hp);
517
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000518 while (count > 0 && (rsize = hp->outbuf_size - hp->n_outbuf) > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 if (rsize > count)
520 rsize = count;
521 memcpy(hp->outbuf + hp->n_outbuf, buf, rsize);
522 count -= rsize;
523 buf += rsize;
524 hp->n_outbuf += rsize;
525 written += rsize;
526 hvc_push(hp);
527 }
528 spin_unlock_irqrestore(&hp->lock, flags);
529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 /*
531 * Racy, but harmless, kick thread if there is still pending data.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 */
533 if (hp->n_outbuf)
534 hvc_kick();
535
536 return written;
537}
538
539/*
540 * This is actually a contract between the driver and the tty layer outlining
will schmidtc3ea6922007-04-18 00:54:51 +1000541 * how much write room the driver can guarantee will be sent OR BUFFERED. This
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 * driver MUST honor the return value.
543 */
544static int hvc_write_room(struct tty_struct *tty)
545{
546 struct hvc_struct *hp = tty->driver_data;
547
548 if (!hp)
549 return -1;
550
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000551 return hp->outbuf_size - hp->n_outbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552}
553
554static int hvc_chars_in_buffer(struct tty_struct *tty)
555{
556 struct hvc_struct *hp = tty->driver_data;
557
558 if (!hp)
559 return -1;
560 return hp->n_outbuf;
561}
562
Will Schmidtb7910722007-04-18 00:44:46 +1000563/*
564 * timeout will vary between the MIN and MAX values defined here. By default
565 * and during console activity we will use a default MIN_TIMEOUT of 10. When
566 * the console is idle, we increase the timeout value on each pass through
567 * msleep until we reach the max. This may be noticeable as a brief (average
568 * one second) delay on the console before the console responds to input when
569 * there has been no input for some time.
570 */
571#define MIN_TIMEOUT (10)
572#define MAX_TIMEOUT (2000)
573static u32 timeout = MIN_TIMEOUT;
574
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575#define HVC_POLL_READ 0x00000001
576#define HVC_POLL_WRITE 0x00000002
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578static int hvc_poll(struct hvc_struct *hp)
579{
580 struct tty_struct *tty;
581 int i, n, poll_mask = 0;
582 char buf[N_INBUF] __ALIGNED__;
583 unsigned long flags;
584 int read_total = 0;
585
586 spin_lock_irqsave(&hp->lock, flags);
587
588 /* Push pending writes */
589 if (hp->n_outbuf > 0)
590 hvc_push(hp);
Michael Ellermanb5374462006-06-07 17:10:03 +1000591
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 /* Reschedule us if still some write pending */
593 if (hp->n_outbuf > 0)
594 poll_mask |= HVC_POLL_WRITE;
595
596 /* No tty attached, just skip */
597 tty = hp->tty;
598 if (tty == NULL)
599 goto bail;
600
601 /* Now check if we can get data (are we throttled ?) */
602 if (test_bit(TTY_THROTTLED, &tty->flags))
603 goto throttled;
604
605 /* If we aren't interrupt driven and aren't throttled, we always
606 * request a reschedule
607 */
Rusty Russell8cd0ae02007-02-23 14:12:02 +1100608 if (hp->irq == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 poll_mask |= HVC_POLL_READ;
610
611 /* Read data if any */
612 for (;;) {
Alan Cox33f0f882006-01-09 20:54:13 -0800613 int count = tty_buffer_request_room(tty, N_INBUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 /* If flip is full, just reschedule a later read */
616 if (count == 0) {
617 poll_mask |= HVC_POLL_READ;
618 break;
619 }
620
Milton Miller030ffad2005-07-07 17:56:25 -0700621 n = hp->ops->get_chars(hp->vtermno, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 if (n <= 0) {
623 /* Hangup the tty when disconnected from host */
624 if (n == -EPIPE) {
625 spin_unlock_irqrestore(&hp->lock, flags);
626 tty_hangup(tty);
627 spin_lock_irqsave(&hp->lock, flags);
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200628 } else if ( n == -EAGAIN ) {
629 /*
630 * Some back-ends can only ensure a certain min
631 * num of bytes read, which may be > 'count'.
632 * Let the tty clear the flip buff to make room.
633 */
634 poll_mask |= HVC_POLL_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 }
636 break;
637 }
638 for (i = 0; i < n; ++i) {
639#ifdef CONFIG_MAGIC_SYSRQ
Milton Miller2b9e0ba2005-07-07 17:56:19 -0700640 if (hp->index == hvc_con_driver.index) {
641 /* Handle the SysRq Hack */
642 /* XXX should support a sequence */
643 if (buf[i] == '\x0f') { /* ^O */
644 sysrq_pressed = 1;
645 continue;
646 } else if (sysrq_pressed) {
David Howells7d12e782006-10-05 14:55:46 +0100647 handle_sysrq(buf[i], tty);
Milton Miller2b9e0ba2005-07-07 17:56:19 -0700648 sysrq_pressed = 0;
649 continue;
650 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 }
652#endif /* CONFIG_MAGIC_SYSRQ */
653 tty_insert_flip_char(tty, buf[i], 0);
654 }
655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 read_total += n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 }
658 throttled:
659 /* Wakeup write queue if necessary */
660 if (hp->do_wakeup) {
661 hp->do_wakeup = 0;
662 tty_wakeup(tty);
663 }
664 bail:
665 spin_unlock_irqrestore(&hp->lock, flags);
666
Will Schmidtb7910722007-04-18 00:44:46 +1000667 if (read_total) {
668 /* Activity is occurring, so reset the polling backoff value to
669 a minimum for performance. */
670 timeout = MIN_TIMEOUT;
671
Michal Ostrowskifb5c5942006-02-18 09:29:59 -0500672 tty_flip_buffer_push(tty);
Will Schmidtb7910722007-04-18 00:44:46 +1000673 }
674
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 return poll_mask;
676}
677
678#if defined(CONFIG_XMON) && defined(CONFIG_SMP)
679extern cpumask_t cpus_in_xmon;
680#else
681static const cpumask_t cpus_in_xmon = CPU_MASK_NONE;
682#endif
683
684/*
685 * This kthread is either polling or interrupt driven. This is determined by
686 * calling hvc_poll() who determines whether a console adapter support
687 * interrupts.
688 */
Adrian Bunk5605d4d2007-07-09 11:37:38 -0700689static int khvcd(void *unused)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690{
691 int poll_mask;
692 struct hvc_struct *hp;
693
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700694 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 __set_current_state(TASK_RUNNING);
696 do {
697 poll_mask = 0;
698 hvc_kicked = 0;
Andrew Mortonb64074e2006-09-16 12:15:38 -0700699 try_to_freeze();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 wmb();
701 if (cpus_empty(cpus_in_xmon)) {
702 spin_lock(&hvc_structs_lock);
703 list_for_each_entry(hp, &hvc_structs, next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 poll_mask |= hvc_poll(hp);
705 }
706 spin_unlock(&hvc_structs_lock);
707 } else
708 poll_mask |= HVC_POLL_READ;
709 if (hvc_kicked)
710 continue;
Michael Ellermanb5374462006-06-07 17:10:03 +1000711 if (poll_mask & HVC_POLL_WRITE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 yield();
713 continue;
714 }
715 set_current_state(TASK_INTERRUPTIBLE);
716 if (!hvc_kicked) {
717 if (poll_mask == 0)
718 schedule();
Will Schmidtb7910722007-04-18 00:44:46 +1000719 else {
720 if (timeout < MAX_TIMEOUT)
721 timeout += (timeout >> 6) + 1;
722
723 msleep_interruptible(timeout);
724 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 }
726 __set_current_state(TASK_RUNNING);
727 } while (!kthread_should_stop());
728
729 return 0;
730}
731
Jeff Dikeb68e31d2006-10-02 02:17:18 -0700732static const struct tty_operations hvc_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 .open = hvc_open,
734 .close = hvc_close,
735 .write = hvc_write,
736 .hangup = hvc_hangup,
737 .unthrottle = hvc_unthrottle,
738 .write_room = hvc_write_room,
739 .chars_in_buffer = hvc_chars_in_buffer,
740};
741
Milton Miller030ffad2005-07-07 17:56:25 -0700742struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int irq,
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000743 struct hv_ops *ops, int outbuf_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744{
745 struct hvc_struct *hp;
Milton Miller6f248082005-07-07 17:56:17 -0700746 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700748 /* We wait until a driver actually comes along */
749 if (!hvc_driver) {
750 int err = hvc_init();
751 if (err)
752 return ERR_PTR(err);
753 }
754
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000755 hp = kmalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
756 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 if (!hp)
Milton Milleracad9552005-07-07 17:56:24 -0700758 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760 memset(hp, 0x00, sizeof(*hp));
Milton Milleracad9552005-07-07 17:56:24 -0700761
762 hp->vtermno = vtermno;
763 hp->irq = irq;
Milton Miller030ffad2005-07-07 17:56:25 -0700764 hp->ops = ops;
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000765 hp->outbuf_size = outbuf_size;
766 hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800768 kref_init(&hp->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
770 spin_lock_init(&hp->lock);
771 spin_lock(&hvc_structs_lock);
Milton Miller6f248082005-07-07 17:56:17 -0700772
773 /*
774 * find index to use:
775 * see if this vterm id matches one registered for console.
776 */
777 for (i=0; i < MAX_NR_HVC_CONSOLES; i++)
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200778 if (vtermnos[i] == hp->vtermno &&
779 cons_ops[i] == hp->ops)
Milton Miller6f248082005-07-07 17:56:17 -0700780 break;
781
782 /* no matching slot, just use a counter */
783 if (i >= MAX_NR_HVC_CONSOLES)
784 i = ++last_hvc;
785
786 hp->index = i;
787
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 list_add_tail(&(hp->next), &hvc_structs);
789 spin_unlock(&hvc_structs_lock);
790
Milton Milleracad9552005-07-07 17:56:24 -0700791 return hp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792}
793
Milton Milleracad9552005-07-07 17:56:24 -0700794int __devexit hvc_remove(struct hvc_struct *hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 struct tty_struct *tty;
798
799 spin_lock_irqsave(&hp->lock, flags);
800 tty = hp->tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
802 if (hp->index < MAX_NR_HVC_CONSOLES)
803 vtermnos[hp->index] = -1;
804
805 /* Don't whack hp->irq because tty_hangup() will need to free the irq. */
806
807 spin_unlock_irqrestore(&hp->lock, flags);
808
809 /*
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800810 * We 'put' the instance that was grabbed when the kref instance
811 * was initialized using kref_init(). Let the last holder of this
812 * kref cause it to be removed, which will probably be the tty_hangup
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 * below.
814 */
Greg Kroah-Hartman12b20de2007-11-28 10:46:22 -0800815 kref_put(&hp->kref, destroy_hvc_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 /*
818 * This function call will auto chain call hvc_hangup. The tty should
819 * always be valid at this time unless a simultaneous tty close already
820 * cleaned up the hvc_struct.
821 */
822 if (tty)
823 tty_hangup(tty);
824 return 0;
825}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700827/* Driver initialization: called as soon as someone uses hvc_alloc(). */
828static int hvc_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829{
Michael Neuling55aab8c2006-03-25 17:30:00 +1100830 struct tty_driver *drv;
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700831 int err;
Michael Neuling55aab8c2006-03-25 17:30:00 +1100832
Milton Miller5f6d9c02005-07-07 17:56:21 -0700833 /* We need more than hvc_count adapters due to hotplug additions. */
Michael Neuling55aab8c2006-03-25 17:30:00 +1100834 drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS);
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700835 if (!drv) {
836 err = -ENOMEM;
837 goto out;
838 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Michael Neuling55aab8c2006-03-25 17:30:00 +1100840 drv->owner = THIS_MODULE;
Michael Neuling55aab8c2006-03-25 17:30:00 +1100841 drv->driver_name = "hvc";
842 drv->name = "hvc";
843 drv->major = HVC_MAJOR;
844 drv->minor_start = HVC_MINOR;
845 drv->type = TTY_DRIVER_TYPE_SYSTEM;
846 drv->init_termios = tty_std_termios;
847 drv->flags = TTY_DRIVER_REAL_RAW;
848 tty_set_operations(drv, &hvc_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 /* Always start the kthread because there can be hotplug vty adapters
851 * added later. */
852 hvc_task = kthread_run(khvcd, NULL, "khvcd");
853 if (IS_ERR(hvc_task)) {
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700854 printk(KERN_ERR "Couldn't create kthread for console.\n");
855 err = PTR_ERR(hvc_task);
856 goto put_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 }
858
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700859 err = tty_register_driver(drv);
860 if (err) {
861 printk(KERN_ERR "Couldn't register hvc console driver\n");
862 goto stop_thread;
863 }
Anton Blanchardef4cbee2005-09-14 14:19:18 -0700864
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700865 /* FIXME: This mb() seems completely random. Remove it. */
Michael Neuling55aab8c2006-03-25 17:30:00 +1100866 mb();
867 hvc_driver = drv;
Milton Milleracad9552005-07-07 17:56:24 -0700868 return 0;
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700869
870put_tty:
871 put_tty_driver(hvc_driver);
872stop_thread:
873 kthread_stop(hvc_task);
874 hvc_task = NULL;
875out:
876 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
will schmidtc3ea6922007-04-18 00:54:51 +1000879/* This isn't particularly necessary due to this being a console driver
Milton Miller320da0d2005-07-07 17:56:20 -0700880 * but it is nice to be thorough.
881 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882static void __exit hvc_exit(void)
883{
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700884 if (hvc_driver) {
885 kthread_stop(hvc_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
Rusty Russell3e6c6f62007-10-16 23:30:13 -0700887 tty_unregister_driver(hvc_driver);
888 /* return tty_struct instances allocated in hvc_init(). */
889 put_tty_driver(hvc_driver);
890 unregister_console(&hvc_con_driver);
891 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893module_exit(hvc_exit);