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
7 * Additional Author(s):
8 * Ryan S. Arnold <rsa@us.ibm.com>
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.
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.
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
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/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>
40 #include <linux/freezer.h>
42 #include <asm/uaccess.h>
44 #include "hvc_console.h"
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.
53 #define HVC_CLOSE_WAIT (HZ/100) /* 1/10 of a second */
56 * 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.
63 #define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
65 static struct tty_driver *hvc_driver;
66 static struct task_struct *hvc_task;
68 /* Picks up late kicks after list walk but before schedule() */
69 static int hvc_kicked;
71 static int hvc_init(void);
73 #ifdef CONFIG_MAGIC_SYSRQ
74 static int sysrq_pressed;
77 /* dynamic list of hvc_struct instances */
78 static LIST_HEAD(hvc_structs);
81 * Protect the list of hvc_struct instances from inserts and removals during
84 static DEFINE_SPINLOCK(hvc_structs_lock);
87 * 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
89 * a console candidate registered with hvc_instantiate().
91 static int last_hvc = -1;
94 * Do not call this function with either the hvc_structs_lock or the hvc_struct
95 * lock held. If successful, this function increments the kref reference
96 * count against the target hvc_struct so it should be released when finished.
98 static struct hvc_struct *hvc_get_by_index(int index)
100 struct hvc_struct *hp;
103 spin_lock(&hvc_structs_lock);
105 list_for_each_entry(hp, &hvc_structs, next) {
106 spin_lock_irqsave(&hp->lock, flags);
107 if (hp->index == index) {
109 spin_unlock_irqrestore(&hp->lock, flags);
110 spin_unlock(&hvc_structs_lock);
113 spin_unlock_irqrestore(&hp->lock, flags);
117 spin_unlock(&hvc_structs_lock);
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.
128 static struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
129 static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
130 {[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
133 * Console APIs, NOT TTY. These APIs are available immediately when
134 * hvc_console_setup() finds adapters.
137 static void hvc_console_print(struct console *co, const char *b,
140 char c[N_OUTBUF] __ALIGNED__;
141 unsigned i = 0, n = 0;
142 int r, donecr = 0, index = co->index;
144 /* Console access attempt outside of acceptable console range. */
145 if (index >= MAX_NR_HVC_CONSOLES)
148 /* This console adapter was removed so it is not usable. */
149 if (vtermnos[index] < 0)
152 while (count > 0 || i > 0) {
153 if (count > 0 && i < sizeof(c)) {
154 if (b[n] == '\n' && !donecr) {
163 r = cons_ops[index]->put_chars(vtermnos[index], c, i);
165 /* throw away chars on error */
176 static struct tty_driver *hvc_console_device(struct console *c, int *index)
178 if (vtermnos[c->index] == -1)
185 static int __init hvc_console_setup(struct console *co, char *options)
187 if (co->index < 0 || co->index >= MAX_NR_HVC_CONSOLES)
190 if (vtermnos[co->index] == -1)
196 static struct console hvc_con_driver = {
198 .write = hvc_console_print,
199 .device = hvc_console_device,
200 .setup = hvc_console_setup,
201 .flags = CON_PRINTBUFFER,
206 * Early console initialization. Precedes driver initialization.
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
217 * Note that for cases 2 and 3, we will match later when the io driver
218 * calls hvc_instantiate() and call register again.
220 static int __init hvc_console_init(void)
222 register_console(&hvc_con_driver);
225 console_initcall(hvc_console_init);
227 /* callback when the kboject ref count reaches zero. */
228 static void destroy_hvc_struct(struct kref *kref)
230 struct hvc_struct *hp = container_of(kref, struct hvc_struct, kref);
233 spin_lock(&hvc_structs_lock);
235 spin_lock_irqsave(&hp->lock, flags);
236 list_del(&(hp->next));
237 spin_unlock_irqrestore(&hp->lock, flags);
239 spin_unlock(&hvc_structs_lock);
245 * 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.
250 int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops)
252 struct hvc_struct *hp;
254 if (index < 0 || index >= MAX_NR_HVC_CONSOLES)
257 if (vtermnos[index] != -1)
260 /* make sure no no tty has been registered in this index */
261 hp = hvc_get_by_index(index);
263 kref_put(&hp->kref, destroy_hvc_struct);
267 vtermnos[index] = vtermno;
268 cons_ops[index] = ops;
270 /* reserve all indices up to and including this index */
271 if (last_hvc < index)
274 /* 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.
278 if (index == hvc_con_driver.index)
279 register_console(&hvc_con_driver);
283 EXPORT_SYMBOL_GPL(hvc_instantiate);
285 /* Wake the sleeping khvcd */
289 wake_up_process(hvc_task);
291 EXPORT_SYMBOL_GPL(hvc_kick);
293 static void hvc_unthrottle(struct tty_struct *tty)
299 * The TTY interface won't be used until after the vio layer has exposed the vty
300 * adapter to the kernel.
302 static int hvc_open(struct tty_struct *tty, struct file * filp)
304 struct hvc_struct *hp;
308 /* Auto increments kref reference if found. */
309 if (!(hp = hvc_get_by_index(tty->index)))
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);
318 } /* else count == 0 */
320 tty->driver_data = hp;
321 tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */
325 spin_unlock_irqrestore(&hp->lock, flags);
327 if (hp->ops->notifier_add)
328 rc = hp->ops->notifier_add(hp, hp->data);
331 * If the notifier fails we return an error. The tty layer
332 * will call hvc_close() after a failed open but we don't want to clean
333 * up there so we'll clean up here and clear out the previously set
334 * tty fields and return the kref reference.
337 spin_lock_irqsave(&hp->lock, flags);
339 spin_unlock_irqrestore(&hp->lock, flags);
340 tty->driver_data = NULL;
341 kref_put(&hp->kref, destroy_hvc_struct);
342 printk(KERN_ERR "hvc_open: request_irq failed with rc %d.\n", rc);
344 /* Force wakeup of the polling thread */
350 static void hvc_close(struct tty_struct *tty, struct file * filp)
352 struct hvc_struct *hp;
355 if (tty_hung_up_p(filp))
359 * No driver_data means that this close was issued after a failed
360 * hvc_open by the tty layer's release_dev() function and we can just
361 * exit cleanly because the kref reference wasn't made.
363 if (!tty->driver_data)
366 hp = tty->driver_data;
367 spin_lock_irqsave(&hp->lock, flags);
369 if (--hp->count == 0) {
370 /* We are done with the tty pointer now. */
372 spin_unlock_irqrestore(&hp->lock, flags);
374 if (hp->ops->notifier_del)
375 hp->ops->notifier_del(hp, hp->data);
377 /* cancel pending tty resize work */
378 cancel_work_sync(&hp->tty_resize);
381 * Chain calls chars_in_buffer() and returns immediately if
382 * there is no buffered data otherwise sleeps on a wait queue
383 * waking periodically to check chars_in_buffer().
385 tty_wait_until_sent(tty, HVC_CLOSE_WAIT);
388 printk(KERN_ERR "hvc_close %X: oops, count is %d\n",
389 hp->vtermno, hp->count);
390 spin_unlock_irqrestore(&hp->lock, flags);
393 kref_put(&hp->kref, destroy_hvc_struct);
396 static void hvc_hangup(struct tty_struct *tty)
398 struct hvc_struct *hp = tty->driver_data;
405 /* cancel pending tty resize work */
406 cancel_work_sync(&hp->tty_resize);
408 spin_lock_irqsave(&hp->lock, flags);
411 * The N_TTY line discipline has problems such that in a close vs
412 * open->hangup case this can be called after the final close so prevent
413 * that from happening for now.
415 if (hp->count <= 0) {
416 spin_unlock_irqrestore(&hp->lock, flags);
420 temp_open_count = hp->count;
425 spin_unlock_irqrestore(&hp->lock, flags);
427 if (hp->ops->notifier_hangup)
428 hp->ops->notifier_hangup(hp, hp->data);
430 while(temp_open_count) {
432 kref_put(&hp->kref, destroy_hvc_struct);
437 * Push buffered characters whether they were just recently buffered or waiting
438 * on a blocked hypervisor. Call this function with hp->lock held.
440 static int hvc_push(struct hvc_struct *hp)
444 n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
450 /* throw away output on error; this happens when
451 there is no session connected to the vterm. */
455 if (hp->n_outbuf > 0)
456 memmove(hp->outbuf, hp->outbuf + n, hp->n_outbuf);
463 static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count)
465 struct hvc_struct *hp = tty->driver_data;
467 int rsize, written = 0;
469 /* This write was probably executed during a tty close. */
476 spin_lock_irqsave(&hp->lock, flags);
478 /* Push pending writes */
479 if (hp->n_outbuf > 0)
482 while (count > 0 && (rsize = hp->outbuf_size - hp->n_outbuf) > 0) {
485 memcpy(hp->outbuf + hp->n_outbuf, buf, rsize);
488 hp->n_outbuf += rsize;
492 spin_unlock_irqrestore(&hp->lock, flags);
495 * Racy, but harmless, kick thread if there is still pending data.
504 * hvc_set_winsz() - Resize the hvc tty terminal window.
505 * @work: work structure.
507 * The routine shall not be called within an atomic context because it
512 static void hvc_set_winsz(struct work_struct *work)
514 struct hvc_struct *hp;
515 unsigned long hvc_flags;
516 struct tty_struct *tty;
519 hp = container_of(work, struct hvc_struct, tty_resize);
523 spin_lock_irqsave(&hp->lock, hvc_flags);
525 spin_unlock_irqrestore(&hp->lock, hvc_flags);
529 tty = tty_kref_get(hp->tty);
530 spin_unlock_irqrestore(&hp->lock, hvc_flags);
532 tty_do_resize(tty, &ws);
537 * This is actually a contract between the driver and the tty layer outlining
538 * how much write room the driver can guarantee will be sent OR BUFFERED. This
539 * driver MUST honor the return value.
541 static int hvc_write_room(struct tty_struct *tty)
543 struct hvc_struct *hp = tty->driver_data;
548 return hp->outbuf_size - hp->n_outbuf;
551 static int hvc_chars_in_buffer(struct tty_struct *tty)
553 struct hvc_struct *hp = tty->driver_data;
561 * timeout will vary between the MIN and MAX values defined here. By default
562 * and during console activity we will use a default MIN_TIMEOUT of 10. When
563 * the console is idle, we increase the timeout value on each pass through
564 * msleep until we reach the max. This may be noticeable as a brief (average
565 * one second) delay on the console before the console responds to input when
566 * there has been no input for some time.
568 #define MIN_TIMEOUT (10)
569 #define MAX_TIMEOUT (2000)
570 static u32 timeout = MIN_TIMEOUT;
572 #define HVC_POLL_READ 0x00000001
573 #define HVC_POLL_WRITE 0x00000002
575 int hvc_poll(struct hvc_struct *hp)
577 struct tty_struct *tty;
578 int i, n, poll_mask = 0;
579 char buf[N_INBUF] __ALIGNED__;
582 int written_total = 0;
584 spin_lock_irqsave(&hp->lock, flags);
586 /* Push pending writes */
587 if (hp->n_outbuf > 0)
588 written_total = hvc_push(hp);
590 /* Reschedule us if still some write pending */
591 if (hp->n_outbuf > 0) {
592 poll_mask |= HVC_POLL_WRITE;
593 /* If hvc_push() was not able to write, sleep a few msecs */
594 timeout = (written_total) ? 0 : MIN_TIMEOUT;
597 /* No tty attached, just skip */
602 /* Now check if we can get data (are we throttled ?) */
603 if (test_bit(TTY_THROTTLED, &tty->flags))
606 /* If we aren't notifier driven and aren't throttled, we always
607 * request a reschedule
609 if (!hp->irq_requested)
610 poll_mask |= HVC_POLL_READ;
612 /* Read data if any */
614 int count = tty_buffer_request_room(tty, N_INBUF);
616 /* If flip is full, just reschedule a later read */
618 poll_mask |= HVC_POLL_READ;
622 n = hp->ops->get_chars(hp->vtermno, buf, count);
624 /* Hangup the tty when disconnected from host */
626 spin_unlock_irqrestore(&hp->lock, flags);
628 spin_lock_irqsave(&hp->lock, flags);
629 } else if ( n == -EAGAIN ) {
631 * Some back-ends can only ensure a certain min
632 * num of bytes read, which may be > 'count'.
633 * Let the tty clear the flip buff to make room.
635 poll_mask |= HVC_POLL_READ;
639 for (i = 0; i < n; ++i) {
640 #ifdef CONFIG_MAGIC_SYSRQ
641 if (hp->index == hvc_con_driver.index) {
642 /* Handle the SysRq Hack */
643 /* XXX should support a sequence */
644 if (buf[i] == '\x0f') { /* ^O */
645 /* if ^O is pressed again, reset
646 * sysrq_pressed and flip ^O char */
647 sysrq_pressed = !sysrq_pressed;
650 } else if (sysrq_pressed) {
651 handle_sysrq(buf[i], tty);
656 #endif /* CONFIG_MAGIC_SYSRQ */
657 tty_insert_flip_char(tty, buf[i], 0);
663 /* Wakeup write queue if necessary */
669 spin_unlock_irqrestore(&hp->lock, flags);
672 /* Activity is occurring, so reset the polling backoff value to
673 a minimum for performance. */
674 timeout = MIN_TIMEOUT;
676 tty_flip_buffer_push(tty);
681 EXPORT_SYMBOL_GPL(hvc_poll);
684 * hvc_resize() - Update terminal window size information.
685 * @hp: HVC console pointer
686 * @ws: Terminal window size structure
688 * Stores the specified window size information in the hvc structure of @hp.
689 * The function schedule the tty resize update.
691 * Locking: Locking free; the function MUST be called holding hp->lock
693 void hvc_resize(struct hvc_struct *hp, struct winsize ws)
696 schedule_work(&hp->tty_resize);
698 EXPORT_SYMBOL_GPL(hvc_resize);
701 * This kthread is either polling or interrupt driven. This is determined by
702 * calling hvc_poll() who determines whether a console adapter support
705 static int khvcd(void *unused)
708 struct hvc_struct *hp;
711 __set_current_state(TASK_RUNNING);
717 if (!cpus_are_in_xmon()) {
718 spin_lock(&hvc_structs_lock);
719 list_for_each_entry(hp, &hvc_structs, next) {
720 poll_mask |= hvc_poll(hp);
722 spin_unlock(&hvc_structs_lock);
724 poll_mask |= HVC_POLL_READ;
727 set_current_state(TASK_INTERRUPTIBLE);
732 if (timeout < MAX_TIMEOUT)
733 timeout += (timeout >> 6) + 1;
735 msleep_interruptible(timeout);
738 __set_current_state(TASK_RUNNING);
739 } while (!kthread_should_stop());
744 static const struct tty_operations hvc_ops = {
748 .hangup = hvc_hangup,
749 .unthrottle = hvc_unthrottle,
750 .write_room = hvc_write_room,
751 .chars_in_buffer = hvc_chars_in_buffer,
754 struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int data,
755 struct hv_ops *ops, int outbuf_size)
757 struct hvc_struct *hp;
760 /* We wait until a driver actually comes along */
762 int err = hvc_init();
767 hp = kmalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
770 return ERR_PTR(-ENOMEM);
772 memset(hp, 0x00, sizeof(*hp));
774 hp->vtermno = vtermno;
777 hp->outbuf_size = outbuf_size;
778 hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
780 kref_init(&hp->kref);
782 INIT_WORK(&hp->tty_resize, hvc_set_winsz);
783 spin_lock_init(&hp->lock);
784 spin_lock(&hvc_structs_lock);
788 * see if this vterm id matches one registered for console.
790 for (i=0; i < MAX_NR_HVC_CONSOLES; i++)
791 if (vtermnos[i] == hp->vtermno &&
792 cons_ops[i] == hp->ops)
795 /* no matching slot, just use a counter */
796 if (i >= MAX_NR_HVC_CONSOLES)
801 list_add_tail(&(hp->next), &hvc_structs);
802 spin_unlock(&hvc_structs_lock);
806 EXPORT_SYMBOL_GPL(hvc_alloc);
808 int hvc_remove(struct hvc_struct *hp)
811 struct tty_struct *tty;
813 spin_lock_irqsave(&hp->lock, flags);
816 if (hp->index < MAX_NR_HVC_CONSOLES)
817 vtermnos[hp->index] = -1;
819 /* Don't whack hp->irq because tty_hangup() will need to free the irq. */
821 spin_unlock_irqrestore(&hp->lock, flags);
824 * We 'put' the instance that was grabbed when the kref instance
825 * was initialized using kref_init(). Let the last holder of this
826 * kref cause it to be removed, which will probably be the tty_hangup
829 kref_put(&hp->kref, destroy_hvc_struct);
832 * This function call will auto chain call hvc_hangup. The tty should
833 * always be valid at this time unless a simultaneous tty close already
834 * cleaned up the hvc_struct.
841 /* Driver initialization: called as soon as someone uses hvc_alloc(). */
842 static int hvc_init(void)
844 struct tty_driver *drv;
847 /* We need more than hvc_count adapters due to hotplug additions. */
848 drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS);
854 drv->owner = THIS_MODULE;
855 drv->driver_name = "hvc";
857 drv->major = HVC_MAJOR;
858 drv->minor_start = HVC_MINOR;
859 drv->type = TTY_DRIVER_TYPE_SYSTEM;
860 drv->init_termios = tty_std_termios;
861 drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
862 tty_set_operations(drv, &hvc_ops);
864 /* Always start the kthread because there can be hotplug vty adapters
866 hvc_task = kthread_run(khvcd, NULL, "khvcd");
867 if (IS_ERR(hvc_task)) {
868 printk(KERN_ERR "Couldn't create kthread for console.\n");
869 err = PTR_ERR(hvc_task);
873 err = tty_register_driver(drv);
875 printk(KERN_ERR "Couldn't register hvc console driver\n");
879 /* FIXME: This mb() seems completely random. Remove it. */
885 kthread_stop(hvc_task);
893 /* This isn't particularly necessary due to this being a console driver
894 * but it is nice to be thorough.
896 static void __exit hvc_exit(void)
899 kthread_stop(hvc_task);
901 tty_unregister_driver(hvc_driver);
902 /* return tty_struct instances allocated in hvc_init(). */
903 put_tty_driver(hvc_driver);
904 unregister_console(&hvc_con_driver);
907 module_exit(hvc_exit);