1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * IBM eServer Hypervisor Virtual Console Server Device Driver 4 * Copyright (C) 2003, 2004 IBM Corp. 5 * Ryan S. Arnold (rsa@us.ibm.com) 6 * 7 * Author(s) : Ryan S. Arnold <rsa@us.ibm.com> 8 * 9 * This is the device driver for the IBM Hypervisor Virtual Console Server, 10 * "hvcs". The IBM hvcs provides a tty driver interface to allow Linux 11 * user space applications access to the system consoles of logically 12 * partitioned operating systems, e.g. Linux, running on the same partitioned 13 * Power5 ppc64 system. Physical hardware consoles per partition are not 14 * practical on this hardware so system consoles are accessed by this driver 15 * using inter-partition firmware interfaces to virtual terminal devices. 16 * 17 * A vty is known to the HMC as a "virtual serial server adapter". It is a 18 * virtual terminal device that is created by firmware upon partition creation 19 * to act as a partitioned OS's console device. 20 * 21 * Firmware dynamically (via hotplug) exposes vty-servers to a running ppc64 22 * Linux system upon their creation by the HMC or their exposure during boot. 23 * The non-user interactive backend of this driver is implemented as a vio 24 * device driver so that it can receive notification of vty-server lifetimes 25 * after it registers with the vio bus to handle vty-server probe and remove 26 * callbacks. 27 * 28 * Many vty-servers can be configured to connect to one vty, but a vty can 29 * only be actively connected to by a single vty-server, in any manner, at one 30 * time. If the HMC is currently hosting the console for a target Linux 31 * partition; attempts to open the tty device to the partition's console using 32 * the hvcs on any partition will return -EBUSY with every open attempt until 33 * the HMC frees the connection between its vty-server and the desired 34 * partition's vty device. Conversely, a vty-server may only be connected to 35 * a single vty at one time even though it may have several configured vty 36 * partner possibilities. 37 * 38 * Firmware does not provide notification of vty partner changes to this 39 * driver. This means that an HMC Super Admin may add or remove partner vtys 40 * from a vty-server's partner list but the changes will not be signaled to 41 * the vty-server. Firmware only notifies the driver when a vty-server is 42 * added or removed from the system. To compensate for this deficiency, this 43 * driver implements a sysfs update attribute which provides a method for 44 * rescanning partner information upon a user's request. 45 * 46 * Each vty-server, prior to being exposed to this driver is reference counted 47 * using the 2.6 Linux kernel kref construct. 48 * 49 * For direction on installation and usage of this driver please reference 50 * Documentation/arch/powerpc/hvcs.rst. 51 */ 52 53#include <linux/device.h> 54#include <linux/init.h> 55#include <linux/completion.h> 56#include <linux/interrupt.h> 57#include <linux/kernel.h> 58#include <linux/kref.h> 59#include <linux/kthread.h> 60#include <linux/list.h> 61#include <linux/major.h> 62#include <linux/module.h> 63#include <linux/moduleparam.h> 64#include <linux/sched.h> 65#include <linux/slab.h> 66#include <linux/spinlock.h> 67#include <linux/stat.h> 68#include <linux/tty.h> 69#include <linux/tty_flip.h> 70#include <asm/hvconsole.h> 71#include <asm/hvcserver.h> 72#include <linux/uaccess.h> 73#include <linux/termios_internal.h> 74#include <asm/vio.h> 75 76/* 77 * 1.3.0 -> 1.3.1 In hvcs_open memset(..,0x00,..) instead of memset(..,0x3F,00). 78 * Removed braces around single statements following conditionals. Removed '= 79 * 0' after static int declarations since these default to zero. Removed 80 * list_for_each_safe() and replaced with list_for_each_entry() in 81 * hvcs_get_by_index(). The 'safe' version is un-needed now that the driver is 82 * using spinlocks. Changed spin_lock_irqsave() to spin_lock() when locking 83 * hvcs_structs_lock and hvcs_pi_lock since these are not touched in an int 84 * handler. Initialized hvcs_structs_lock and hvcs_pi_lock to 85 * SPIN_LOCK_UNLOCKED at declaration time rather than in hvcs_module_init(). 86 * Added spin_lock around list_del() in destroy_hvcs_struct() to protect the 87 * list traversals from a deletion. Removed '= NULL' from pointer declaration 88 * statements since they are initialized NULL by default. Removed wmb() 89 * instances from hvcs_try_write(). They probably aren't needed with locking in 90 * place. Added check and cleanup for hvcs_pi_buff = kmalloc() in 91 * hvcs_module_init(). Exposed hvcs_struct.index via a sysfs attribute so that 92 * the coupling between /dev/hvcs* and a vty-server can be automatically 93 * determined. Moved kobject_put() in hvcs_open outside of the 94 * spin_unlock_irqrestore(). 95 * 96 * 1.3.1 -> 1.3.2 Changed method for determining hvcs_struct->index and had it 97 * align with how the tty layer always assigns the lowest index available. This 98 * change resulted in a list of ints that denotes which indexes are available. 99 * Device additions and removals use the new hvcs_get_index() and 100 * hvcs_return_index() helper functions. The list is created with 101 * hvsc_alloc_index_list() and it is destroyed with hvcs_free_index_list(). 102 * Without these fixes hotplug vty-server adapter support goes crazy with this 103 * driver if the user removes a vty-server adapter. Moved free_irq() outside of 104 * the hvcs_final_close() function in order to get it out of the spinlock. 105 * Rearranged hvcs_close(). Cleaned up some printks and did some housekeeping 106 * on the changelog. Removed local CLC_LENGTH and used HVCS_CLC_LENGTH from 107 * arch/powerepc/include/asm/hvcserver.h 108 * 109 * 1.3.2 -> 1.3.3 Replaced yield() in hvcs_close() with tty_wait_until_sent() to 110 * prevent possible lockup with realtime scheduling as similarly pointed out by 111 * akpm in hvc_console. Changed resulted in the removal of hvcs_final_close() 112 * to reorder cleanup operations and prevent discarding of pending data during 113 * an hvcs_close(). Removed spinlock protection of hvcs_struct data members in 114 * hvcs_write_room() and hvcs_chars_in_buffer() because they aren't needed. 115 */ 116 117#define HVCS_DRIVER_VERSION "1.3.3" 118 119MODULE_AUTHOR("Ryan S. Arnold <rsa@us.ibm.com>"); 120MODULE_DESCRIPTION("IBM hvcs (Hypervisor Virtual Console Server) Driver"); 121MODULE_LICENSE("GPL"); 122MODULE_VERSION(HVCS_DRIVER_VERSION); 123 124/* 125 * Wait this long per iteration while trying to push buffered data to the 126 * hypervisor before allowing the tty to complete a close operation. 127 */ 128#define HVCS_CLOSE_WAIT (HZ/100) /* 1/10 of a second */ 129 130/* 131 * Since the Linux TTY code does not currently (2-04-2004) support dynamic 132 * addition of tty derived devices and we shouldn't allocate thousands of 133 * tty_device pointers when the number of vty-server & vty partner connections 134 * will most often be much lower than this, we'll arbitrarily allocate 135 * HVCS_DEFAULT_SERVER_ADAPTERS tty_structs and cdev's by default when we 136 * register the tty_driver. This can be overridden using an insmod parameter. 137 */ 138#define HVCS_DEFAULT_SERVER_ADAPTERS 64 139 140/* 141 * The user can't insmod with more than HVCS_MAX_SERVER_ADAPTERS hvcs device 142 * nodes as a sanity check. Theoretically there can be over 1 Billion 143 * vty-server & vty partner connections. 144 */ 145#define HVCS_MAX_SERVER_ADAPTERS 1024 146 147/* 148 * We let Linux assign us a major number and we start the minors at zero. There 149 * is no intuitive mapping between minor number and the target vty-server 150 * adapter except that each new vty-server adapter is always assigned to the 151 * smallest minor number available. 152 */ 153#define HVCS_MINOR_START 0 154 155/* 156 * The hcall interface involves putting 8 chars into each of two registers. 157 * We load up those 2 registers (in arch/powerpc/platforms/pseries/hvconsole.c) 158 * by casting char[16] to long[2]. It would work without __ALIGNED__, but a 159 * little (tiny) bit slower because an unaligned load is slower than aligned 160 * load. 161 */ 162#define __ALIGNED__ __attribute__((__aligned__(8))) 163 164/* 165 * How much data can firmware send with each hvc_put_chars()? Maybe this 166 * should be moved into an architecture specific area. 167 */ 168#define HVCS_BUFF_LEN 16 169 170/* 171 * This is the maximum amount of data we'll let the user send us (hvcs_write) at 172 * once in a chunk as a sanity check. 173 */ 174#define HVCS_MAX_FROM_USER 4096 175 176/* 177 * Be careful when adding flags to this line discipline. Don't add anything 178 * that will cause echoing or we'll go into recursive loop echoing chars back 179 * and forth with the console drivers. 180 */ 181static const struct ktermios hvcs_tty_termios = { 182 .c_iflag = IGNBRK | IGNPAR, 183 .c_oflag = OPOST, 184 .c_cflag = B38400 | CS8 | CREAD | HUPCL, 185 .c_cc = INIT_C_CC, 186 .c_ispeed = 38400, 187 .c_ospeed = 38400 188}; 189 190/* 191 * This value is used to take the place of a command line parameter when the 192 * module is inserted. It starts as -1 and stays as such if the user doesn't 193 * specify a module insmod parameter. If they DO specify one then it is set to 194 * the value of the integer passed in. 195 */ 196static int hvcs_parm_num_devs = -1; 197module_param(hvcs_parm_num_devs, int, 0); 198 199static const char hvcs_driver_name[] = "hvcs"; 200static const char hvcs_device_node[] = "hvcs"; 201 202/* Status of partner info rescan triggered via sysfs. */ 203static int hvcs_rescan_status; 204 205static struct tty_driver *hvcs_tty_driver; 206 207/* 208 * In order to be somewhat sane this driver always associates the hvcs_struct 209 * index element with the numerically equal tty->index. This means that a 210 * hotplugged vty-server adapter will always map to the lowest index valued 211 * device node. If vty-servers were hotplug removed from the system and then 212 * new ones added the new vty-server may have the largest slot number of all 213 * the vty-server adapters in the partition but it may have the lowest dev node 214 * index of all the adapters due to the hole left by the hotplug removed 215 * adapter. There are a set of functions provided to get the lowest index for 216 * a new device as well as return the index to the list. This list is allocated 217 * with a number of elements equal to the number of device nodes requested when 218 * the module was inserted. 219 */ 220static int *hvcs_index_list; 221 222/* 223 * How large is the list? This is kept for traversal since the list is 224 * dynamically created. 225 */ 226static int hvcs_index_count; 227 228/* 229 * Used by the khvcsd to pick up I/O operations when the kernel_thread is 230 * already awake but potentially shifted to TASK_INTERRUPTIBLE state. 231 */ 232static int hvcs_kicked; 233 234/* 235 * Use by the kthread construct for task operations like waking the sleeping 236 * thread and stopping the kthread. 237 */ 238static struct task_struct *hvcs_task; 239 240/* 241 * We allocate this for the use of all of the hvcs_structs when they fetch 242 * partner info. 243 */ 244static unsigned long *hvcs_pi_buff; 245 246/* Only allow one hvcs_struct to use the hvcs_pi_buff at a time. */ 247static DEFINE_SPINLOCK(hvcs_pi_lock); 248 249/* One vty-server per hvcs_struct */ 250struct hvcs_struct { 251 struct tty_port port; 252 spinlock_t lock; 253 254 /* 255 * This index identifies this hvcs device as the complement to a 256 * specific tty index. 257 */ 258 unsigned int index; 259 260 /* 261 * Used to tell the driver kernel_thread what operations need to take 262 * place upon this hvcs_struct instance. 263 */ 264 int todo_mask; 265 266 /* 267 * This buffer is required so that when hvcs_write_room() reports that 268 * it can send HVCS_BUFF_LEN characters that it will buffer the full 269 * HVCS_BUFF_LEN characters if need be. This is essential for opost 270 * writes since they do not do high level buffering and expect to be 271 * able to send what the driver commits to sending buffering 272 * [e.g. tab to space conversions in n_tty.c opost()]. 273 */ 274 char buffer[HVCS_BUFF_LEN]; 275 int chars_in_buffer; 276 277 /* 278 * Any variable below is valid before a tty is connected and 279 * stays valid after the tty is disconnected. These shouldn't be 280 * whacked until the kobject refcount reaches zero though some entries 281 * may be changed via sysfs initiatives. 282 */ 283 int connected; /* is the vty-server currently connected to a vty? */ 284 uint32_t p_unit_address; /* partner unit address */ 285 uint32_t p_partition_ID; /* partner partition ID */ 286 char p_location_code[HVCS_CLC_LENGTH + 1]; /* CLC + Null Term */ 287 struct list_head next; /* list management */ 288 struct vio_dev *vdev; 289 struct completion *destroyed; 290}; 291 292static LIST_HEAD(hvcs_structs); 293static DEFINE_SPINLOCK(hvcs_structs_lock); 294static DEFINE_MUTEX(hvcs_init_mutex); 295 296static int hvcs_get_pi(struct hvcs_struct *hvcsd); 297static int hvcs_rescan_devices_list(void); 298 299static void hvcs_partner_free(struct hvcs_struct *hvcsd); 300 301static int hvcs_initialize(void); 302 303#define HVCS_SCHED_READ 0x00000001 304#define HVCS_QUICK_READ 0x00000002 305#define HVCS_TRY_WRITE 0x00000004 306#define HVCS_READ_MASK (HVCS_SCHED_READ | HVCS_QUICK_READ) 307 308static inline struct hvcs_struct *from_vio_dev(struct vio_dev *viod) 309{ 310 return dev_get_drvdata(&viod->dev); 311} 312/* The sysfs interface for the driver and devices */ 313 314static ssize_t hvcs_partner_vtys_show(struct device *dev, struct device_attribute *attr, char *buf) 315{ 316 struct vio_dev *viod = to_vio_dev(dev); 317 struct hvcs_struct *hvcsd = from_vio_dev(viod); 318 unsigned long flags; 319 int retval; 320 321 spin_lock_irqsave(&hvcsd->lock, flags); 322 retval = sprintf(buf, "%X\n", hvcsd->p_unit_address); 323 spin_unlock_irqrestore(&hvcsd->lock, flags); 324 return retval; 325} 326static DEVICE_ATTR(partner_vtys, S_IRUGO, hvcs_partner_vtys_show, NULL); 327 328static ssize_t hvcs_partner_clcs_show(struct device *dev, struct device_attribute *attr, char *buf) 329{ 330 struct vio_dev *viod = to_vio_dev(dev); 331 struct hvcs_struct *hvcsd = from_vio_dev(viod); 332 unsigned long flags; 333 int retval; 334 335 spin_lock_irqsave(&hvcsd->lock, flags); 336 retval = sprintf(buf, "%s\n", &hvcsd->p_location_code[0]); 337 spin_unlock_irqrestore(&hvcsd->lock, flags); 338 return retval; 339} 340static DEVICE_ATTR(partner_clcs, S_IRUGO, hvcs_partner_clcs_show, NULL); 341 342static ssize_t hvcs_current_vty_store(struct device *dev, struct device_attribute *attr, const char * buf, 343 size_t count) 344{ 345 /* 346 * Don't need this feature at the present time because firmware doesn't 347 * yet support multiple partners. 348 */ 349 printk(KERN_INFO "HVCS: Denied current_vty change: -EPERM.\n"); 350 return -EPERM; 351} 352 353static ssize_t hvcs_current_vty_show(struct device *dev, struct device_attribute *attr, char *buf) 354{ 355 struct vio_dev *viod = to_vio_dev(dev); 356 struct hvcs_struct *hvcsd = from_vio_dev(viod); 357 unsigned long flags; 358 int retval; 359 360 spin_lock_irqsave(&hvcsd->lock, flags); 361 retval = sprintf(buf, "%s\n", &hvcsd->p_location_code[0]); 362 spin_unlock_irqrestore(&hvcsd->lock, flags); 363 return retval; 364} 365 366static DEVICE_ATTR(current_vty, 367 S_IRUGO | S_IWUSR, hvcs_current_vty_show, hvcs_current_vty_store); 368 369static ssize_t hvcs_vterm_state_store(struct device *dev, struct device_attribute *attr, const char *buf, 370 size_t count) 371{ 372 struct vio_dev *viod = to_vio_dev(dev); 373 struct hvcs_struct *hvcsd = from_vio_dev(viod); 374 unsigned long flags; 375 376 /* writing a '0' to this sysfs entry will result in the disconnect. */ 377 if (simple_strtol(buf, NULL, 0) != 0) 378 return -EINVAL; 379 380 spin_lock_irqsave(&hvcsd->lock, flags); 381 382 if (hvcsd->port.count > 0) { 383 spin_unlock_irqrestore(&hvcsd->lock, flags); 384 printk(KERN_INFO "HVCS: vterm state unchanged. " 385 "The hvcs device node is still in use.\n"); 386 return -EPERM; 387 } 388 389 if (hvcsd->connected == 0) { 390 spin_unlock_irqrestore(&hvcsd->lock, flags); 391 printk(KERN_INFO "HVCS: vterm state unchanged. The" 392 " vty-server is not connected to a vty.\n"); 393 return -EPERM; 394 } 395 396 hvcs_partner_free(hvcsd); 397 printk(KERN_INFO "HVCS: Closed vty-server@%X and" 398 " partner vty@%X:%d connection.\n", 399 hvcsd->vdev->unit_address, 400 hvcsd->p_unit_address, 401 (uint32_t)hvcsd->p_partition_ID); 402 403 spin_unlock_irqrestore(&hvcsd->lock, flags); 404 return count; 405} 406 407static ssize_t hvcs_vterm_state_show(struct device *dev, struct device_attribute *attr, char *buf) 408{ 409 struct vio_dev *viod = to_vio_dev(dev); 410 struct hvcs_struct *hvcsd = from_vio_dev(viod); 411 unsigned long flags; 412 int retval; 413 414 spin_lock_irqsave(&hvcsd->lock, flags); 415 retval = sprintf(buf, "%d\n", hvcsd->connected); 416 spin_unlock_irqrestore(&hvcsd->lock, flags); 417 return retval; 418} 419static DEVICE_ATTR(vterm_state, S_IRUGO | S_IWUSR, 420 hvcs_vterm_state_show, hvcs_vterm_state_store); 421 422static ssize_t hvcs_index_show(struct device *dev, struct device_attribute *attr, char *buf) 423{ 424 struct vio_dev *viod = to_vio_dev(dev); 425 struct hvcs_struct *hvcsd = from_vio_dev(viod); 426 unsigned long flags; 427 int retval; 428 429 spin_lock_irqsave(&hvcsd->lock, flags); 430 retval = sprintf(buf, "%d\n", hvcsd->index); 431 spin_unlock_irqrestore(&hvcsd->lock, flags); 432 return retval; 433} 434 435static DEVICE_ATTR(index, S_IRUGO, hvcs_index_show, NULL); 436 437static struct attribute *hvcs_dev_attrs[] = { 438 &dev_attr_partner_vtys.attr, 439 &dev_attr_partner_clcs.attr, 440 &dev_attr_current_vty.attr, 441 &dev_attr_vterm_state.attr, 442 &dev_attr_index.attr, 443 NULL, 444}; 445 446ATTRIBUTE_GROUPS(hvcs_dev); 447 448static ssize_t rescan_show(struct device_driver *ddp, char *buf) 449{ 450 /* A 1 means it is updating, a 0 means it is done updating */ 451 return snprintf(buf, PAGE_SIZE, "%d\n", hvcs_rescan_status); 452} 453 454static ssize_t rescan_store(struct device_driver *ddp, const char * buf, 455 size_t count) 456{ 457 if ((simple_strtol(buf, NULL, 0) != 1) 458 && (hvcs_rescan_status != 0)) 459 return -EINVAL; 460 461 hvcs_rescan_status = 1; 462 printk(KERN_INFO "HVCS: rescanning partner info for all" 463 " vty-servers.\n"); 464 hvcs_rescan_devices_list(); 465 hvcs_rescan_status = 0; 466 return count; 467} 468 469static DRIVER_ATTR_RW(rescan); 470 471static struct attribute *hvcs_attrs[] = { 472 &driver_attr_rescan.attr, 473 NULL, 474}; 475 476ATTRIBUTE_GROUPS(hvcs); 477 478static void hvcs_kick(void) 479{ 480 hvcs_kicked = 1; 481 wmb(); 482 wake_up_process(hvcs_task); 483} 484 485static void hvcs_unthrottle(struct tty_struct *tty) 486{ 487 struct hvcs_struct *hvcsd = tty->driver_data; 488 unsigned long flags; 489 490 spin_lock_irqsave(&hvcsd->lock, flags); 491 hvcsd->todo_mask |= HVCS_SCHED_READ; 492 spin_unlock_irqrestore(&hvcsd->lock, flags); 493 hvcs_kick(); 494} 495 496static void hvcs_throttle(struct tty_struct *tty) 497{ 498 struct hvcs_struct *hvcsd = tty->driver_data; 499 unsigned long flags; 500 501 spin_lock_irqsave(&hvcsd->lock, flags); 502 vio_disable_interrupts(hvcsd->vdev); 503 spin_unlock_irqrestore(&hvcsd->lock, flags); 504} 505 506/* 507 * If the device is being removed we don't have to worry about this interrupt 508 * handler taking any further interrupts because they are disabled which means 509 * the hvcs_struct will always be valid in this handler. 510 */ 511static irqreturn_t hvcs_handle_interrupt(int irq, void *dev_instance) 512{ 513 struct hvcs_struct *hvcsd = dev_instance; 514 515 spin_lock(&hvcsd->lock); 516 vio_disable_interrupts(hvcsd->vdev); 517 hvcsd->todo_mask |= HVCS_SCHED_READ; 518 spin_unlock(&hvcsd->lock); 519 hvcs_kick(); 520 521 return IRQ_HANDLED; 522} 523 524/* This function must be called with the hvcsd->lock held */ 525static void hvcs_try_write(struct hvcs_struct *hvcsd) 526{ 527 uint32_t unit_address = hvcsd->vdev->unit_address; 528 struct tty_struct *tty = hvcsd->port.tty; 529 int sent; 530 531 if (hvcsd->todo_mask & HVCS_TRY_WRITE) { 532 /* won't send partial writes */ 533 sent = hvc_put_chars(unit_address, 534 &hvcsd->buffer[0], 535 hvcsd->chars_in_buffer ); 536 if (sent > 0) { 537 hvcsd->chars_in_buffer = 0; 538 /* wmb(); */ 539 hvcsd->todo_mask &= ~(HVCS_TRY_WRITE); 540 /* wmb(); */ 541 542 /* 543 * We are still obligated to deliver the data to the 544 * hypervisor even if the tty has been closed because 545 * we committed to delivering it. But don't try to wake 546 * a non-existent tty. 547 */ 548 if (tty) { 549 tty_wakeup(tty); 550 } 551 } 552 } 553} 554 555static int hvcs_io(struct hvcs_struct *hvcsd) 556{ 557 uint32_t unit_address; 558 struct tty_struct *tty; 559 char buf[HVCS_BUFF_LEN] __ALIGNED__; 560 unsigned long flags; 561 int got = 0; 562 563 spin_lock_irqsave(&hvcsd->lock, flags); 564 565 unit_address = hvcsd->vdev->unit_address; 566 tty = hvcsd->port.tty; 567 568 hvcs_try_write(hvcsd); 569 570 if (!tty || tty_throttled(tty)) { 571 hvcsd->todo_mask &= ~(HVCS_READ_MASK); 572 goto bail; 573 } else if (!(hvcsd->todo_mask & (HVCS_READ_MASK))) 574 goto bail; 575 576 /* remove the read masks */ 577 hvcsd->todo_mask &= ~(HVCS_READ_MASK); 578 579 if (tty_buffer_request_room(&hvcsd->port, HVCS_BUFF_LEN) >= HVCS_BUFF_LEN) { 580 got = hvc_get_chars(unit_address, 581 &buf[0], 582 HVCS_BUFF_LEN); 583 tty_insert_flip_string(&hvcsd->port, buf, got); 584 } 585 586 /* Give the TTY time to process the data we just sent. */ 587 if (got) 588 hvcsd->todo_mask |= HVCS_QUICK_READ; 589 590 spin_unlock_irqrestore(&hvcsd->lock, flags); 591 /* This is synch -- FIXME :js: it is not! */ 592 if (got) 593 tty_flip_buffer_push(&hvcsd->port); 594 else { 595 /* Do this _after_ the flip_buffer_push */ 596 spin_lock_irqsave(&hvcsd->lock, flags); 597 vio_enable_interrupts(hvcsd->vdev); 598 spin_unlock_irqrestore(&hvcsd->lock, flags); 599 } 600 601 return hvcsd->todo_mask; 602 603 bail: 604 spin_unlock_irqrestore(&hvcsd->lock, flags); 605 return hvcsd->todo_mask; 606} 607 608static int khvcsd(void *unused) 609{ 610 struct hvcs_struct *hvcsd; 611 int hvcs_todo_mask; 612 613 __set_current_state(TASK_RUNNING); 614 615 do { 616 hvcs_todo_mask = 0; 617 hvcs_kicked = 0; 618 wmb(); 619 620 spin_lock(&hvcs_structs_lock); 621 list_for_each_entry(hvcsd, &hvcs_structs, next) { 622 hvcs_todo_mask |= hvcs_io(hvcsd); 623 } 624 spin_unlock(&hvcs_structs_lock); 625 626 /* 627 * If any of the hvcs adapters want to try a write or quick read 628 * don't schedule(), yield a smidgen then execute the hvcs_io 629 * thread again for those that want the write. 630 */ 631 if (hvcs_todo_mask & (HVCS_TRY_WRITE | HVCS_QUICK_READ)) { 632 yield(); 633 continue; 634 } 635 636 set_current_state(TASK_INTERRUPTIBLE); 637 if (!hvcs_kicked) 638 schedule(); 639 __set_current_state(TASK_RUNNING); 640 } while (!kthread_should_stop()); 641 642 return 0; 643} 644 645static const struct vio_device_id hvcs_driver_table[] = { 646 {"serial-server", "hvterm2"}, 647 { "", "" } 648}; 649MODULE_DEVICE_TABLE(vio, hvcs_driver_table); 650 651static void hvcs_return_index(int index) 652{ 653 /* Paranoia check */ 654 if (!hvcs_index_list) 655 return; 656 if (index < 0 || index >= hvcs_index_count) 657 return; 658 if (hvcs_index_list[index] == -1) 659 return; 660 else 661 hvcs_index_list[index] = -1; 662} 663 664static void hvcs_destruct_port(struct tty_port *p) 665{ 666 struct hvcs_struct *hvcsd = container_of(p, struct hvcs_struct, port); 667 struct completion *comp; 668 unsigned long flags; 669 670 spin_lock(&hvcs_structs_lock); 671 spin_lock_irqsave(&hvcsd->lock, flags); 672 673 comp = hvcsd->destroyed; 674 /* the list_del poisons the pointers */ 675 list_del(&(hvcsd->next)); 676 677 if (hvcsd->connected == 1) { 678 hvcs_partner_free(hvcsd); 679 printk(KERN_INFO "HVCS: Closed vty-server@%X and" 680 " partner vty@%X:%d connection.\n", 681 hvcsd->vdev->unit_address, 682 hvcsd->p_unit_address, 683 (uint32_t)hvcsd->p_partition_ID); 684 } 685 printk(KERN_INFO "HVCS: Destroyed hvcs_struct for vty-server@%X.\n", 686 hvcsd->vdev->unit_address); 687 688 hvcsd->vdev = NULL; 689 690 hvcsd->p_unit_address = 0; 691 hvcsd->p_partition_ID = 0; 692 hvcsd->destroyed = NULL; 693 hvcs_return_index(hvcsd->index); 694 memset(&hvcsd->p_location_code[0], 0x00, HVCS_CLC_LENGTH + 1); 695 696 spin_unlock_irqrestore(&hvcsd->lock, flags); 697 spin_unlock(&hvcs_structs_lock); 698 699 kfree(hvcsd); 700 if (comp) 701 complete(comp); 702} 703 704static const struct tty_port_operations hvcs_port_ops = { 705 .destruct = hvcs_destruct_port, 706}; 707 708static int hvcs_get_index(void) 709{ 710 int i; 711 /* Paranoia check */ 712 if (!hvcs_index_list) { 713 printk(KERN_ERR "HVCS: hvcs_index_list NOT valid!.\n"); 714 return -EFAULT; 715 } 716 /* Find the numerically lowest first free index. */ 717 for(i = 0; i < hvcs_index_count; i++) { 718 if (hvcs_index_list[i] == -1) { 719 hvcs_index_list[i] = 0; 720 return i; 721 } 722 } 723 return -1; 724} 725 726static int hvcs_probe( 727 struct vio_dev *dev, 728 const struct vio_device_id *id) 729{ 730 struct hvcs_struct *hvcsd; 731 int index, rc; 732 733 if (!dev || !id) { 734 printk(KERN_ERR "HVCS: probed with invalid parameter.\n"); 735 return -EPERM; 736 } 737 738 /* Make sure we are properly initialized */ 739 rc = hvcs_initialize(); 740 if (rc) { 741 pr_err("HVCS: Failed to initialize core driver.\n"); 742 return rc; 743 } 744 745 /* early to avoid cleanup on failure */ 746 index = hvcs_get_index(); 747 if (index < 0) { 748 return -EFAULT; 749 } 750 751 hvcsd = kzalloc(sizeof(*hvcsd), GFP_KERNEL); 752 if (!hvcsd) 753 return -ENODEV; 754 755 tty_port_init(&hvcsd->port); 756 hvcsd->port.ops = &hvcs_port_ops; 757 spin_lock_init(&hvcsd->lock); 758 759 hvcsd->vdev = dev; 760 dev_set_drvdata(&dev->dev, hvcsd); 761 762 hvcsd->index = index; 763 764 /* hvcsd->index = ++hvcs_struct_count; */ 765 hvcsd->chars_in_buffer = 0; 766 hvcsd->todo_mask = 0; 767 hvcsd->connected = 0; 768 769 /* 770 * This will populate the hvcs_struct's partner info fields for the 771 * first time. 772 */ 773 if (hvcs_get_pi(hvcsd)) { 774 printk(KERN_ERR "HVCS: Failed to fetch partner" 775 " info for vty-server@%X on device probe.\n", 776 hvcsd->vdev->unit_address); 777 } 778 779 /* 780 * If a user app opens a tty that corresponds to this vty-server before 781 * the hvcs_struct has been added to the devices list then the user app 782 * will get -ENODEV. 783 */ 784 spin_lock(&hvcs_structs_lock); 785 list_add_tail(&(hvcsd->next), &hvcs_structs); 786 spin_unlock(&hvcs_structs_lock); 787 788 printk(KERN_INFO "HVCS: vty-server@%X added to the vio bus.\n", dev->unit_address); 789 790 /* 791 * DON'T enable interrupts here because there is no user to receive the 792 * data. 793 */ 794 return 0; 795} 796 797static void hvcs_remove(struct vio_dev *dev) 798{ 799 struct hvcs_struct *hvcsd = dev_get_drvdata(&dev->dev); 800 DECLARE_COMPLETION_ONSTACK(comp); 801 unsigned long flags; 802 struct tty_struct *tty; 803 804 /* By this time the vty-server won't be getting any more interrupts */ 805 806 spin_lock_irqsave(&hvcsd->lock, flags); 807 808 hvcsd->destroyed = ∁ 809 tty = tty_port_tty_get(&hvcsd->port); 810 811 spin_unlock_irqrestore(&hvcsd->lock, flags); 812 813 /* 814 * The tty should always be valid at this time unless a 815 * simultaneous tty close already cleaned up the hvcs_struct. 816 */ 817 if (tty) { 818 tty_vhangup(tty); 819 tty_kref_put(tty); 820 } 821 822 tty_port_put(&hvcsd->port); 823 wait_for_completion(&comp); 824 printk(KERN_INFO "HVCS: vty-server@%X removed from the" 825 " vio bus.\n", dev->unit_address); 826}; 827 828static struct vio_driver hvcs_vio_driver = { 829 .id_table = hvcs_driver_table, 830 .probe = hvcs_probe, 831 .remove = hvcs_remove, 832 .name = hvcs_driver_name, 833 .driver = { 834 .groups = hvcs_groups, 835 .dev_groups = hvcs_dev_groups, 836 }, 837}; 838 839/* Only called from hvcs_get_pi please */ 840static void hvcs_set_pi(struct hvcs_partner_info *pi, struct hvcs_struct *hvcsd) 841{ 842 hvcsd->p_unit_address = pi->unit_address; 843 hvcsd->p_partition_ID = pi->partition_ID; 844 845 /* copy the null-term char too */ 846 strscpy(hvcsd->p_location_code, pi->location_code, 847 sizeof(hvcsd->p_location_code)); 848} 849 850/* 851 * Traverse the list and add the partner info that is found to the hvcs_struct 852 * struct entry. NOTE: At this time I know that partner info will return a 853 * single entry but in the future there may be multiple partner info entries per 854 * vty-server and you'll want to zero out that list and reset it. If for some 855 * reason you have an old version of this driver but there IS more than one 856 * partner info then hvcsd->p_* will hold the last partner info data from the 857 * firmware query. A good way to update this code would be to replace the three 858 * partner info fields in hvcs_struct with a list of hvcs_partner_info 859 * instances. 860 * 861 * This function must be called with the hvcsd->lock held. 862 */ 863static int hvcs_get_pi(struct hvcs_struct *hvcsd) 864{ 865 struct hvcs_partner_info *pi; 866 uint32_t unit_address = hvcsd->vdev->unit_address; 867 struct list_head head; 868 int retval; 869 870 spin_lock(&hvcs_pi_lock); 871 if (!hvcs_pi_buff) { 872 spin_unlock(&hvcs_pi_lock); 873 return -EFAULT; 874 } 875 retval = hvcs_get_partner_info(unit_address, &head, hvcs_pi_buff); 876 spin_unlock(&hvcs_pi_lock); 877 if (retval) { 878 printk(KERN_ERR "HVCS: Failed to fetch partner" 879 " info for vty-server@%x.\n", unit_address); 880 return retval; 881 } 882 883 /* nixes the values if the partner vty went away */ 884 hvcsd->p_unit_address = 0; 885 hvcsd->p_partition_ID = 0; 886 887 list_for_each_entry(pi, &head, node) 888 hvcs_set_pi(pi, hvcsd); 889 890 hvcs_free_partner_info(&head); 891 return 0; 892} 893 894/* 895 * This function is executed by the driver "rescan" sysfs entry. It shouldn't 896 * be executed elsewhere, in order to prevent deadlock issues. 897 */ 898static int hvcs_rescan_devices_list(void) 899{ 900 struct hvcs_struct *hvcsd; 901 unsigned long flags; 902 903 spin_lock(&hvcs_structs_lock); 904 905 list_for_each_entry(hvcsd, &hvcs_structs, next) { 906 spin_lock_irqsave(&hvcsd->lock, flags); 907 hvcs_get_pi(hvcsd); 908 spin_unlock_irqrestore(&hvcsd->lock, flags); 909 } 910 911 spin_unlock(&hvcs_structs_lock); 912 913 return 0; 914} 915 916/* 917 * Farm this off into its own function because it could be more complex once 918 * multiple partners support is added. This function should be called with 919 * the hvcsd->lock held. 920 */ 921static int hvcs_has_pi(struct hvcs_struct *hvcsd) 922{ 923 if ((!hvcsd->p_unit_address) || (!hvcsd->p_partition_ID)) 924 return 0; 925 return 1; 926} 927 928/* 929 * NOTE: It is possible that the super admin removed a partner vty and then 930 * added a different vty as the new partner. 931 * 932 * This function must be called with the hvcsd->lock held. 933 */ 934static int hvcs_partner_connect(struct hvcs_struct *hvcsd) 935{ 936 int retval; 937 unsigned int unit_address = hvcsd->vdev->unit_address; 938 939 /* 940 * If there wasn't any pi when the device was added it doesn't meant 941 * there isn't any now. This driver isn't notified when a new partner 942 * vty is added to a vty-server so we discover changes on our own. 943 * Please see comments in hvcs_register_connection() for justification 944 * of this bizarre code. 945 */ 946 retval = hvcs_register_connection(unit_address, 947 hvcsd->p_partition_ID, 948 hvcsd->p_unit_address); 949 if (!retval) { 950 hvcsd->connected = 1; 951 return 0; 952 } else if (retval != -EINVAL) 953 return retval; 954 955 /* 956 * As per the spec re-get the pi and try again if -EINVAL after the 957 * first connection attempt. 958 */ 959 if (hvcs_get_pi(hvcsd)) 960 return -ENOMEM; 961 962 if (!hvcs_has_pi(hvcsd)) 963 return -ENODEV; 964 965 retval = hvcs_register_connection(unit_address, 966 hvcsd->p_partition_ID, 967 hvcsd->p_unit_address); 968 if (retval != -EINVAL) { 969 hvcsd->connected = 1; 970 return retval; 971 } 972 973 /* 974 * EBUSY is the most likely scenario though the vty could have been 975 * removed or there really could be an hcall error due to the parameter 976 * data but thanks to ambiguous firmware return codes we can't really 977 * tell. 978 */ 979 printk(KERN_INFO "HVCS: vty-server or partner" 980 " vty is busy. Try again later.\n"); 981 return -EBUSY; 982} 983 984/* This function must be called with the hvcsd->lock held */ 985static void hvcs_partner_free(struct hvcs_struct *hvcsd) 986{ 987 int retval; 988 do { 989 retval = hvcs_free_connection(hvcsd->vdev->unit_address); 990 } while (retval == -EBUSY); 991 hvcsd->connected = 0; 992} 993 994/* This helper function must be called WITHOUT the hvcsd->lock held */ 995static int hvcs_enable_device(struct hvcs_struct *hvcsd, uint32_t unit_address, 996 unsigned int irq, struct vio_dev *vdev) 997{ 998 unsigned long flags; 999 int rc; 1000 1001 /* 1002 * It is possible that the vty-server was removed between the time that 1003 * the conn was registered and now. 1004 */ 1005 rc = request_irq(irq, &hvcs_handle_interrupt, 0, "ibmhvcs", hvcsd); 1006 if (!rc) { 1007 /* 1008 * It is possible the vty-server was removed after the irq was 1009 * requested but before we have time to enable interrupts. 1010 */ 1011 if (vio_enable_interrupts(vdev) == H_SUCCESS) 1012 return 0; 1013 else { 1014 printk(KERN_ERR "HVCS: int enable failed for" 1015 " vty-server@%X.\n", unit_address); 1016 free_irq(irq, hvcsd); 1017 } 1018 } else 1019 printk(KERN_ERR "HVCS: irq req failed for" 1020 " vty-server@%X.\n", unit_address); 1021 1022 spin_lock_irqsave(&hvcsd->lock, flags); 1023 hvcs_partner_free(hvcsd); 1024 spin_unlock_irqrestore(&hvcsd->lock, flags); 1025 1026 return rc; 1027 1028} 1029 1030/* 1031 * This always increments the kref ref count if the call is successful. 1032 * Please remember to dec when you are done with the instance. 1033 * 1034 * NOTICE: Do NOT hold either the hvcs_struct.lock or hvcs_structs_lock when 1035 * calling this function or you will get deadlock. 1036 */ 1037static struct hvcs_struct *hvcs_get_by_index(int index) 1038{ 1039 struct hvcs_struct *hvcsd; 1040 unsigned long flags; 1041 1042 spin_lock(&hvcs_structs_lock); 1043 list_for_each_entry(hvcsd, &hvcs_structs, next) { 1044 spin_lock_irqsave(&hvcsd->lock, flags); 1045 if (hvcsd->index == index) { 1046 tty_port_get(&hvcsd->port); 1047 spin_unlock_irqrestore(&hvcsd->lock, flags); 1048 spin_unlock(&hvcs_structs_lock); 1049 return hvcsd; 1050 } 1051 spin_unlock_irqrestore(&hvcsd->lock, flags); 1052 } 1053 spin_unlock(&hvcs_structs_lock); 1054 1055 return NULL; 1056} 1057 1058static int hvcs_install(struct tty_driver *driver, struct tty_struct *tty) 1059{ 1060 struct hvcs_struct *hvcsd; 1061 struct vio_dev *vdev; 1062 unsigned long unit_address, flags; 1063 unsigned int irq; 1064 int retval; 1065 1066 /* 1067 * Is there a vty-server that shares the same index? 1068 * This function increments the kref index. 1069 */ 1070 hvcsd = hvcs_get_by_index(tty->index); 1071 if (!hvcsd) { 1072 printk(KERN_WARNING "HVCS: open failed, no device associated" 1073 " with tty->index %d.\n", tty->index); 1074 return -ENODEV; 1075 } 1076 1077 spin_lock_irqsave(&hvcsd->lock, flags); 1078 1079 if (hvcsd->connected == 0) { 1080 retval = hvcs_partner_connect(hvcsd); 1081 if (retval) { 1082 spin_unlock_irqrestore(&hvcsd->lock, flags); 1083 printk(KERN_WARNING "HVCS: partner connect failed.\n"); 1084 goto err_put; 1085 } 1086 } 1087 1088 hvcsd->port.count = 0; 1089 hvcsd->port.tty = tty; 1090 tty->driver_data = hvcsd; 1091 1092 memset(&hvcsd->buffer[0], 0x00, HVCS_BUFF_LEN); 1093 1094 /* 1095 * Save these in the spinlock for the enable operations that need them 1096 * outside of the spinlock. 1097 */ 1098 irq = hvcsd->vdev->irq; 1099 vdev = hvcsd->vdev; 1100 unit_address = hvcsd->vdev->unit_address; 1101 1102 hvcsd->todo_mask |= HVCS_SCHED_READ; 1103 spin_unlock_irqrestore(&hvcsd->lock, flags); 1104 1105 /* 1106 * This must be done outside of the spinlock because it requests irqs 1107 * and will grab the spinlock and free the connection if it fails. 1108 */ 1109 retval = hvcs_enable_device(hvcsd, unit_address, irq, vdev); 1110 if (retval) { 1111 printk(KERN_WARNING "HVCS: enable device failed.\n"); 1112 goto err_put; 1113 } 1114 1115 retval = tty_port_install(&hvcsd->port, driver, tty); 1116 if (retval) 1117 goto err_irq; 1118 1119 return 0; 1120err_irq: 1121 spin_lock_irqsave(&hvcsd->lock, flags); 1122 vio_disable_interrupts(hvcsd->vdev); 1123 spin_unlock_irqrestore(&hvcsd->lock, flags); 1124 free_irq(irq, hvcsd); 1125err_put: 1126 tty_port_put(&hvcsd->port); 1127 1128 return retval; 1129} 1130 1131/* 1132 * This is invoked via the tty_open interface when a user app connects to the 1133 * /dev node. 1134 */ 1135static int hvcs_open(struct tty_struct *tty, struct file *filp) 1136{ 1137 struct hvcs_struct *hvcsd = tty->driver_data; 1138 unsigned long flags; 1139 1140 spin_lock_irqsave(&hvcsd->lock, flags); 1141 hvcsd->port.count++; 1142 hvcsd->todo_mask |= HVCS_SCHED_READ; 1143 spin_unlock_irqrestore(&hvcsd->lock, flags); 1144 1145 hvcs_kick(); 1146 1147 printk(KERN_INFO "HVCS: vty-server@%X connection opened.\n", 1148 hvcsd->vdev->unit_address ); 1149 1150 return 0; 1151} 1152 1153static void hvcs_close(struct tty_struct *tty, struct file *filp) 1154{ 1155 struct hvcs_struct *hvcsd; 1156 unsigned long flags; 1157 int irq; 1158 1159 /* 1160 * Is someone trying to close the file associated with this device after 1161 * we have hung up? If so tty->driver_data wouldn't be valid. 1162 */ 1163 if (tty_hung_up_p(filp)) 1164 return; 1165 1166 /* 1167 * No driver_data means that this close was probably issued after a 1168 * failed hvcs_open by the tty layer's release_dev() api and we can just 1169 * exit cleanly. 1170 */ 1171 if (!tty->driver_data) 1172 return; 1173 1174 hvcsd = tty->driver_data; 1175 1176 spin_lock_irqsave(&hvcsd->lock, flags); 1177 if (hvcsd->port.count == 0) { 1178 spin_unlock_irqrestore(&hvcsd->lock, flags); 1179 return; 1180 } else if (--hvcsd->port.count == 0) { 1181 1182 vio_disable_interrupts(hvcsd->vdev); 1183 1184 /* 1185 * NULL this early so that the kernel_thread doesn't try to 1186 * execute any operations on the TTY even though it is obligated 1187 * to deliver any pending I/O to the hypervisor. 1188 */ 1189 hvcsd->port.tty = NULL; 1190 1191 irq = hvcsd->vdev->irq; 1192 spin_unlock_irqrestore(&hvcsd->lock, flags); 1193 1194 tty_wait_until_sent(tty, HVCS_CLOSE_WAIT); 1195 1196 free_irq(irq, hvcsd); 1197 return; 1198 } else if (hvcsd->port.count < 0) { 1199 printk(KERN_ERR "HVCS: vty-server@%X open_count: %d is mismanaged.\n", 1200 hvcsd->vdev->unit_address, hvcsd->port.count); 1201 } 1202 1203 spin_unlock_irqrestore(&hvcsd->lock, flags); 1204} 1205 1206static void hvcs_cleanup(struct tty_struct * tty) 1207{ 1208 struct hvcs_struct *hvcsd = tty->driver_data; 1209 1210 /* 1211 * This line is important because it tells hvcs_open that this 1212 * device needs to be re-configured the next time hvcs_open is 1213 * called. 1214 */ 1215 tty->driver_data = NULL; 1216 1217 tty_port_put(&hvcsd->port); 1218} 1219 1220static void hvcs_hangup(struct tty_struct * tty) 1221{ 1222 struct hvcs_struct *hvcsd = tty->driver_data; 1223 unsigned long flags; 1224 int irq; 1225 1226 spin_lock_irqsave(&hvcsd->lock, flags); 1227 1228 /* 1229 * Don't kref put inside the spinlock because the destruction 1230 * callback may use the spinlock and it may get called before the 1231 * spinlock has been released. 1232 */ 1233 vio_disable_interrupts(hvcsd->vdev); 1234 1235 hvcsd->todo_mask = 0; 1236 hvcsd->port.tty = NULL; 1237 hvcsd->port.count = 0; 1238 1239 /* This will drop any buffered data on the floor which is OK in a hangup 1240 * scenario. */ 1241 memset(&hvcsd->buffer[0], 0x00, HVCS_BUFF_LEN); 1242 hvcsd->chars_in_buffer = 0; 1243 1244 irq = hvcsd->vdev->irq; 1245 1246 spin_unlock_irqrestore(&hvcsd->lock, flags); 1247 1248 free_irq(irq, hvcsd); 1249} 1250 1251/* 1252 * NOTE: This is almost always from_user since user level apps interact with the 1253 * /dev nodes. I'm trusting that if hvcs_write gets called and interrupted by 1254 * hvcs_remove (which removes the target device and executes tty_hangup()) that 1255 * tty_hangup will allow hvcs_write time to complete execution before it 1256 * terminates our device. 1257 */ 1258static ssize_t hvcs_write(struct tty_struct *tty, const u8 *buf, size_t count) 1259{ 1260 struct hvcs_struct *hvcsd = tty->driver_data; 1261 unsigned int unit_address; 1262 const unsigned char *charbuf; 1263 unsigned long flags; 1264 size_t total_sent = 0; 1265 size_t tosend = 0; 1266 int result = 0; 1267 1268 /* 1269 * If they don't check the return code off of their open they may 1270 * attempt this even if there is no connected device. 1271 */ 1272 if (!hvcsd) 1273 return -ENODEV; 1274 1275 /* Reasonable size to prevent user level flooding */ 1276 if (count > HVCS_MAX_FROM_USER) { 1277 printk(KERN_WARNING "HVCS write: count being truncated to" 1278 " HVCS_MAX_FROM_USER.\n"); 1279 count = HVCS_MAX_FROM_USER; 1280 } 1281 1282 charbuf = buf; 1283 1284 spin_lock_irqsave(&hvcsd->lock, flags); 1285 1286 /* 1287 * Somehow an open succeeded but the device was removed or the 1288 * connection terminated between the vty-server and partner vty during 1289 * the middle of a write operation? This is a crummy place to do this 1290 * but we want to keep it all in the spinlock. 1291 */ 1292 if (hvcsd->port.count <= 0) { 1293 spin_unlock_irqrestore(&hvcsd->lock, flags); 1294 return -ENODEV; 1295 } 1296 1297 unit_address = hvcsd->vdev->unit_address; 1298 1299 while (count > 0) { 1300 tosend = min_t(size_t, count, 1301 (HVCS_BUFF_LEN - hvcsd->chars_in_buffer)); 1302 /* 1303 * No more space, this probably means that the last call to 1304 * hvcs_write() didn't succeed and the buffer was filled up. 1305 */ 1306 if (!tosend) 1307 break; 1308 1309 memcpy(&hvcsd->buffer[hvcsd->chars_in_buffer], 1310 &charbuf[total_sent], 1311 tosend); 1312 1313 hvcsd->chars_in_buffer += tosend; 1314 1315 result = 0; 1316 1317 /* 1318 * If this is true then we don't want to try writing to the 1319 * hypervisor because that is the kernel_threads job now. We'll 1320 * just add to the buffer. 1321 */ 1322 if (!(hvcsd->todo_mask & HVCS_TRY_WRITE)) 1323 /* won't send partial writes */ 1324 result = hvc_put_chars(unit_address, 1325 &hvcsd->buffer[0], 1326 hvcsd->chars_in_buffer); 1327 1328 /* 1329 * Since we know we have enough room in hvcsd->buffer for 1330 * tosend we record that it was sent regardless of whether the 1331 * hypervisor actually took it because we have it buffered. 1332 */ 1333 total_sent+=tosend; 1334 count-=tosend; 1335 if (result == 0) { 1336 hvcsd->todo_mask |= HVCS_TRY_WRITE; 1337 hvcs_kick(); 1338 break; 1339 } 1340 1341 hvcsd->chars_in_buffer = 0; 1342 /* 1343 * Test after the chars_in_buffer reset otherwise this could 1344 * deadlock our writes if hvc_put_chars fails. 1345 */ 1346 if (result < 0) 1347 break; 1348 } 1349 1350 spin_unlock_irqrestore(&hvcsd->lock, flags); 1351 1352 if (result == -1) 1353 return -EIO; 1354 else 1355 return total_sent; 1356} 1357 1358/* 1359 * This is really asking how much can we guarantee that we can send or that we 1360 * absolutely WILL BUFFER if we can't send it. This driver MUST honor the 1361 * return value, hence the reason for hvcs_struct buffering. 1362 */ 1363static unsigned int hvcs_write_room(struct tty_struct *tty) 1364{ 1365 struct hvcs_struct *hvcsd = tty->driver_data; 1366 1367 if (!hvcsd || hvcsd->port.count <= 0) 1368 return 0; 1369 1370 return HVCS_BUFF_LEN - hvcsd->chars_in_buffer; 1371} 1372 1373static unsigned int hvcs_chars_in_buffer(struct tty_struct *tty) 1374{ 1375 struct hvcs_struct *hvcsd = tty->driver_data; 1376 1377 return hvcsd->chars_in_buffer; 1378} 1379 1380static const struct tty_operations hvcs_ops = { 1381 .install = hvcs_install, 1382 .open = hvcs_open, 1383 .close = hvcs_close, 1384 .cleanup = hvcs_cleanup, 1385 .hangup = hvcs_hangup, 1386 .write = hvcs_write, 1387 .write_room = hvcs_write_room, 1388 .chars_in_buffer = hvcs_chars_in_buffer, 1389 .unthrottle = hvcs_unthrottle, 1390 .throttle = hvcs_throttle, 1391}; 1392 1393static int hvcs_alloc_index_list(int n) 1394{ 1395 int i; 1396 1397 hvcs_index_list = kmalloc_array(n, sizeof(hvcs_index_count), 1398 GFP_KERNEL); 1399 if (!hvcs_index_list) 1400 return -ENOMEM; 1401 hvcs_index_count = n; 1402 for (i = 0; i < hvcs_index_count; i++) 1403 hvcs_index_list[i] = -1; 1404 return 0; 1405} 1406 1407static void hvcs_free_index_list(void) 1408{ 1409 /* Paranoia check to be thorough. */ 1410 kfree(hvcs_index_list); 1411 hvcs_index_list = NULL; 1412 hvcs_index_count = 0; 1413} 1414 1415static int hvcs_initialize(void) 1416{ 1417 int rc, num_ttys_to_alloc; 1418 1419 mutex_lock(&hvcs_init_mutex); 1420 if (hvcs_task) { 1421 mutex_unlock(&hvcs_init_mutex); 1422 return 0; 1423 } 1424 1425 /* Has the user specified an overload with an insmod param? */ 1426 if (hvcs_parm_num_devs <= 0 || 1427 (hvcs_parm_num_devs > HVCS_MAX_SERVER_ADAPTERS)) { 1428 num_ttys_to_alloc = HVCS_DEFAULT_SERVER_ADAPTERS; 1429 } else 1430 num_ttys_to_alloc = hvcs_parm_num_devs; 1431 1432 hvcs_tty_driver = tty_alloc_driver(num_ttys_to_alloc, 1433 TTY_DRIVER_REAL_RAW); 1434 if (IS_ERR(hvcs_tty_driver)) { 1435 mutex_unlock(&hvcs_init_mutex); 1436 return PTR_ERR(hvcs_tty_driver); 1437 } 1438 1439 if (hvcs_alloc_index_list(num_ttys_to_alloc)) { 1440 rc = -ENOMEM; 1441 goto index_fail; 1442 } 1443 1444 hvcs_tty_driver->driver_name = hvcs_driver_name; 1445 hvcs_tty_driver->name = hvcs_device_node; 1446 1447 /* 1448 * We'll let the system assign us a major number, indicated by leaving 1449 * it blank. 1450 */ 1451 1452 hvcs_tty_driver->minor_start = HVCS_MINOR_START; 1453 hvcs_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM; 1454 1455 /* 1456 * We role our own so that we DONT ECHO. We can't echo because the 1457 * device we are connecting to already echoes by default and this would 1458 * throw us into a horrible recursive echo-echo-echo loop. 1459 */ 1460 hvcs_tty_driver->init_termios = hvcs_tty_termios; 1461 1462 tty_set_operations(hvcs_tty_driver, &hvcs_ops); 1463 1464 /* 1465 * The following call will result in sysfs entries that denote the 1466 * dynamically assigned major and minor numbers for our devices. 1467 */ 1468 if (tty_register_driver(hvcs_tty_driver)) { 1469 printk(KERN_ERR "HVCS: registration as a tty driver failed.\n"); 1470 rc = -EIO; 1471 goto register_fail; 1472 } 1473 1474 hvcs_pi_buff = (unsigned long *) __get_free_page(GFP_KERNEL); 1475 if (!hvcs_pi_buff) { 1476 rc = -ENOMEM; 1477 goto buff_alloc_fail; 1478 } 1479 1480 hvcs_task = kthread_run(khvcsd, NULL, "khvcsd"); 1481 if (IS_ERR(hvcs_task)) { 1482 printk(KERN_ERR "HVCS: khvcsd creation failed.\n"); 1483 rc = -EIO; 1484 goto kthread_fail; 1485 } 1486 mutex_unlock(&hvcs_init_mutex); 1487 return 0; 1488 1489kthread_fail: 1490 free_page((unsigned long)hvcs_pi_buff); 1491buff_alloc_fail: 1492 tty_unregister_driver(hvcs_tty_driver); 1493register_fail: 1494 hvcs_free_index_list(); 1495index_fail: 1496 tty_driver_kref_put(hvcs_tty_driver); 1497 hvcs_tty_driver = NULL; 1498 mutex_unlock(&hvcs_init_mutex); 1499 return rc; 1500} 1501 1502static int __init hvcs_module_init(void) 1503{ 1504 int rc = vio_register_driver(&hvcs_vio_driver); 1505 if (rc) { 1506 printk(KERN_ERR "HVCS: can't register vio driver\n"); 1507 return rc; 1508 } 1509 1510 pr_info("HVCS: Driver registered.\n"); 1511 1512 return 0; 1513} 1514 1515static void __exit hvcs_module_exit(void) 1516{ 1517 /* 1518 * This driver receives hvcs_remove callbacks for each device upon 1519 * module removal. 1520 */ 1521 vio_unregister_driver(&hvcs_vio_driver); 1522 if (!hvcs_task) 1523 return; 1524 1525 /* 1526 * This synchronous operation will wake the khvcsd kthread if it is 1527 * asleep and will return when khvcsd has terminated. 1528 */ 1529 kthread_stop(hvcs_task); 1530 1531 spin_lock(&hvcs_pi_lock); 1532 free_page((unsigned long)hvcs_pi_buff); 1533 hvcs_pi_buff = NULL; 1534 spin_unlock(&hvcs_pi_lock); 1535 1536 tty_unregister_driver(hvcs_tty_driver); 1537 1538 hvcs_free_index_list(); 1539 1540 tty_driver_kref_put(hvcs_tty_driver); 1541 1542 printk(KERN_INFO "HVCS: driver module removed.\n"); 1543} 1544 1545module_init(hvcs_module_init); 1546module_exit(hvcs_module_exit); 1547