hvc_console.c 21.2 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 30 31 32 33 34 35 36 37 38 39 40
/*
 * 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>
#include <linux/kobject.h>
#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 72 73 74 75
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;

#ifdef CONFIG_MAGIC_SYSRQ
static int sysrq_pressed;
#endif

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

/* 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);

102
/*
103 104
 * 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 已提交
105
 * a console candidate registered with hvc_instantiate().
106
 */
107
static int last_hvc = -1;
108 109

/*
W
will schmidt 已提交
110
 * Do not call this function with either the hvc_structs_lock or the hvc_struct
111 112 113
 * lock held.  If successful, this function increments the kobject reference
 * count against the target hvc_struct so it should be released when finished.
 */
114
static struct hvc_struct *hvc_get_by_index(int index)
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
{
	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) {
			kobject_get(&hp->kobj);
			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 已提交
138 139 140 141 142 143
/*
 * 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.
 */
144
static struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
145 146
static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
	{[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
L
Linus Torvalds 已提交
147

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

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

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

W
will schmidt 已提交
164
	/* This console adapter was removed so it is not usable. */
165
	if (vtermnos[index] < 0)
166 167 168 169 170 171 172 173 174 175 176 177 178
		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 {
179
			r = cons_ops[index]->put_chars(vtermnos[index], c, i);
180 181 182 183 184 185 186 187 188 189 190 191 192 193
			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)
{
194 195 196
	if (vtermnos[c->index] == -1)
		return NULL;

197 198 199 200 201 202
	*index = c->index;
	return hvc_driver;
}

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

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

209 210 211
	return 0;
}

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

221
/*
W
will schmidt 已提交
222
 * Early console initialization.  Precedes driver initialization.
223 224 225 226 227 228 229 230 231 232 233 234 235
 *
 * (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.
 */
236 237 238 239 240 241
static int __init hvc_console_init(void)
{
	register_console(&hvc_con_driver);
	return 0;
}
console_initcall(hvc_console_init);
L
Linus Torvalds 已提交
242 243

/*
244 245 246 247
 * 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 已提交
248
 */
249
int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops)
250
{
251 252
	struct hvc_struct *hp;

253 254
	if (index < 0 || index >= MAX_NR_HVC_CONSOLES)
		return -1;
L
Linus Torvalds 已提交
255

256 257 258
	if (vtermnos[index] != -1)
		return -1;

W
will schmidt 已提交
259
	/* make sure no no tty has been registered in this index */
260 261 262 263 264 265
	hp = hvc_get_by_index(index);
	if (hp) {
		kobject_put(&hp->kobj);
		return -1;
	}

266
	vtermnos[index] = vtermno;
267
	cons_ops[index] = ops;
268

W
will schmidt 已提交
269
	/* reserve all indices up to and including this index */
270 271 272
	if (last_hvc < index)
		last_hvc = index;

273 274 275 276 277 278 279
	/* 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);

280 281
	return 0;
}
L
Linus Torvalds 已提交
282 283 284 285 286 287 288 289

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

290 291
static int hvc_poll(struct hvc_struct *hp);

L
Linus Torvalds 已提交
292 293 294 295
/*
 * NOTE: This API isn't used if the console adapter doesn't support interrupts.
 * In this case the console is poll driven.
 */
296
static irqreturn_t hvc_handle_interrupt(int irq, void *dev_instance)
L
Linus Torvalds 已提交
297
{
298 299 300
	/* if hvc_poll request a repoll, then kick the hvcd thread */
	if (hvc_poll(dev_instance))
		hvc_kick();
L
Linus Torvalds 已提交
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
	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;
317
	int irq = 0;
L
Linus Torvalds 已提交
318 319 320 321
	int rc = 0;
	struct kobject *kobjp;

	/* Auto increments kobject reference if found. */
322
	if (!(hp = hvc_get_by_index(tty->index)))
L
Linus Torvalds 已提交
323 324 325 326 327 328 329 330 331 332 333
		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;
334 335
	tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */

L
Linus Torvalds 已提交
336 337 338
	hp->tty = tty;
	/* Save for request_irq outside of spin_lock. */
	irq = hp->irq;
339
	if (irq)
L
Linus Torvalds 已提交
340 341 342 343 344 345
		hp->irq_requested = 1;

	kobjp = &hp->kobj;

	spin_unlock_irqrestore(&hp->lock, flags);
	/* check error, fallback to non-irq */
346
	if (irq)
347
		rc = request_irq(irq, hvc_handle_interrupt, IRQF_DISABLED, "hvc_console", hp);
L
Linus Torvalds 已提交
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373

	/*
	 * 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
	 * tty fields and return the kobject reference.
	 */
	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;
		kobject_put(kobjp);
		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;
	struct kobject *kobjp;
374
	int irq = 0;
L
Linus Torvalds 已提交
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
	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
	 * exit cleanly because the kobject reference wasn't made.
	 */
	if (!tty->driver_data)
		return;

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

	kobjp = &hp->kobj;
	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);

408
		if (irq)
L
Linus Torvalds 已提交
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
			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);
	}

	kobject_put(kobjp);
}

