hvc_console.c 21.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
 * Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
 * Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
 * Copyright (C) 2004 IBM Corporation
 *
 * Additional Author(s):
 *  Ryan S. Arnold <rsa@us.ibm.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/console.h>
#include <linux/cpumask.h>
#include <linux/init.h>
#include <linux/kbd_kern.h>
#include <linux/kernel.h>
30
#include <linux/kref.h>
L
Linus Torvalds 已提交
31 32 33 34 35 36 37 38 39 40
#include <linux/kthread.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/major.h>
#include <linux/sysrq.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/delay.h>
41
#include <linux/freezer.h>
42

L
Linus Torvalds 已提交
43
#include <asm/uaccess.h>
44 45

#include "hvc_console.h"
L
Linus Torvalds 已提交
46 47 48 49 50 51 52 53 54 55 56

#define HVC_MAJOR	229
#define HVC_MINOR	0

/*
 * Wait this long per iteration while trying to push buffered data to the
 * hypervisor before allowing the tty to complete a close operation.
 */
#define HVC_CLOSE_WAIT (HZ/100) /* 1/10 of a second */

/*
57 58 59
 * These sizes are most efficient for vio, because they are the
 * native transfer size. We could make them selectable in the
 * future to better deal with backends that want other buffer sizes.
L
Linus Torvalds 已提交
60 61 62 63
 */
#define N_OUTBUF	16
#define N_INBUF		16

64
#define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
L
Linus Torvalds 已提交
65

66 67 68 69 70 71
static struct tty_driver *hvc_driver;
static struct task_struct *hvc_task;

/* Picks up late kicks after list walk but before schedule() */
static int hvc_kicked;

R
Rusty Russell 已提交
72 73
static int hvc_init(void);

74 75 76 77
#ifdef CONFIG_MAGIC_SYSRQ
static int sysrq_pressed;
#endif

L
Linus Torvalds 已提交
78 79 80 81 82 83
struct hvc_struct {
	spinlock_t lock;
	int index;
	struct tty_struct *tty;
	unsigned int count;
	int do_wakeup;
84 85
	char *outbuf;
	int outbuf_size;
L
Linus Torvalds 已提交
86 87
	int n_outbuf;
	uint32_t vtermno;
88
	struct hv_ops *ops;
L
Linus Torvalds 已提交
89 90 91
	int irq_requested;
	int irq;
	struct list_head next;
92
	struct kref kref; /* ref count & hvc_struct lifetime */
L
Linus Torvalds 已提交
93 94 95 96 97 98 99 100 101 102 103
};

/* dynamic list of hvc_struct instances */
static struct list_head hvc_structs = LIST_HEAD_INIT(hvc_structs);

/*
 * Protect the list of hvc_struct instances from inserts and removals during
 * list traversal.
 */
static DEFINE_SPINLOCK(hvc_structs_lock);

104
/*
105 106
 * This value is used to assign a tty->index value to a hvc_struct based
 * upon order of exposure via hvc_probe(), when we can not match it to
W
will schmidt 已提交
107
 * a console candidate registered with hvc_instantiate().
108
 */
109
static int last_hvc = -1;
110 111

/*
W
will schmidt 已提交
112
 * Do not call this function with either the hvc_structs_lock or the hvc_struct
113
 * lock held.  If successful, this function increments the kref reference
114 115
 * count against the target hvc_struct so it should be released when finished.
 */
116
static struct hvc_struct *hvc_get_by_index(int index)
117 118 119 120 121 122 123 124 125
{
	struct hvc_struct *hp;
	unsigned long flags;

	spin_lock(&hvc_structs_lock);

	list_for_each_entry(hp, &hvc_structs, next) {
		spin_lock_irqsave(&hp->lock, flags);
		if (hp->index == index) {
126
			kref_get(&hp->kref);
127 128 129 130 131 132 133 134 135 136 137 138 139
			spin_unlock_irqrestore(&hp->lock, flags);
			spin_unlock(&hvc_structs_lock);
			return hp;
		}
		spin_unlock_irqrestore(&hp->lock, flags);
	}
	hp = NULL;

	spin_unlock(&hvc_structs_lock);
	return hp;
}


