blob: cc2cd46bedc6ac6dac8dd7d256a3605c784128cf [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>
30#include <linux/kobject.h>
31#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
50#define TIMEOUT (10)
51
52/*
53 * Wait this long per iteration while trying to push buffered data to the
54 * hypervisor before allowing the tty to complete a close operation.
55 */
56#define HVC_CLOSE_WAIT (HZ/100) /* 1/10 of a second */
57
58/*
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020059 * These sizes are most efficient for vio, because they are the
60 * native transfer size. We could make them selectable in the
61 * future to better deal with backends that want other buffer sizes.
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#define N_OUTBUF 16
64#define N_INBUF 16
65
Ryan S. Arnold45d607e2006-03-27 21:25:16 +020066#define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Milton Miller837dcfa2005-07-07 17:56:16 -070068static struct tty_driver *hvc_driver;
69static struct task_struct *hvc_task;
70
71/* Picks up late kicks after list walk but before schedule() */
72static int hvc_kicked;
73
74#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;
92 struct kobject kobj; /* ref count & hvc_struct lifetime */
Linus Torvalds1da177e2005-04-16 15:20:36 -070093};
94
95/* dynamic list of hvc_struct instances */
96static struct list_head hvc_structs = LIST_HEAD_INIT(hvc_structs);
97
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
107 * a console canidate 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/*
112 * Do not call this function with either the hvc_strucst_lock or the hvc_struct
113 * lock held. If successful, this function increments the kobject reference
114 * count against the target hvc_struct so it should be released when finished.
115 */
116struct hvc_struct *hvc_get_by_index(int index)
117{
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) {
126 kobject_get(&hp->kobj);
127 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
155void hvc_console_print(struct console *co, const char *b, unsigned count)
156{
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200157 char c[N_OUTBUF] __ALIGNED__;
Milton Miller837dcfa2005-07-07 17:56:16 -0700158 unsigned i = 0, n = 0;
Milton Miller030ffad2005-07-07 17:56:25 -0700159 int r, donecr = 0, index = co->index;
Milton Miller837dcfa2005-07-07 17:56:16 -0700160
161 /* Console access attempt outside of acceptable console range. */
Milton Miller030ffad2005-07-07 17:56:25 -0700162 if (index >= MAX_NR_HVC_CONSOLES)
Milton Miller837dcfa2005-07-07 17:56:16 -0700163 return;
164
165 /* This console adapter was removed so it is not useable. */
Milton Miller030ffad2005-07-07 17:56:25 -0700166 if (vtermnos[index] < 0)
Milton Miller837dcfa2005-07-07 17:56:16 -0700167 return;
168
169 while (count > 0 || i > 0) {
170 if (count > 0 && i < sizeof(c)) {
171 if (b[n] == '\n' && !donecr) {
172 c[i++] = '\r';
173 donecr = 1;
174 } else {
175 c[i++] = b[n++];
176 donecr = 0;
177 --count;
178 }
179 } else {
Milton Miller030ffad2005-07-07 17:56:25 -0700180 r = cons_ops[index]->put_chars(vtermnos[index], c, i);
Milton Miller837dcfa2005-07-07 17:56:16 -0700181 if (r < 0) {
182 /* throw away chars on error */
183 i = 0;
184 } else if (r > 0) {
185 i -= r;
186 if (i > 0)
187 memmove(c, c+r, i);
188 }
189 }
190 }
191}
192
193static struct tty_driver *hvc_console_device(struct console *c, int *index)
194{
Milton Miller7805b1b2005-07-07 17:56:23 -0700195 if (vtermnos[c->index] == -1)
196 return NULL;
197
Milton Miller837dcfa2005-07-07 17:56:16 -0700198 *index = c->index;
199 return hvc_driver;
200}
201
202static int __init hvc_console_setup(struct console *co, char *options)
203{
Milton Miller7805b1b2005-07-07 17:56:23 -0700204 if (co->index < 0 || co->index >= MAX_NR_HVC_CONSOLES)
205 return -ENODEV;
206
207 if (vtermnos[co->index] == -1)
208 return -ENODEV;
209
Milton Miller837dcfa2005-07-07 17:56:16 -0700210 return 0;
211}
212
213struct console hvc_con_driver = {
214 .name = "hvc",
215 .write = hvc_console_print,
216 .device = hvc_console_device,
217 .setup = hvc_console_setup,
218 .flags = CON_PRINTBUFFER,
219 .index = -1,
220};
221
Milton Millerd5ee2572005-07-07 17:56:24 -0700222/*
223 * Early console initialization. Preceeds driver initialization.
224 *
225 * (1) we are first, and the user specified another driver
226 * -- index will remain -1
227 * (2) we are first and the user specified no driver
228 * -- index will be set to 0, then we will fail setup.
229 * (3) we are first and the user specified our driver
230 * -- index will be set to user specified driver, and we will fail
231 * (4) we are after driver, and this initcall will register us
232 * -- if the user didn't specify a driver then the console will match
233 *
234 * Note that for cases 2 and 3, we will match later when the io driver
235 * calls hvc_instantiate() and call register again.
236 */
Milton Miller837dcfa2005-07-07 17:56:16 -0700237static int __init hvc_console_init(void)
238{
Milton Miller837dcfa2005-07-07 17:56:16 -0700239 register_console(&hvc_con_driver);
240 return 0;
241}
242console_initcall(hvc_console_init);
243
244/*
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
Milton Miller7805b1b2005-07-07 17:56:23 -0700260 /* make sure no no tty has been registerd in this index */
261 hp = hvc_get_by_index(index);
262 if (hp) {
263 kobject_put(&hp->kobj);
264 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
270 /* reserve all indices upto and including this index */
271 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}
Milton Milleracad9552005-07-07 17:56:24 -0700283EXPORT_SYMBOL(hvc_instantiate);
Milton Miller837dcfa2005-07-07 17:56:16 -0700284
285/* Wake the sleeping khvcd */
286static void hvc_kick(void)
287{
288 hvc_kicked = 1;
289 wake_up_process(hvc_task);
290}
291
Milton Miller8b67f8c2005-07-07 17:56:18 -0700292static int hvc_poll(struct hvc_struct *hp);
293
Milton Miller837dcfa2005-07-07 17:56:16 -0700294/*
295 * NOTE: This API isn't used if the console adapter doesn't support interrupts.
296 * In this case the console is poll driven.
297 */
David Howells7d12e782006-10-05 14:55:46 +0100298static irqreturn_t hvc_handle_interrupt(int irq, void *dev_instance)
Milton Miller837dcfa2005-07-07 17:56:16 -0700299{
Milton Miller8b67f8c2005-07-07 17:56:18 -0700300 /* if hvc_poll request a repoll, then kick the hvcd thread */
301 if (hvc_poll(dev_instance))
302 hvc_kick();
Milton Miller837dcfa2005-07-07 17:56:16 -0700303 return IRQ_HANDLED;
304}
305
306static void hvc_unthrottle(struct tty_struct *tty)
307{
308 hvc_kick();
309}
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311/*
312 * The TTY interface won't be used until after the vio layer has exposed the vty
313 * adapter to the kernel.
314 */
315static int hvc_open(struct tty_struct *tty, struct file * filp)
316{
317 struct hvc_struct *hp;
318 unsigned long flags;
319 int irq = NO_IRQ;
320 int rc = 0;
321 struct kobject *kobjp;
322
323 /* Auto increments kobject reference if found. */
Olof Johansson87fd7722006-09-07 15:18:08 -0500324 if (!(hp = hvc_get_by_index(tty->index)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 spin_lock_irqsave(&hp->lock, flags);
328 /* Check and then increment for fast path open. */
329 if (hp->count++ > 0) {
330 spin_unlock_irqrestore(&hp->lock, flags);
331 hvc_kick();
332 return 0;
333 } /* else count == 0 */
334
335 tty->driver_data = hp;
Michal Ostrowskifb5c5942006-02-18 09:29:59 -0500336 tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 hp->tty = tty;
339 /* Save for request_irq outside of spin_lock. */
340 irq = hp->irq;
341 if (irq != NO_IRQ)
342 hp->irq_requested = 1;
343
344 kobjp = &hp->kobj;
345
346 spin_unlock_irqrestore(&hp->lock, flags);
347 /* check error, fallback to non-irq */
348 if (irq != NO_IRQ)
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -0700349 rc = request_irq(irq, hvc_handle_interrupt, IRQF_DISABLED, "hvc_console", hp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
351 /*
352 * If the request_irq() fails and we return an error. The tty layer
353 * will call hvc_close() after a failed open but we don't want to clean
354 * up there so we'll clean up here and clear out the previously set
355 * tty fields and return the kobject reference.
356 */
357 if (rc) {
358 spin_lock_irqsave(&hp->lock, flags);
359 hp->tty = NULL;
360 hp->irq_requested = 0;
361 spin_unlock_irqrestore(&hp->lock, flags);
362 tty->driver_data = NULL;
363 kobject_put(kobjp);
364 printk(KERN_ERR "hvc_open: request_irq failed with rc %d.\n", rc);
365 }
366 /* Force wakeup of the polling thread */
367 hvc_kick();
368
369 return rc;
370}
371
372static void hvc_close(struct tty_struct *tty, struct file * filp)
373{
374 struct hvc_struct *hp;
375 struct kobject *kobjp;
376 int irq = NO_IRQ;
377 unsigned long flags;
378
379 if (tty_hung_up_p(filp))
380 return;
381
382 /*
383 * No driver_data means that this close was issued after a failed
384 * hvc_open by the tty layer's release_dev() function and we can just
385 * exit cleanly because the kobject reference wasn't made.
386 */
387 if (!tty->driver_data)
388 return;
389
390 hp = tty->driver_data;
391 spin_lock_irqsave(&hp->lock, flags);
392
393 kobjp = &hp->kobj;
394 if (--hp->count == 0) {
395 if (hp->irq_requested)
396 irq = hp->irq;
397 hp->irq_requested = 0;
398
399 /* We are done with the tty pointer now. */
400 hp->tty = NULL;
401 spin_unlock_irqrestore(&hp->lock, flags);
402
403 /*
404 * Chain calls chars_in_buffer() and returns immediately if
405 * there is no buffered data otherwise sleeps on a wait queue
406 * waking periodically to check chars_in_buffer().
407 */
408 tty_wait_until_sent(tty, HVC_CLOSE_WAIT);
409
410 if (irq != NO_IRQ)
411 free_irq(irq, hp);
412
413 } else {
414 if (hp->count < 0)
415 printk(KERN_ERR "hvc_close %X: oops, count is %d\n",
416 hp->vtermno, hp->count);
417 spin_unlock_irqrestore(&hp->lock, flags);
418 }
419
420 kobject_put(kobjp);
421}
422
423static void hvc_hangup(struct tty_struct *tty)
424{
425 struct hvc_struct *hp = tty->driver_data;
426 unsigned long flags;
427 int irq = NO_IRQ;
428 int temp_open_count;
429 struct kobject *kobjp;
430
431 if (!hp)
432 return;
433
434 spin_lock_irqsave(&hp->lock, flags);
435
436 /*
437 * The N_TTY line discipline has problems such that in a close vs
438 * open->hangup case this can be called after the final close so prevent
439 * that from happening for now.
440 */
441 if (hp->count <= 0) {
442 spin_unlock_irqrestore(&hp->lock, flags);
443 return;
444 }
445
446 kobjp = &hp->kobj;
447 temp_open_count = hp->count;
448 hp->count = 0;
449 hp->n_outbuf = 0;
450 hp->tty = NULL;
451 if (hp->irq_requested)
452 /* Saved for use outside of spin_lock. */
453 irq = hp->irq;
454 hp->irq_requested = 0;
455 spin_unlock_irqrestore(&hp->lock, flags);
456 if (irq != NO_IRQ)
457 free_irq(irq, hp);
458 while(temp_open_count) {
459 --temp_open_count;
460 kobject_put(kobjp);
461 }
462}
463
464/*
465 * Push buffered characters whether they were just recently buffered or waiting
466 * on a blocked hypervisor. Call this function with hp->lock held.
467 */
468static void hvc_push(struct hvc_struct *hp)
469{
470 int n;
471
Milton Miller030ffad2005-07-07 17:56:25 -0700472 n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 if (n <= 0) {
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200474 if (n == 0) {
475 hp->do_wakeup = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 return;
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 /* throw away output on error; this happens when
479 there is no session connected to the vterm. */
480 hp->n_outbuf = 0;
481 } else
482 hp->n_outbuf -= n;
483 if (hp->n_outbuf > 0)
484 memmove(hp->outbuf, hp->outbuf + n, hp->n_outbuf);
485 else
486 hp->do_wakeup = 1;
487}
488
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200489static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200491 struct hvc_struct *hp = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 unsigned long flags;
493 int rsize, written = 0;
494
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200495 /* This write was probably executed during a tty close. */
496 if (!hp)
497 return -EPIPE;
498
499 if (hp->count <= 0)
500 return -EIO;
501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 spin_lock_irqsave(&hp->lock, flags);
503
504 /* Push pending writes */
505 if (hp->n_outbuf > 0)
506 hvc_push(hp);
507
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000508 while (count > 0 && (rsize = hp->outbuf_size - hp->n_outbuf) > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 if (rsize > count)
510 rsize = count;
511 memcpy(hp->outbuf + hp->n_outbuf, buf, rsize);
512 count -= rsize;
513 buf += rsize;
514 hp->n_outbuf += rsize;
515 written += rsize;
516 hvc_push(hp);
517 }
518 spin_unlock_irqrestore(&hp->lock, flags);
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 /*
521 * Racy, but harmless, kick thread if there is still pending data.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 */
523 if (hp->n_outbuf)
524 hvc_kick();
525
526 return written;
527}
528
529/*
530 * This is actually a contract between the driver and the tty layer outlining
531 * how much write room the driver can guarentee will be sent OR BUFFERED. This
532 * driver MUST honor the return value.
533 */
534static int hvc_write_room(struct tty_struct *tty)
535{
536 struct hvc_struct *hp = tty->driver_data;
537
538 if (!hp)
539 return -1;
540
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000541 return hp->outbuf_size - hp->n_outbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
543
544static int hvc_chars_in_buffer(struct tty_struct *tty)
545{
546 struct hvc_struct *hp = tty->driver_data;
547
548 if (!hp)
549 return -1;
550 return hp->n_outbuf;
551}
552
553#define HVC_POLL_READ 0x00000001
554#define HVC_POLL_WRITE 0x00000002
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
556static int hvc_poll(struct hvc_struct *hp)
557{
558 struct tty_struct *tty;
559 int i, n, poll_mask = 0;
560 char buf[N_INBUF] __ALIGNED__;
561 unsigned long flags;
562 int read_total = 0;
563
564 spin_lock_irqsave(&hp->lock, flags);
565
566 /* Push pending writes */
567 if (hp->n_outbuf > 0)
568 hvc_push(hp);
Michael Ellermanb5374462006-06-07 17:10:03 +1000569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 /* Reschedule us if still some write pending */
571 if (hp->n_outbuf > 0)
572 poll_mask |= HVC_POLL_WRITE;
573
574 /* No tty attached, just skip */
575 tty = hp->tty;
576 if (tty == NULL)
577 goto bail;
578
579 /* Now check if we can get data (are we throttled ?) */
580 if (test_bit(TTY_THROTTLED, &tty->flags))
581 goto throttled;
582
583 /* If we aren't interrupt driven and aren't throttled, we always
584 * request a reschedule
585 */
586 if (hp->irq == NO_IRQ)
587 poll_mask |= HVC_POLL_READ;
588
589 /* Read data if any */
590 for (;;) {
Alan Cox33f0f882006-01-09 20:54:13 -0800591 int count = tty_buffer_request_room(tty, N_INBUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 /* If flip is full, just reschedule a later read */
594 if (count == 0) {
595 poll_mask |= HVC_POLL_READ;
596 break;
597 }
598
Milton Miller030ffad2005-07-07 17:56:25 -0700599 n = hp->ops->get_chars(hp->vtermno, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 if (n <= 0) {
601 /* Hangup the tty when disconnected from host */
602 if (n == -EPIPE) {
603 spin_unlock_irqrestore(&hp->lock, flags);
604 tty_hangup(tty);
605 spin_lock_irqsave(&hp->lock, flags);
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200606 } else if ( n == -EAGAIN ) {
607 /*
608 * Some back-ends can only ensure a certain min
609 * num of bytes read, which may be > 'count'.
610 * Let the tty clear the flip buff to make room.
611 */
612 poll_mask |= HVC_POLL_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 }
614 break;
615 }
616 for (i = 0; i < n; ++i) {
617#ifdef CONFIG_MAGIC_SYSRQ
Milton Miller2b9e0ba2005-07-07 17:56:19 -0700618 if (hp->index == hvc_con_driver.index) {
619 /* Handle the SysRq Hack */
620 /* XXX should support a sequence */
621 if (buf[i] == '\x0f') { /* ^O */
622 sysrq_pressed = 1;
623 continue;
624 } else if (sysrq_pressed) {
David Howells7d12e782006-10-05 14:55:46 +0100625 handle_sysrq(buf[i], tty);
Milton Miller2b9e0ba2005-07-07 17:56:19 -0700626 sysrq_pressed = 0;
627 continue;
628 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 }
630#endif /* CONFIG_MAGIC_SYSRQ */
631 tty_insert_flip_char(tty, buf[i], 0);
632 }
633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 read_total += n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 }
636 throttled:
637 /* Wakeup write queue if necessary */
638 if (hp->do_wakeup) {
639 hp->do_wakeup = 0;
640 tty_wakeup(tty);
641 }
642 bail:
643 spin_unlock_irqrestore(&hp->lock, flags);
644
Michal Ostrowskifb5c5942006-02-18 09:29:59 -0500645 if (read_total)
646 tty_flip_buffer_push(tty);
647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 return poll_mask;
649}
650
651#if defined(CONFIG_XMON) && defined(CONFIG_SMP)
652extern cpumask_t cpus_in_xmon;
653#else
654static const cpumask_t cpus_in_xmon = CPU_MASK_NONE;
655#endif
656
657/*
658 * This kthread is either polling or interrupt driven. This is determined by
659 * calling hvc_poll() who determines whether a console adapter support
660 * interrupts.
661 */
662int khvcd(void *unused)
663{
664 int poll_mask;
665 struct hvc_struct *hp;
666
667 __set_current_state(TASK_RUNNING);
668 do {
669 poll_mask = 0;
670 hvc_kicked = 0;
Andrew Mortonb64074e2006-09-16 12:15:38 -0700671 try_to_freeze();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 wmb();
673 if (cpus_empty(cpus_in_xmon)) {
674 spin_lock(&hvc_structs_lock);
675 list_for_each_entry(hp, &hvc_structs, next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 poll_mask |= hvc_poll(hp);
677 }
678 spin_unlock(&hvc_structs_lock);
679 } else
680 poll_mask |= HVC_POLL_READ;
681 if (hvc_kicked)
682 continue;
Michael Ellermanb5374462006-06-07 17:10:03 +1000683 if (poll_mask & HVC_POLL_WRITE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 yield();
685 continue;
686 }
687 set_current_state(TASK_INTERRUPTIBLE);
688 if (!hvc_kicked) {
689 if (poll_mask == 0)
690 schedule();
691 else
692 msleep_interruptible(TIMEOUT);
693 }
694 __set_current_state(TASK_RUNNING);
695 } while (!kthread_should_stop());
696
697 return 0;
698}
699
Jeff Dikeb68e31d2006-10-02 02:17:18 -0700700static const struct tty_operations hvc_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 .open = hvc_open,
702 .close = hvc_close,
703 .write = hvc_write,
704 .hangup = hvc_hangup,
705 .unthrottle = hvc_unthrottle,
706 .write_room = hvc_write_room,
707 .chars_in_buffer = hvc_chars_in_buffer,
708};
709
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710/* callback when the kboject ref count reaches zero. */
711static void destroy_hvc_struct(struct kobject *kobj)
712{
713 struct hvc_struct *hp = container_of(kobj, struct hvc_struct, kobj);
714 unsigned long flags;
715
716 spin_lock(&hvc_structs_lock);
717
718 spin_lock_irqsave(&hp->lock, flags);
719 list_del(&(hp->next));
720 spin_unlock_irqrestore(&hp->lock, flags);
721
722 spin_unlock(&hvc_structs_lock);
723
724 kfree(hp);
725}
726
727static struct kobj_type hvc_kobj_type = {
728 .release = destroy_hvc_struct,
729};
730
Milton Miller030ffad2005-07-07 17:56:25 -0700731struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int irq,
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000732 struct hv_ops *ops, int outbuf_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733{
734 struct hvc_struct *hp;
Milton Miller6f248082005-07-07 17:56:17 -0700735 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000737 hp = kmalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
738 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 if (!hp)
Milton Milleracad9552005-07-07 17:56:24 -0700740 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
742 memset(hp, 0x00, sizeof(*hp));
Milton Milleracad9552005-07-07 17:56:24 -0700743
744 hp->vtermno = vtermno;
745 hp->irq = irq;
Milton Miller030ffad2005-07-07 17:56:25 -0700746 hp->ops = ops;
Stephen Rothwell4e9e95a2006-07-13 18:53:32 +1000747 hp->outbuf_size = outbuf_size;
748 hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
750 kobject_init(&hp->kobj);
751 hp->kobj.ktype = &hvc_kobj_type;
752
753 spin_lock_init(&hp->lock);
754 spin_lock(&hvc_structs_lock);
Milton Miller6f248082005-07-07 17:56:17 -0700755
756 /*
757 * find index to use:
758 * see if this vterm id matches one registered for console.
759 */
760 for (i=0; i < MAX_NR_HVC_CONSOLES; i++)
Ryan S. Arnold45d607e2006-03-27 21:25:16 +0200761 if (vtermnos[i] == hp->vtermno &&
762 cons_ops[i] == hp->ops)
Milton Miller6f248082005-07-07 17:56:17 -0700763 break;
764
765 /* no matching slot, just use a counter */
766 if (i >= MAX_NR_HVC_CONSOLES)
767 i = ++last_hvc;
768
769 hp->index = i;
770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 list_add_tail(&(hp->next), &hvc_structs);
772 spin_unlock(&hvc_structs_lock);
773
Milton Milleracad9552005-07-07 17:56:24 -0700774 return hp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775}
Milton Milleracad9552005-07-07 17:56:24 -0700776EXPORT_SYMBOL(hvc_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Milton Milleracad9552005-07-07 17:56:24 -0700778int __devexit hvc_remove(struct hvc_struct *hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 unsigned long flags;
781 struct kobject *kobjp;
782 struct tty_struct *tty;
783
784 spin_lock_irqsave(&hp->lock, flags);
785 tty = hp->tty;
786 kobjp = &hp->kobj;
787
788 if (hp->index < MAX_NR_HVC_CONSOLES)
789 vtermnos[hp->index] = -1;
790
791 /* Don't whack hp->irq because tty_hangup() will need to free the irq. */
792
793 spin_unlock_irqrestore(&hp->lock, flags);
794
795 /*
796 * We 'put' the instance that was grabbed when the kobject instance
797 * was intialized using kobject_init(). Let the last holder of this
798 * kobject cause it to be removed, which will probably be the tty_hangup
799 * below.
800 */
801 kobject_put(kobjp);
802
803 /*
804 * This function call will auto chain call hvc_hangup. The tty should
805 * always be valid at this time unless a simultaneous tty close already
806 * cleaned up the hvc_struct.
807 */
808 if (tty)
809 tty_hangup(tty);
810 return 0;
811}
Milton Milleracad9552005-07-07 17:56:24 -0700812EXPORT_SYMBOL(hvc_remove);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
814/* Driver initialization. Follow console initialization. This is where the TTY
815 * interfaces start to become available. */
816int __init hvc_init(void)
817{
Michael Neuling55aab8c2006-03-25 17:30:00 +1100818 struct tty_driver *drv;
819
Milton Miller5f6d9c02005-07-07 17:56:21 -0700820 /* We need more than hvc_count adapters due to hotplug additions. */
Michael Neuling55aab8c2006-03-25 17:30:00 +1100821 drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS);
822 if (!drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 return -ENOMEM;
824
Michael Neuling55aab8c2006-03-25 17:30:00 +1100825 drv->owner = THIS_MODULE;
Michael Neuling55aab8c2006-03-25 17:30:00 +1100826 drv->driver_name = "hvc";
827 drv->name = "hvc";
828 drv->major = HVC_MAJOR;
829 drv->minor_start = HVC_MINOR;
830 drv->type = TTY_DRIVER_TYPE_SYSTEM;
831 drv->init_termios = tty_std_termios;
832 drv->flags = TTY_DRIVER_REAL_RAW;
833 tty_set_operations(drv, &hvc_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 /* Always start the kthread because there can be hotplug vty adapters
836 * added later. */
837 hvc_task = kthread_run(khvcd, NULL, "khvcd");
838 if (IS_ERR(hvc_task)) {
839 panic("Couldn't create kthread for console.\n");
Michael Neuling55aab8c2006-03-25 17:30:00 +1100840 put_tty_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 return -EIO;
842 }
843
Michael Neuling55aab8c2006-03-25 17:30:00 +1100844 if (tty_register_driver(drv))
Anton Blanchardef4cbee2005-09-14 14:19:18 -0700845 panic("Couldn't register hvc console driver\n");
846
Michael Neuling55aab8c2006-03-25 17:30:00 +1100847 mb();
848 hvc_driver = drv;
Milton Milleracad9552005-07-07 17:56:24 -0700849 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850}
Milton Miller837dcfa2005-07-07 17:56:16 -0700851module_init(hvc_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Milton Miller320da0d2005-07-07 17:56:20 -0700853/* This isn't particularily necessary due to this being a console driver
854 * but it is nice to be thorough.
855 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856static void __exit hvc_exit(void)
857{
858 kthread_stop(hvc_task);
859
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 tty_unregister_driver(hvc_driver);
861 /* return tty_struct instances allocated in hvc_init(). */
862 put_tty_driver(hvc_driver);
Milton Miller320da0d2005-07-07 17:56:20 -0700863 unregister_console(&hvc_con_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865module_exit(hvc_exit);