static void hvc_hangup(struct tty_struct *tty)
{
	struct hvc_struct *hp = tty->driver_data;
	unsigned long flags;
425
	int irq = 0;
L
Linus Torvalds 已提交
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
	int temp_open_count;
	struct kobject *kobjp;

	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;
	}

	kobjp = &hp->kobj;
	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);
454
	if (irq)
L
Linus Torvalds 已提交
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
		free_irq(irq, hp);
	while(temp_open_count) {
		--temp_open_count;
		kobject_put(kobjp);
	}
}

/*
 * 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;

470
	n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
L
Linus Torvalds 已提交
471
	if (n <= 0) {
472 473
		if (n == 0) {
			hp->do_wakeup = 1;
L
Linus Torvalds 已提交
474
			return;
475
		}
L
Linus Torvalds 已提交
476 477 478 479 480 481 482 483 484 485 486
		/* 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;
}

487
static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count)
L
Linus Torvalds 已提交
488
{
489
	struct hvc_struct *hp = tty->driver_data;
L
Linus Torvalds 已提交
490 491 492
	unsigned long flags;
	int rsize, written = 0;

493 494 495 496 497 498 499
	/* This write was probably executed during a tty close. */
	if (!hp)
		return -EPIPE;

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

L
Linus Torvalds 已提交
500 501 502 503 504 505
	spin_lock_irqsave(&hp->lock, flags);

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

506
	while (count > 0 && (rsize = hp->outbuf_size - hp->n_outbuf) > 0) {
L
Linus Torvalds 已提交
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
		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 已提交
529
 * how much write room the driver can guarantee will be sent OR BUFFERED.  This
L
Linus Torvalds 已提交
530 531 532 533 534 535 536 537 538
 * 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;

539
	return hp->outbuf_size - hp->n_outbuf;
L
Linus Torvalds 已提交
540 541 542 543 544 545 546 547 548 549 550
}

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;
}

551 552 553 554 555 556 557 558 559 560 561 562
/*
 * 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 已提交
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
#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);
579

L
Linus Torvalds 已提交
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
	/* 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
	 */
596
	if (hp->irq == 0)
L
Linus Torvalds 已提交
597 598 599 600
		poll_mask |= HVC_POLL_READ;

	/* Read data if any */
	for (;;) {
A
Alan Cox 已提交
601
		int count = tty_buffer_request_room(tty, N_INBUF);
L
Linus Torvalds 已提交
602 603 604 605 606 607 608

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

609
		n = hp->ops->get_chars(hp->vtermno, buf, count);
L
Linus Torvalds 已提交
610 611 612 613 614 615
		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);
616 617 618 619 620 621 622
			} 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 已提交
623 624 625 626 627
			}
			break;
		}
		for (i = 0; i < n; ++i) {
#ifdef CONFIG_MAGIC_SYSRQ
628 629 630 631 632 633 634
			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) {
635
					handle_sysrq(buf[i], tty);
636 637 638
					sysrq_pressed = 0;
					continue;
				}
L
Linus Torvalds 已提交
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
			}
#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);

655 656 657 658 659
	if (read_total) {
		/* Activity is occurring, so reset the polling backoff value to
		   a minimum for performance. */
		timeout = MIN_TIMEOUT;

660
		tty_flip_buffer_push(tty);
661 662
	}

L
Linus Torvalds 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675 676
	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.
 */