L
Linus Torvalds 已提交
140 141 142 143 144 145
/*
 * Initial console vtermnos for console API usage prior to full console
 * initialization.  Any vty adapter outside this range will not have usable
 * console interfaces but can still be used as a tty device.  This has to be
 * static because kmalloc will not work during early console init.
 */
146
static struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
147 148
static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
	{[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
L
Linus Torvalds 已提交
149

150 151 152 153 154
/*
 * Console APIs, NOT TTY.  These APIs are available immediately when
 * hvc_console_setup() finds adapters.
 */

155 156
static void hvc_console_print(struct console *co, const char *b,
			      unsigned count)
157
{
158
	char c[N_OUTBUF] __ALIGNED__;
159
	unsigned i = 0, n = 0;
160
	int r, donecr = 0, index = co->index;
161 162

	/* Console access attempt outside of acceptable console range. */
163
	if (index >= MAX_NR_HVC_CONSOLES)
164 165
		return;

W
will schmidt 已提交
166
	/* This console adapter was removed so it is not usable. */
167
	if (vtermnos[index] < 0)
168 169 170 171 172 173 174 175 176 177 178 179 180
		return;

	while (count > 0 || i > 0) {
		if (count > 0 && i < sizeof(c)) {
			if (b[n] == '\n' && !donecr) {
				c[i++] = '\r';
				donecr = 1;
			} else {
				c[i++] = b[n++];
				donecr = 0;
				--count;
			}
		} else {
181
			r = cons_ops[index]->put_chars(vtermnos[index], c, i);
182 183 184 185 186 187 188 189 190 191 192 193 194 195
			if (r < 0) {
				/* throw away chars on error */
				i = 0;
			} else if (r > 0) {
				i -= r;
				if (i > 0)
					memmove(c, c+r, i);
			}
		}
	}
}

static struct tty_driver *hvc_console_device(struct console *c, int *index)
{
196 197 198
	if (vtermnos[c->index] == -1)
		return NULL;

199 200 201 202 203 204
	*index = c->index;
	return hvc_driver;
}

static int __init hvc_console_setup(struct console *co, char *options)
{
205 206 207 208 209 210
	if (co->index < 0 || co->index >= MAX_NR_HVC_CONSOLES)
		return -ENODEV;

	if (vtermnos[co->index] == -1)
		return -ENODEV;

211 212 213
	return 0;
}

214
static struct console hvc_con_driver = {
215 216 217 218 219 220 221 222
	.name		= "hvc",
	.write		= hvc_console_print,
	.device		= hvc_console_device,
	.setup		= hvc_console_setup,
	.flags		= CON_PRINTBUFFER,
	.index		= -1,
};

223
/*
W
will schmidt 已提交
224
 * Early console initialization.  Precedes driver initialization.
225 226 227 228 229 230 231 232 233 234 235 236 237
 *
 * (1) we are first, and the user specified another driver
 * -- index will remain -1
 * (2) we are first and the user specified no driver
 * -- index will be set to 0, then we will fail setup.
 * (3)  we are first and the user specified our driver
 * -- index will be set to user specified driver, and we will fail
 * (4) we are after driver, and this initcall will register us
 * -- if the user didn't specify a driver then the console will match
 *
 * Note that for cases 2 and 3, we will match later when the io driver
 * calls hvc_instantiate() and call register again.
 */
238 239 240 241 242 243
static int __init hvc_console_init(void)
{
	register_console(&hvc_con_driver);
	return 0;
}
console_initcall(hvc_console_init);
L
Linus Torvalds 已提交
244

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
/* callback when the kboject ref count reaches zero. */
static void destroy_hvc_struct(struct kref *kref)
{
	struct hvc_struct *hp = container_of(kref, struct hvc_struct, kref);
	unsigned long flags;

	spin_lock(&hvc_structs_lock);

	spin_lock_irqsave(&hp->lock, flags);
	list_del(&(hp->next));
	spin_unlock_irqrestore(&hp->lock, flags);

	spin_unlock(&hvc_structs_lock);

	kfree(hp);
}

L
Linus Torvalds 已提交
262
/*
263 264 265 266
 * hvc_instantiate() is an early console discovery method which locates
 * consoles * prior to the vio subsystem discovering them.  Hotplugged
 * vty adapters do NOT get an hvc_instantiate() callback since they
 * appear after early console init.
L
Linus Torvalds 已提交
267
 */
268
int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops)
269
{
270 271
	struct hvc_struct *hp;

272 273
	if (index < 0 || index >= MAX_NR_HVC_CONSOLES)
		return -1;
L
Linus Torvalds 已提交
274

275 276 277
	if (vtermnos[index] != -1)
		return -1;

W
will schmidt 已提交
278
	/* make sure no no tty has been registered in this index */
279 280
	hp = hvc_get_by_index(index);
	if (hp) {
281
		kref_put(&hp->kref, destroy_hvc_struct);
282 283 284
		return -1;
	}

285
	vtermnos[index] = vtermno;
286
	cons_ops[index] = ops;
287

W
will schmidt 已提交
288
	/* reserve all indices up to and including this index */
289 290 291
	if (last_hvc < index)
		last_hvc = index;

292 293 294 295 296 297 298
	/* if this index is what the user requested, then register
	 * now (setup won't fail at this point).  It's ok to just
	 * call register again if previously .setup failed.
	 */
	if (index == hvc_con_driver.index)
		register_console(&hvc_con_driver);

299 300
	return 0;
}
L
Linus Torvalds 已提交
301 302 303 304 305 306 307 308

/* Wake the sleeping khvcd */
static void hvc_kick(void)
{
	hvc_kicked = 1;
	wake_up_process(hvc_task);
}

309 310
static int hvc_poll(struct hvc_struct *hp);

L
Linus Torvalds 已提交
311 312 313 314
/*
 * NOTE: This API isn't used if the console adapter doesn't support interrupts.
 * In this case the console is poll driven.
 */
315
static irqreturn_t hvc_handle_interrupt(int irq, void *dev_instance)
L
Linus Torvalds 已提交
316
{
317 318 319
	/* if hvc_poll request a repoll, then kick the hvcd thread */
	if (hvc_poll(dev_instance))
		hvc_kick();
L
Linus Torvalds 已提交
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
	return IRQ_HANDLED;
}

static void hvc_unthrottle(struct tty_struct *tty)
{
	hvc_kick();
}

/*
 * The TTY interface won't be used until after the vio layer has exposed the vty
 * adapter to the kernel.
 */
static int hvc_open(struct tty_struct *tty, struct file * filp)
{
	struct hvc_struct *hp;
	unsigned long flags;
336
	int irq = 0;
L
Linus Torvalds 已提交
337 338
	int rc = 0;

339
	/* Auto increments kref reference if found. */
340
	if (!(hp = hvc_get_by_index(tty->index)))
L
Linus Torvalds 已提交
341 342 343 344 345 346 347 348 349 350 351
		return -ENODEV;

	spin_lock_irqsave(&hp->lock, flags);
	/* Check and then increment for fast path open. */
	if (hp->count++ > 0) {
		spin_unlock_irqrestore(&hp->lock, flags);
		hvc_kick();
		return 0;
	} /* else count == 0 */

	tty->driver_data = hp;
352 353
	tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */

L
Linus Torvalds 已提交
354 355 356
	hp->tty = tty;
	/* Save for request_irq outside of spin_lock. */
	irq = hp->irq;
357
	if (irq)
L
Linus Torvalds 已提交
358 359 360 361
		hp->irq_requested = 1;

	spin_unlock_irqrestore(&hp->lock, flags);
	/* check error, fallback to non-irq */
362
	if (irq)
363
		rc = request_irq(irq, hvc_handle_interrupt, IRQF_DISABLED, "hvc_console", hp);
L
Linus Torvalds 已提交
364 365 366 367 368

	/*
	 * If the request_irq() fails and we return an error.  The tty layer
	 * will call hvc_close() after a failed open but we don't want to clean
	 * up there so we'll clean up here and clear out the previously set
369
	 * tty fields and return the kref reference.
L
Linus Torvalds 已提交
370 371 372 373 374 375 376
	 */
	if (rc) {
		spin_lock_irqsave(&hp->lock, flags);
		hp->tty = NULL;
		hp->irq_requested = 0;
		spin_unlock_irqrestore(&hp->lock, flags);
		tty->driver_data = NULL;
377
		kref_put(&hp->kref, destroy_hvc_struct);
L
Linus Torvalds 已提交
378 379 380 381 382 383 384 385 386 387 388
		printk(KERN_ERR "hvc_open: request_irq failed with rc %d.\n", rc);
	}
	/* Force wakeup of the polling thread */
	hvc_kick();

	return rc;
}

static void hvc_close(struct tty_struct *tty, struct file * filp)
{
	struct hvc_struct *hp;
389
	int irq = 0;
L
Linus Torvalds 已提交
390 391 392 393 394 395 396 397
	unsigned long flags;

	if (tty_hung_up_p(filp))
		return;

	/*
	 * No driver_data means that this close was issued after a failed
	 * hvc_open by the tty layer's release_dev() function and we can just
398
	 * exit cleanly because the kref reference wasn't made.
L
Linus Torvalds 已提交
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
	 */
	if (!tty->driver_data)
		return;

	hp = tty->driver_data;
	spin_lock_irqsave(&hp->lock, flags);

	if (--hp->count == 0) {
		if (hp->irq_requested)
			irq = hp->irq;
		hp->irq_requested = 0;

		/* We are done with the tty pointer now. */
		hp->tty = NULL;
		spin_unlock_irqrestore(&hp->lock, flags);

		/*
		 * Chain calls chars_in_buffer() and returns immediately if
		 * there is no buffered data otherwise sleeps on a wait queue
		 * waking periodically to check chars_in_buffer().
		 */
		tty_wait_until_sent(tty, HVC_CLOSE_WAIT);

422
		if (irq)
L
Linus Torvalds 已提交
423 424 425 426 427 428 429 430 431
			free_irq(irq, hp);

	} else {
		if (hp->count < 0)
			printk(KERN_ERR "hvc_close %X: oops, count is %d\n",
				hp->vtermno, hp->count);
		spin_unlock_irqrestore(&hp->lock, flags);
	}

432
	kref_put(&hp->kref, destroy_hvc_struct);
L
Linus Torvalds 已提交
433 434 435 436 437 438
}

static void hvc_hangup(struct tty_struct *tty)
{
	struct hvc_struct *hp = tty->driver_data;
	unsigned long flags;
439
	int irq = 0;
L
Linus Torvalds 已提交
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
	int temp_open_count;

	if (!hp)
		return;

	spin_lock_irqsave(&hp->lock, flags);

	/*
	 * The N_TTY line discipline has problems such that in a close vs
	 * open->hangup case this can be called after the final close so prevent
	 * that from happening for now.
	 */
	if (hp->count <= 0) {
		spin_unlock_irqrestore(&hp->lock, flags);
		return;
	}

	temp_open_count = hp->count;
	hp->count = 0;
	hp->n_outbuf = 0;
	hp->tty = NULL;
	if (hp->irq_requested)
		/* Saved for use outside of spin_lock. */
		irq = hp->irq;
	hp->irq_requested = 0;
	spin_unlock_irqrestore(&hp->lock, flags);
466
	if (irq)
L
Linus Torvalds 已提交
467 468 469
		free_irq(irq, hp);
	while(temp_open_count) {
		--temp_open_count;
470
		kref_put(&hp->kref, destroy_hvc_struct);
L
Linus Torvalds 已提交
471 472 473 474 475 476 477 478 479 480 481
	}
}

/*
 * Push buffered characters whether they were just recently buffered or waiting
 * on a blocked hypervisor.  Call this function with hp->lock held.
 */
static void hvc_push(struct hvc_struct *hp)
{
	int n;

482
	n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
L
Linus Torvalds 已提交
483
	if (n <= 0) {
484 485
		if (n == 0) {
			hp->do_wakeup = 1;
L
Linus Torvalds 已提交
486
			return;
487
		}
L
Linus Torvalds 已提交
488 489 490 491 492 493 494 495 496 497 498
		/* throw away output on error; this happens when
		   there is no session connected to the vterm. */
		hp->n_outbuf = 0;
	} else
		hp->n_outbuf -= n;
	if (hp->n_outbuf > 0)
		memmove(hp->outbuf, hp->outbuf + n, hp->n_outbuf);
	else
		hp->do_wakeup = 1;
}

499
static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count)
L
Linus Torvalds 已提交
500
{
501
	struct hvc_struct *hp = tty->driver_data;
L
Linus Torvalds 已提交
502 503 504
	unsigned long flags;
	int rsize, written = 0;

505 506 507 508 509 510 511
	/* This write was probably executed during a tty close. */
	if (!hp)
		return -EPIPE;

	if (hp->count <= 0)
		return -EIO;

L
Linus Torvalds 已提交
512 513 514 515 516 517
	spin_lock_irqsave(&hp->lock, flags);

	/* Push pending writes */
	if (hp->n_outbuf > 0)
		hvc_push(hp);

518
	while (count > 0 && (rsize = hp->outbuf_size - hp->n_outbuf) > 0) {
L
Linus Torvalds 已提交
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
		if (rsize > count)
			rsize = count;
		memcpy(hp->outbuf + hp->n_outbuf, buf, rsize);
		count -= rsize;
		buf += rsize;
		hp->n_outbuf += rsize;
		written += rsize;
		hvc_push(hp);
	}
	spin_unlock_irqrestore(&hp->lock, flags);

	/*
	 * Racy, but harmless, kick thread if there is still pending data.
	 */
	if (hp->n_outbuf)
		hvc_kick();

	return written;
}