677
static int khvcd(void *unused)
L
Linus Torvalds 已提交
678 679 680 681 682 683 684 685
{
	int poll_mask;
	struct hvc_struct *hp;

	__set_current_state(TASK_RUNNING);
	do {
		poll_mask = 0;
		hvc_kicked = 0;
A
Andrew Morton 已提交
686
		try_to_freeze();
L
Linus Torvalds 已提交
687 688 689 690 691 692 693 694 695 696 697
		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;
698
		if (poll_mask & HVC_POLL_WRITE) {
L
Linus Torvalds 已提交
699 700 701 702 703 704 705
			yield();
			continue;
		}
		set_current_state(TASK_INTERRUPTIBLE);
		if (!hvc_kicked) {
			if (poll_mask == 0)
				schedule();
706 707 708 709 710 711
			else {
				if (timeout < MAX_TIMEOUT)
					timeout += (timeout >> 6) + 1;

				msleep_interruptible(timeout);
			}
L
Linus Torvalds 已提交
712 713 714 715 716 717 718
		}
		__set_current_state(TASK_RUNNING);
	} while (!kthread_should_stop());

	return 0;
}

J
Jeff Dike 已提交
719
static const struct tty_operations hvc_ops = {
L
Linus Torvalds 已提交
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
	.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,
};

/* callback when the kboject ref count reaches zero. */
static void destroy_hvc_struct(struct kobject *kobj)
{
	struct hvc_struct *hp = container_of(kobj, struct hvc_struct, kobj);
	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);
}

static struct kobj_type hvc_kobj_type = {
	.release = destroy_hvc_struct,
};

750
struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int irq,
751
					struct hv_ops *ops, int outbuf_size)
L
Linus Torvalds 已提交
752 753
{
	struct hvc_struct *hp;
754
	int i;
L
Linus Torvalds 已提交
755

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

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

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

	kobject_init(&hp->kobj);
	hp->kobj.ktype = &hvc_kobj_type;

	spin_lock_init(&hp->lock);
	spin_lock(&hvc_structs_lock);
774 775 776 777 778 779

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

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

	hp->index = i;

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

793
	return hp;
L
Linus Torvalds 已提交
794 795
}

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

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

	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);

	/*
	 * We 'put' the instance that was grabbed when the kobject instance
W
will schmidt 已提交
815
	 * was initialized using kobject_init().  Let the last holder of this
L
Linus Torvalds 已提交
816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
	 * kobject cause it to be removed, which will probably be the tty_hangup
	 * below.
	 */
	kobject_put(kobjp);

	/*
	 * 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;
}

/* Driver initialization.  Follow console initialization.  This is where the TTY
 * interfaces start to become available. */
833
static int __init hvc_init(void)
L
Linus Torvalds 已提交
834
{
M
Michael Neuling 已提交
835 836
	struct tty_driver *drv;

837
	/* We need more than hvc_count adapters due to hotplug additions. */
M
Michael Neuling 已提交
838 839
	drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS);
	if (!drv)
L
Linus Torvalds 已提交
840 841
		return -ENOMEM;

M
Michael Neuling 已提交
842 843 844 845 846 847 848 849 850
	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 已提交
851 852 853 854 855 856

	/* 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)) {
		panic("Couldn't create kthread for console.\n");
M
Michael Neuling 已提交
857
		put_tty_driver(drv);
L
Linus Torvalds 已提交
858 859 860
		return -EIO;
	}

M
Michael Neuling 已提交
861
	if (tty_register_driver(drv))
862 863
		panic("Couldn't register hvc console driver\n");

M
Michael Neuling 已提交
864 865
	mb();
	hvc_driver = drv;
866
	return 0;
L
Linus Torvalds 已提交
867
}
868
module_init(hvc_init);
L
Linus Torvalds 已提交
869

W
will schmidt 已提交
870
/* This isn't particularly necessary due to this being a console driver
871 872
 * but it is nice to be thorough.
 */
L
Linus Torvalds 已提交
873 874 875 876 877 878 879
static void __exit hvc_exit(void)
{
	kthread_stop(hvc_task);

	tty_unregister_driver(hvc_driver);
	/* return tty_struct instances allocated in hvc_init(). */
	put_tty_driver(hvc_driver);
880
	unregister_console(&hvc_con_driver);
L
Linus Torvalds 已提交
881 882
}
module_exit(hvc_exit);