/*
 * This is actually a contract between the driver and the tty layer outlining
W
will schmidt 已提交
541
 * how much write room the driver can guarantee will be sent OR BUFFERED.  This
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549 550
 * driver MUST honor the return value.
 */
static int hvc_write_room(struct tty_struct *tty)
{
	struct hvc_struct *hp = tty->driver_data;

	if (!hp)
		return -1;

551
	return hp->outbuf_size - hp->n_outbuf;
L
Linus Torvalds 已提交
552 553 554 555 556 557 558 559 560 561 562
}

static int hvc_chars_in_buffer(struct tty_struct *tty)
{
	struct hvc_struct *hp = tty->driver_data;

	if (!hp)
		return -1;
	return hp->n_outbuf;
}

563 564 565 566 567 568 569 570 571 572 573 574
/*
 * timeout will vary between the MIN and MAX values defined here.  By default
 * and during console activity we will use a default MIN_TIMEOUT of 10.  When
 * the console is idle, we increase the timeout value on each pass through
 * msleep until we reach the max.  This may be noticeable as a brief (average
 * one second) delay on the console before the console responds to input when
 * there has been no input for some time.
 */
#define MIN_TIMEOUT		(10)
#define MAX_TIMEOUT		(2000)
static u32 timeout = MIN_TIMEOUT;

L
Linus Torvalds 已提交
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
#define HVC_POLL_READ	0x00000001
#define HVC_POLL_WRITE	0x00000002

static int hvc_poll(struct hvc_struct *hp)
{
	struct tty_struct *tty;
	int i, n, poll_mask = 0;
	char buf[N_INBUF] __ALIGNED__;
	unsigned long flags;
	int read_total = 0;

	spin_lock_irqsave(&hp->lock, flags);

	/* Push pending writes */
	if (hp->n_outbuf > 0)
		hvc_push(hp);
591

L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
	/* Reschedule us if still some write pending */
	if (hp->n_outbuf > 0)
		poll_mask |= HVC_POLL_WRITE;

	/* No tty attached, just skip */
	tty = hp->tty;
	if (tty == NULL)
		goto bail;

	/* Now check if we can get data (are we throttled ?) */
	if (test_bit(TTY_THROTTLED, &tty->flags))
		goto throttled;

	/* If we aren't interrupt driven and aren't throttled, we always
	 * request a reschedule
	 */
608
	if (hp->irq == 0)
L
Linus Torvalds 已提交
609 610 611 612
		poll_mask |= HVC_POLL_READ;

	/* Read data if any */
	for (;;) {
A
Alan Cox 已提交
613
		int count = tty_buffer_request_room(tty, N_INBUF);
L
Linus Torvalds 已提交
614 615 616 617 618 619 620

		/* If flip is full, just reschedule a later read */
		if (count == 0) {
			poll_mask |= HVC_POLL_READ;
			break;
		}

621
		n = hp->ops->get_chars(hp->vtermno, buf, count);
L
Linus Torvalds 已提交
622 623 624 625 626 627
		if (n <= 0) {
			/* Hangup the tty when disconnected from host */
			if (n == -EPIPE) {
				spin_unlock_irqrestore(&hp->lock, flags);
				tty_hangup(tty);
				spin_lock_irqsave(&hp->lock, flags);
628 629 630 631 632 633 634
			} else if ( n == -EAGAIN ) {
				/*
				 * Some back-ends can only ensure a certain min
				 * num of bytes read, which may be > 'count'.
				 * Let the tty clear the flip buff to make room.
				 */
				poll_mask |= HVC_POLL_READ;
L
Linus Torvalds 已提交
635 636 637 638 639
			}
			break;
		}
		for (i = 0; i < n; ++i) {
#ifdef CONFIG_MAGIC_SYSRQ
640 641 642 643 644 645 646
			if (hp->index == hvc_con_driver.index) {
				/* Handle the SysRq Hack */
				/* XXX should support a sequence */
				if (buf[i] == '\x0f') {	/* ^O */
					sysrq_pressed = 1;
					continue;
				} else if (sysrq_pressed) {
647
					handle_sysrq(buf[i], tty);
648 649 650
					sysrq_pressed = 0;
					continue;
				}
L
Linus Torvalds 已提交
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
			}
#endif /* CONFIG_MAGIC_SYSRQ */
			tty_insert_flip_char(tty, buf[i], 0);
		}

		read_total += n;
	}
 throttled:
	/* Wakeup write queue if necessary */
	if (hp->do_wakeup) {
		hp->do_wakeup = 0;
		tty_wakeup(tty);
	}
 bail:
	spin_unlock_irqrestore(&hp->lock, flags);

667 668 669 670 671
	if (read_total) {
		/* Activity is occurring, so reset the polling backoff value to
		   a minimum for performance. */
		timeout = MIN_TIMEOUT;

672
		tty_flip_buffer_push(tty);
673 674
	}

L
Linus Torvalds 已提交
675 676 677 678 679 680 681 682 683 684 685 686 687 688
	return poll_mask;
}

#if defined(CONFIG_XMON) && defined(CONFIG_SMP)
extern cpumask_t cpus_in_xmon;
#else
static const cpumask_t cpus_in_xmon = CPU_MASK_NONE;
#endif

/*
 * This kthread is either polling or interrupt driven.  This is determined by
 * calling hvc_poll() who determines whether a console adapter support
 * interrupts.
 */
689
static int khvcd(void *unused)
L
Linus Torvalds 已提交
690 691 692 693
{
	int poll_mask;
	struct hvc_struct *hp;

694
	set_freezable();
L
Linus Torvalds 已提交
695 696 697 698
	__set_current_state(TASK_RUNNING);
	do {
		poll_mask = 0;
		hvc_kicked = 0;
A
Andrew Morton 已提交
699
		try_to_freeze();
L
Linus Torvalds 已提交
700 701 702 703 704 705 706 707 708 709 710
		wmb();
		if (cpus_empty(cpus_in_xmon)) {
			spin_lock(&hvc_structs_lock);
			list_for_each_entry(hp, &hvc_structs, next) {
				poll_mask |= hvc_poll(hp);
			}
			spin_unlock(&hvc_structs_lock);
		} else
			poll_mask |= HVC_POLL_READ;
		if (hvc_kicked)
			continue;
711
		if (poll_mask & HVC_POLL_WRITE) {
L
Linus Torvalds 已提交
712 713 714 715 716 717 718
			yield();
			continue;
		}
		set_current_state(TASK_INTERRUPTIBLE);
		if (!hvc_kicked) {
			if (poll_mask == 0)
				schedule();
719 720 721 722 723 724
			else {
				if (timeout < MAX_TIMEOUT)
					timeout += (timeout >> 6) + 1;

				msleep_interruptible(timeout);
			}
L
Linus Torvalds 已提交
725 726 727 728 729 730 731
		}
		__set_current_state(TASK_RUNNING);
	} while (!kthread_should_stop());

	return 0;
}

J
Jeff Dike 已提交
732
static const struct tty_operations hvc_ops = {
L
Linus Torvalds 已提交
733 734 735 736 737 738 739 740 741
	.open = hvc_open,
	.close = hvc_close,
	.write = hvc_write,
	.hangup = hvc_hangup,
	.unthrottle = hvc_unthrottle,
	.write_room = hvc_write_room,
	.chars_in_buffer = hvc_chars_in_buffer,
};

742
struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int irq,
743
					struct hv_ops *ops, int outbuf_size)
L
Linus Torvalds 已提交
744 745
{
	struct hvc_struct *hp;
746
	int i;
L
Linus Torvalds 已提交
747

R
Rusty Russell 已提交
748 749 750 751 752 753 754
	/* We wait until a driver actually comes along */
	if (!hvc_driver) {
		int err = hvc_init();
		if (err)
			return ERR_PTR(err);
	}

755 756
	hp = kmalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
			GFP_KERNEL);
L
Linus Torvalds 已提交
757
	if (!hp)
758
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
759 760

	memset(hp, 0x00, sizeof(*hp));
761 762 763

	hp->vtermno = vtermno;
	hp->irq = irq;
764
	hp->ops = ops;
765 766
	hp->outbuf_size = outbuf_size;
	hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
L
Linus Torvalds 已提交
767

768
	kref_init(&hp->kref);
L
Linus Torvalds 已提交
769 770 771

	spin_lock_init(&hp->lock);
	spin_lock(&hvc_structs_lock);
772 773 774 775 776 777

	/*
	 * find index to use:
	 * see if this vterm id matches one registered for console.
	 */
	for (i=0; i < MAX_NR_HVC_CONSOLES; i++)
778 779
		if (vtermnos[i] == hp->vtermno &&
		    cons_ops[i] == hp->ops)
780 781 782 783 784 785 786 787
			break;

	/* no matching slot, just use a counter */
	if (i >= MAX_NR_HVC_CONSOLES)
		i = ++last_hvc;

	hp->index = i;

L
Linus Torvalds 已提交
788 789 790
	list_add_tail(&(hp->next), &hvc_structs);
	spin_unlock(&hvc_structs_lock);

791
	return hp;
L
Linus Torvalds 已提交
792 793
}

794
int __devexit hvc_remove(struct hvc_struct *hp)
L
Linus Torvalds 已提交
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
{
	unsigned long flags;
	struct tty_struct *tty;

	spin_lock_irqsave(&hp->lock, flags);
	tty = hp->tty;

	if (hp->index < MAX_NR_HVC_CONSOLES)
		vtermnos[hp->index] = -1;

	/* Don't whack hp->irq because tty_hangup() will need to free the irq. */

	spin_unlock_irqrestore(&hp->lock, flags);

	/*
810 811 812
	 * We 'put' the instance that was grabbed when the kref instance
	 * was initialized using kref_init().  Let the last holder of this
	 * kref cause it to be removed, which will probably be the tty_hangup
L
Linus Torvalds 已提交
813 814
	 * below.
	 */
815
	kref_put(&hp->kref, destroy_hvc_struct);
L
Linus Torvalds 已提交
816 817 818 819 820 821 822 823 824 825 826

	/*
	 * This function call will auto chain call hvc_hangup.  The tty should
	 * always be valid at this time unless a simultaneous tty close already
	 * cleaned up the hvc_struct.
	 */
	if (tty)
		tty_hangup(tty);
	return 0;
}

R
Rusty Russell 已提交
827 828
/* Driver initialization: called as soon as someone uses hvc_alloc(). */
static int hvc_init(void)
L
Linus Torvalds 已提交
829
{
M
Michael Neuling 已提交
830
	struct tty_driver *drv;
R
Rusty Russell 已提交
831
	int err;
M
Michael Neuling 已提交
832

833
	/* We need more than hvc_count adapters due to hotplug additions. */
M
Michael Neuling 已提交
834
	drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS);
R
Rusty Russell 已提交
835 836 837 838
	if (!drv) {
		err = -ENOMEM;
		goto out;
	}
L
Linus Torvalds 已提交
839

M
Michael Neuling 已提交
840 841 842 843 844 845 846 847 848
	drv->owner = THIS_MODULE;
	drv->driver_name = "hvc";
	drv->name = "hvc";
	drv->major = HVC_MAJOR;
	drv->minor_start = HVC_MINOR;
	drv->type = TTY_DRIVER_TYPE_SYSTEM;
	drv->init_termios = tty_std_termios;
	drv->flags = TTY_DRIVER_REAL_RAW;
	tty_set_operations(drv, &hvc_ops);
L
Linus Torvalds 已提交
849 850 851 852 853

	/* Always start the kthread because there can be hotplug vty adapters
	 * added later. */
	hvc_task = kthread_run(khvcd, NULL, "khvcd");
	if (IS_ERR(hvc_task)) {
R
Rusty Russell 已提交
854 855 856
		printk(KERN_ERR "Couldn't create kthread for console.\n");
		err = PTR_ERR(hvc_task);
		goto put_tty;
L
Linus Torvalds 已提交
857 858
	}

R
Rusty Russell 已提交
859 860 861 862 863
	err = tty_register_driver(drv);
	if (err) {
		printk(KERN_ERR "Couldn't register hvc console driver\n");
		goto stop_thread;
	}
864

R
Rusty Russell 已提交
865
	/* FIXME: This mb() seems completely random.  Remove it. */
M
Michael Neuling 已提交
866 867
	mb();
	hvc_driver = drv;
868
	return 0;
R
Rusty Russell 已提交
869 870 871 872 873 874 875 876

put_tty:
	put_tty_driver(hvc_driver);
stop_thread:
	kthread_stop(hvc_task);
	hvc_task = NULL;
out:
	return err;
L
Linus Torvalds 已提交
877 878
}

W
will schmidt 已提交
879
/* This isn't particularly necessary due to this being a console driver
880 881
 * but it is nice to be thorough.
 */
L
Linus Torvalds 已提交
882 883
static void __exit hvc_exit(void)
{
R
Rusty Russell 已提交
884 885
	if (hvc_driver) {
		kthread_stop(hvc_task);
L
Linus Torvalds 已提交
886

R
Rusty Russell 已提交
887 888 889 890 891
		tty_unregister_driver(hvc_driver);
		/* return tty_struct instances allocated in hvc_init(). */
		put_tty_driver(hvc_driver);
		unregister_console(&hvc_con_driver);
	}
L
Linus Torvalds 已提交
892 893
}
module_exit(hvc_exit);