1 /* $Id: parport_share.c,v 1.15 1998/01/11 12:06:17 philip Exp $ 2 * Parallel-port resource manager code. 3 * 4 * Authors: David Campbell <campbell@tirian.che.curtin.edu.au> 5 * Tim Waugh <tim@cyberelk.demon.co.uk> 6 * Jose Renau <renau@acm.org> 7 * Philip Blundell <philb@gnu.org> 8 * Andrea Arcangeli 9 * 10 * based on work by Grant Guenther <grant@torque.net> 11 * and Philip Blundell 12 * 13 * Any part of this program may be used in documents licensed under 14 * the GNU Free Documentation License, Version 1.1 or any later version 15 * published by the Free Software Foundation. 16 */ 17 18 #undef PARPORT_DEBUG_SHARING /* undef for production */ 19 20 #include <linux/module.h> 21 #include <linux/string.h> 22 #include <linux/threads.h> 23 #include <linux/parport.h> 24 #include <linux/delay.h> 25 #include <linux/errno.h> 26 #include <linux/interrupt.h> 27 #include <linux/ioport.h> 28 #include <linux/kernel.h> 29 #include <linux/slab.h> 30 #include <linux/sched.h> 31 #include <linux/kmod.h> 32 33 #include <linux/spinlock.h> 34 #include <linux/mutex.h> 35 #include <asm/irq.h> 36 37 #undef PARPORT_PARANOID 38 39 #define PARPORT_DEFAULT_TIMESLICE (HZ/5) 40 41 unsigned long parport_default_timeslice = PARPORT_DEFAULT_TIMESLICE; 42 int parport_default_spintime = DEFAULT_SPIN_TIME; 43 44 static LIST_HEAD(portlist); 45 static DEFINE_SPINLOCK(parportlist_lock); 46 47 /* list of all allocated ports, sorted by ->number */ 48 static LIST_HEAD(all_ports); 49 static DEFINE_SPINLOCK(full_list_lock); 50 51 static LIST_HEAD(drivers); 52 53 static DEFINE_MUTEX(registration_lock); 54 55 /* What you can do to a port that's gone away.. */ 56 static void dead_write_lines (struct parport *p, unsigned char b){} 57 static unsigned char dead_read_lines (struct parport *p) { return 0; } 58 static unsigned char dead_frob_lines (struct parport *p, unsigned char b, 59 unsigned char c) { return 0; } 60 static void dead_onearg (struct parport *p){} 61 static void dead_initstate (struct pardevice *d, struct parport_state *s) { } 62 static void dead_state (struct parport *p, struct parport_state *s) { } 63 static size_t dead_write (struct parport *p, const void *b, size_t l, int f) 64 { return 0; } 65 static size_t dead_read (struct parport *p, void *b, size_t l, int f) 66 { return 0; } 67 static struct parport_operations dead_ops = { 68 .write_data = dead_write_lines, /* data */ 69 .read_data = dead_read_lines, 70 71 .write_control = dead_write_lines, /* control */ 72 .read_control = dead_read_lines, 73 .frob_control = dead_frob_lines, 74 75 .read_status = dead_read_lines, /* status */ 76 77 .enable_irq = dead_onearg, /* enable_irq */ 78 .disable_irq = dead_onearg, /* disable_irq */ 79 80 .data_forward = dead_onearg, /* data_forward */ 81 .data_reverse = dead_onearg, /* data_reverse */ 82 83 .init_state = dead_initstate, /* init_state */ 84 .save_state = dead_state, 85 .restore_state = dead_state, 86 87 .epp_write_data = dead_write, /* epp */ 88 .epp_read_data = dead_read, 89 .epp_write_addr = dead_write, 90 .epp_read_addr = dead_read, 91 92 .ecp_write_data = dead_write, /* ecp */ 93 .ecp_read_data = dead_read, 94 .ecp_write_addr = dead_write, 95 96 .compat_write_data = dead_write, /* compat */ 97 .nibble_read_data = dead_read, /* nibble */ 98 .byte_read_data = dead_read, /* byte */ 99 100 .owner = NULL, 101 }; 102 103 /* Call attach(port) for each registered driver. */ 104 static void attach_driver_chain(struct parport *port) 105 { 106 /* caller has exclusive registration_lock */ 107 struct parport_driver *drv; 108 list_for_each_entry(drv, &drivers, list) 109 drv->attach(port); 110 } 111 112 /* Call detach(port) for each registered driver. */ 113 static void detach_driver_chain(struct parport *port) 114 { 115 struct parport_driver *drv; 116 /* caller has exclusive registration_lock */ 117 list_for_each_entry(drv, &drivers, list) 118 drv->detach (port); 119 } 120 121 /* Ask kmod for some lowlevel drivers. */ 122 static void get_lowlevel_driver (void) 123 { 124 /* There is no actual module called this: you should set 125 * up an alias for modutils. */ 126 request_module ("parport_lowlevel"); 127 } 128 129 /** 130 * parport_register_driver - register a parallel port device driver 131 * @drv: structure describing the driver 132 * 133 * This can be called by a parallel port device driver in order 134 * to receive notifications about ports being found in the 135 * system, as well as ports no longer available. 136 * 137 * The @drv structure is allocated by the caller and must not be 138 * deallocated until after calling parport_unregister_driver(). 139 * 140 * The driver's attach() function may block. The port that 141 * attach() is given will be valid for the duration of the 142 * callback, but if the driver wants to take a copy of the 143 * pointer it must call parport_get_port() to do so. Calling 144 * parport_register_device() on that port will do this for you. 145 * 146 * The driver's detach() function may block. The port that 147 * detach() is given will be valid for the duration of the 148 * callback, but if the driver wants to take a copy of the 149 * pointer it must call parport_get_port() to do so. 150 * 151 * Returns 0 on success. Currently it always succeeds. 152 **/ 153 154 int parport_register_driver (struct parport_driver *drv) 155 { 156 struct parport *port; 157 158 if (list_empty(&portlist)) 159 get_lowlevel_driver (); 160 161 mutex_lock(®istration_lock); 162 list_for_each_entry(port, &portlist, list) 163 drv->attach(port); 164 list_add(&drv->list, &drivers); 165 mutex_unlock(®istration_lock); 166 167 return 0; 168 } 169 170 /** 171 * parport_unregister_driver - deregister a parallel port device driver 172 * @drv: structure describing the driver that was given to 173 * parport_register_driver() 174 * 175 * This should be called by a parallel port device driver that 176 * has registered itself using parport_register_driver() when it 177 * is about to be unloaded. 178 * 179 * When it returns, the driver's attach() routine will no longer 180 * be called, and for each port that attach() was called for, the 181 * detach() routine will have been called. 182 * 183 * All the driver's attach() and detach() calls are guaranteed to have 184 * finished by the time this function returns. 185 **/ 186 187 void parport_unregister_driver (struct parport_driver *drv) 188 { 189 struct parport *port; 190 191 mutex_lock(®istration_lock); 192 list_del_init(&drv->list); 193 list_for_each_entry(port, &portlist, list) 194 drv->detach(port); 195 mutex_unlock(®istration_lock); 196 } 197 198 static void free_port (struct parport *port) 199 { 200 int d; 201 spin_lock(&full_list_lock); 202 list_del(&port->full_list); 203 spin_unlock(&full_list_lock); 204 for (d = 0; d < 5; d++) { 205 kfree(port->probe_info[d].class_name); 206 kfree(port->probe_info[d].mfr); 207 kfree(port->probe_info[d].model); 208 kfree(port->probe_info[d].cmdset); 209 kfree(port->probe_info[d].description); 210 } 211 212 kfree(port->name); 213 kfree(port); 214 } 215 216 /** 217 * parport_get_port - increment a port's reference count 218 * @port: the port 219 * 220 * This ensures that a struct parport pointer remains valid 221 * until the matching parport_put_port() call. 222 **/ 223 224 struct parport *parport_get_port (struct parport *port) 225 { 226 atomic_inc (&port->ref_count); 227 return port; 228 } 229 230 /** 231 * parport_put_port - decrement a port's reference count 232 * @port: the port 233 * 234 * This should be called once for each call to parport_get_port(), 235 * once the port is no longer needed. 236 **/ 237 238 void parport_put_port (struct parport *port) 239 { 240 if (atomic_dec_and_test (&port->ref_count)) 241 /* Can destroy it now. */ 242 free_port (port); 243 244 return; 245 } 246 247 /** 248 * parport_register_port - register a parallel port 249 * @base: base I/O address 250 * @irq: IRQ line 251 * @dma: DMA channel 252 * @ops: pointer to the port driver's port operations structure 253 * 254 * When a parallel port (lowlevel) driver finds a port that 255 * should be made available to parallel port device drivers, it 256 * should call parport_register_port(). The @base, @irq, and 257 * @dma parameters are for the convenience of port drivers, and 258 * for ports where they aren't meaningful needn't be set to 259 * anything special. They can be altered afterwards by adjusting 260 * the relevant members of the parport structure that is returned 261 * and represents the port. They should not be tampered with 262 * after calling parport_announce_port, however. 263 * 264 * If there are parallel port device drivers in the system that 265 * have registered themselves using parport_register_driver(), 266 * they are not told about the port at this time; that is done by 267 * parport_announce_port(). 268 * 269 * The @ops structure is allocated by the caller, and must not be 270 * deallocated before calling parport_remove_port(). 271 * 272 * If there is no memory to allocate a new parport structure, 273 * this function will return %NULL. 274 **/ 275 276 struct parport *parport_register_port(unsigned long base, int irq, int dma, 277 struct parport_operations *ops) 278 { 279 struct list_head *l; 280 struct parport *tmp; 281 int num; 282 int device; 283 char *name; 284 285 tmp = kmalloc(sizeof(struct parport), GFP_KERNEL); 286 if (!tmp) { 287 printk(KERN_WARNING "parport: memory squeeze\n"); 288 return NULL; 289 } 290 291 /* Init our structure */ 292 memset(tmp, 0, sizeof(struct parport)); 293 tmp->base = base; 294 tmp->irq = irq; 295 tmp->dma = dma; 296 tmp->muxport = tmp->daisy = tmp->muxsel = -1; 297 tmp->modes = 0; 298 INIT_LIST_HEAD(&tmp->list); 299 tmp->devices = tmp->cad = NULL; 300 tmp->flags = 0; 301 tmp->ops = ops; 302 tmp->physport = tmp; 303 memset (tmp->probe_info, 0, 5 * sizeof (struct parport_device_info)); 304 rwlock_init(&tmp->cad_lock); 305 spin_lock_init(&tmp->waitlist_lock); 306 spin_lock_init(&tmp->pardevice_lock); 307 tmp->ieee1284.mode = IEEE1284_MODE_COMPAT; 308 tmp->ieee1284.phase = IEEE1284_PH_FWD_IDLE; 309 init_MUTEX_LOCKED (&tmp->ieee1284.irq); /* actually a semaphore at 0 */ 310 tmp->spintime = parport_default_spintime; 311 atomic_set (&tmp->ref_count, 1); 312 INIT_LIST_HEAD(&tmp->full_list); 313 314 name = kmalloc(15, GFP_KERNEL); 315 if (!name) { 316 printk(KERN_ERR "parport: memory squeeze\n"); 317 kfree(tmp); 318 return NULL; 319 } 320 /* Search for the lowest free parport number. */ 321 322 spin_lock(&full_list_lock); 323 for (l = all_ports.next, num = 0; l != &all_ports; l = l->next, num++) { 324 struct parport *p = list_entry(l, struct parport, full_list); 325 if (p->number != num) 326 break; 327 } 328 tmp->portnum = tmp->number = num; 329 list_add_tail(&tmp->full_list, l); 330 spin_unlock(&full_list_lock); 331 332 /* 333 * Now that the portnum is known finish doing the Init. 334 */ 335 sprintf(name, "parport%d", tmp->portnum = tmp->number); 336 tmp->name = name; 337 338 for (device = 0; device < 5; device++) 339 /* assume the worst */ 340 tmp->probe_info[device].class = PARPORT_CLASS_LEGACY; 341 342 tmp->waithead = tmp->waittail = NULL; 343 344 return tmp; 345 } 346 347 /** 348 * parport_announce_port - tell device drivers about a parallel port 349 * @port: parallel port to announce 350 * 351 * After a port driver has registered a parallel port with 352 * parport_register_port, and performed any necessary 353 * initialisation or adjustments, it should call 354 * parport_announce_port() in order to notify all device drivers 355 * that have called parport_register_driver(). Their attach() 356 * functions will be called, with @port as the parameter. 357 **/ 358 359 void parport_announce_port (struct parport *port) 360 { 361 int i; 362 363 #ifdef CONFIG_PARPORT_1284 364 /* Analyse the IEEE1284.3 topology of the port. */ 365 parport_daisy_init(port); 366 #endif 367 368 parport_proc_register(port); 369 mutex_lock(®istration_lock); 370 spin_lock_irq(&parportlist_lock); 371 list_add_tail(&port->list, &portlist); 372 for (i = 1; i < 3; i++) { 373 struct parport *slave = port->slaves[i-1]; 374 if (slave) 375 list_add_tail(&slave->list, &portlist); 376 } 377 spin_unlock_irq(&parportlist_lock); 378 379 /* Let drivers know that new port(s) has arrived. */ 380 attach_driver_chain (port); 381 for (i = 1; i < 3; i++) { 382 struct parport *slave = port->slaves[i-1]; 383 if (slave) 384 attach_driver_chain(slave); 385 } 386 mutex_unlock(®istration_lock); 387 } 388 389 /** 390 * parport_remove_port - deregister a parallel port 391 * @port: parallel port to deregister 392 * 393 * When a parallel port driver is forcibly unloaded, or a 394 * parallel port becomes inaccessible, the port driver must call 395 * this function in order to deal with device drivers that still 396 * want to use it. 397 * 398 * The parport structure associated with the port has its 399 * operations structure replaced with one containing 'null' 400 * operations that return errors or just don't do anything. 401 * 402 * Any drivers that have registered themselves using 403 * parport_register_driver() are notified that the port is no 404 * longer accessible by having their detach() routines called 405 * with @port as the parameter. 406 **/ 407 408 void parport_remove_port(struct parport *port) 409 { 410 int i; 411 412 mutex_lock(®istration_lock); 413 414 /* Spread the word. */ 415 detach_driver_chain (port); 416 417 #ifdef CONFIG_PARPORT_1284 418 /* Forget the IEEE1284.3 topology of the port. */ 419 parport_daisy_fini(port); 420 for (i = 1; i < 3; i++) { 421 struct parport *slave = port->slaves[i-1]; 422 if (!slave) 423 continue; 424 detach_driver_chain(slave); 425 parport_daisy_fini(slave); 426 } 427 #endif 428 429 port->ops = &dead_ops; 430 spin_lock(&parportlist_lock); 431 list_del_init(&port->list); 432 for (i = 1; i < 3; i++) { 433 struct parport *slave = port->slaves[i-1]; 434 if (slave) 435 list_del_init(&slave->list); 436 } 437 spin_unlock(&parportlist_lock); 438 439 mutex_unlock(®istration_lock); 440 441 parport_proc_unregister(port); 442 443 for (i = 1; i < 3; i++) { 444 struct parport *slave = port->slaves[i-1]; 445 if (slave) 446 parport_put_port(slave); 447 } 448 } 449 450 /** 451 * parport_register_device - register a device on a parallel port 452 * @port: port to which the device is attached 453 * @name: a name to refer to the device 454 * @pf: preemption callback 455 * @kf: kick callback (wake-up) 456 * @irq_func: interrupt handler 457 * @flags: registration flags 458 * @handle: data for callback functions 459 * 460 * This function, called by parallel port device drivers, 461 * declares that a device is connected to a port, and tells the 462 * system all it needs to know. 463 * 464 * The @name is allocated by the caller and must not be 465 * deallocated until the caller calls @parport_unregister_device 466 * for that device. 467 * 468 * The preemption callback function, @pf, is called when this 469 * device driver has claimed access to the port but another 470 * device driver wants to use it. It is given @handle as its 471 * parameter, and should return zero if it is willing for the 472 * system to release the port to another driver on its behalf. 473 * If it wants to keep control of the port it should return 474 * non-zero, and no action will be taken. It is good manners for 475 * the driver to try to release the port at the earliest 476 * opportunity after its preemption callback rejects a preemption 477 * attempt. Note that if a preemption callback is happy for 478 * preemption to go ahead, there is no need to release the port; 479 * it is done automatically. This function may not block, as it 480 * may be called from interrupt context. If the device driver 481 * does not support preemption, @pf can be %NULL. 482 * 483 * The wake-up ("kick") callback function, @kf, is called when 484 * the port is available to be claimed for exclusive access; that 485 * is, parport_claim() is guaranteed to succeed when called from 486 * inside the wake-up callback function. If the driver wants to 487 * claim the port it should do so; otherwise, it need not take 488 * any action. This function may not block, as it may be called 489 * from interrupt context. If the device driver does not want to 490 * be explicitly invited to claim the port in this way, @kf can 491 * be %NULL. 492 * 493 * The interrupt handler, @irq_func, is called when an interrupt 494 * arrives from the parallel port. Note that if a device driver 495 * wants to use interrupts it should use parport_enable_irq(), 496 * and can also check the irq member of the parport structure 497 * representing the port. 498 * 499 * The parallel port (lowlevel) driver is the one that has called 500 * request_irq() and whose interrupt handler is called first. 501 * This handler does whatever needs to be done to the hardware to 502 * acknowledge the interrupt (for PC-style ports there is nothing 503 * special to be done). It then tells the IEEE 1284 code about 504 * the interrupt, which may involve reacting to an IEEE 1284 505 * event depending on the current IEEE 1284 phase. After this, 506 * it calls @irq_func. Needless to say, @irq_func will be called 507 * from interrupt context, and may not block. 508 * 509 * The %PARPORT_DEV_EXCL flag is for preventing port sharing, and 510 * so should only be used when sharing the port with other device 511 * drivers is impossible and would lead to incorrect behaviour. 512 * Use it sparingly! Normally, @flags will be zero. 513 * 514 * This function returns a pointer to a structure that represents 515 * the device on the port, or %NULL if there is not enough memory 516 * to allocate space for that structure. 517 **/ 518 519 struct pardevice * 520 parport_register_device(struct parport *port, const char *name, 521 int (*pf)(void *), void (*kf)(void *), 522 void (*irq_func)(int, void *), 523 int flags, void *handle) 524 { 525 struct pardevice *tmp; 526 527 if (port->physport->flags & PARPORT_FLAG_EXCL) { 528 /* An exclusive device is registered. */ 529 printk (KERN_DEBUG "%s: no more devices allowed\n", 530 port->name); 531 return NULL; 532 } 533 534 if (flags & PARPORT_DEV_LURK) { 535 if (!pf || !kf) { 536 printk(KERN_INFO "%s: refused to register lurking device (%s) without callbacks\n", port->name, name); 537 return NULL; 538 } 539 } 540 541 /* We up our own module reference count, and that of the port 542 on which a device is to be registered, to ensure that 543 neither of us gets unloaded while we sleep in (e.g.) 544 kmalloc. 545 */ 546 if (!try_module_get(port->ops->owner)) { 547 return NULL; 548 } 549 550 parport_get_port (port); 551 552 tmp = kmalloc(sizeof(struct pardevice), GFP_KERNEL); 553 if (tmp == NULL) { 554 printk(KERN_WARNING "%s: memory squeeze, couldn't register %s.\n", port->name, name); 555 goto out; 556 } 557 558 tmp->state = kmalloc(sizeof(struct parport_state), GFP_KERNEL); 559 if (tmp->state == NULL) { 560 printk(KERN_WARNING "%s: memory squeeze, couldn't register %s.\n", port->name, name); 561 goto out_free_pardevice; 562 } 563 564 tmp->name = name; 565 tmp->port = port; 566 tmp->daisy = -1; 567 tmp->preempt = pf; 568 tmp->wakeup = kf; 569 tmp->private = handle; 570 tmp->flags = flags; 571 tmp->irq_func = irq_func; 572 tmp->waiting = 0; 573 tmp->timeout = 5 * HZ; 574 575 /* Chain this onto the list */ 576 tmp->prev = NULL; 577 /* 578 * This function must not run from an irq handler so we don' t need 579 * to clear irq on the local CPU. -arca 580 */ 581 spin_lock(&port->physport->pardevice_lock); 582 583 if (flags & PARPORT_DEV_EXCL) { 584 if (port->physport->devices) { 585 spin_unlock (&port->physport->pardevice_lock); 586 printk (KERN_DEBUG 587 "%s: cannot grant exclusive access for " 588 "device %s\n", port->name, name); 589 goto out_free_all; 590 } 591 port->flags |= PARPORT_FLAG_EXCL; 592 } 593 594 tmp->next = port->physport->devices; 595 wmb(); /* Make sure that tmp->next is written before it's 596 added to the list; see comments marked 'no locking 597 required' */ 598 if (port->physport->devices) 599 port->physport->devices->prev = tmp; 600 port->physport->devices = tmp; 601 spin_unlock(&port->physport->pardevice_lock); 602 603 init_waitqueue_head(&tmp->wait_q); 604 tmp->timeslice = parport_default_timeslice; 605 tmp->waitnext = tmp->waitprev = NULL; 606 607 /* 608 * This has to be run as last thing since init_state may need other 609 * pardevice fields. -arca 610 */ 611 port->ops->init_state(tmp, tmp->state); 612 parport_device_proc_register(tmp); 613 return tmp; 614 615 out_free_all: 616 kfree(tmp->state); 617 out_free_pardevice: 618 kfree(tmp); 619 out: 620 parport_put_port (port); 621 module_put(port->ops->owner); 622 623 return NULL; 624 } 625 626 /** 627 * parport_unregister_device - deregister a device on a parallel port 628 * @dev: pointer to structure representing device 629 * 630 * This undoes the effect of parport_register_device(). 631 **/ 632 633 void parport_unregister_device(struct pardevice *dev) 634 { 635 struct parport *port; 636 637 #ifdef PARPORT_PARANOID 638 if (dev == NULL) { 639 printk(KERN_ERR "parport_unregister_device: passed NULL\n"); 640 return; 641 } 642 #endif 643 644 parport_device_proc_unregister(dev); 645 646 port = dev->port->physport; 647 648 if (port->cad == dev) { 649 printk(KERN_DEBUG "%s: %s forgot to release port\n", 650 port->name, dev->name); 651 parport_release (dev); 652 } 653 654 spin_lock(&port->pardevice_lock); 655 if (dev->next) 656 dev->next->prev = dev->prev; 657 if (dev->prev) 658 dev->prev->next = dev->next; 659 else 660 port->devices = dev->next; 661 662 if (dev->flags & PARPORT_DEV_EXCL) 663 port->flags &= ~PARPORT_FLAG_EXCL; 664 665 spin_unlock(&port->pardevice_lock); 666 667 /* Make sure we haven't left any pointers around in the wait 668 * list. */ 669 spin_lock (&port->waitlist_lock); 670 if (dev->waitprev || dev->waitnext || port->waithead == dev) { 671 if (dev->waitprev) 672 dev->waitprev->waitnext = dev->waitnext; 673 else 674 port->waithead = dev->waitnext; 675 if (dev->waitnext) 676 dev->waitnext->waitprev = dev->waitprev; 677 else 678 port->waittail = dev->waitprev; 679 } 680 spin_unlock (&port->waitlist_lock); 681 682 kfree(dev->state); 683 kfree(dev); 684 685 module_put(port->ops->owner); 686 parport_put_port (port); 687 } 688 689 /** 690 * parport_find_number - find a parallel port by number 691 * @number: parallel port number 692 * 693 * This returns the parallel port with the specified number, or 694 * %NULL if there is none. 695 * 696 * There is an implicit parport_get_port() done already; to throw 697 * away the reference to the port that parport_find_number() 698 * gives you, use parport_put_port(). 699 */ 700 701 struct parport *parport_find_number (int number) 702 { 703 struct parport *port, *result = NULL; 704 705 if (list_empty(&portlist)) 706 get_lowlevel_driver (); 707 708 spin_lock (&parportlist_lock); 709 list_for_each_entry(port, &portlist, list) { 710 if (port->number == number) { 711 result = parport_get_port (port); 712 break; 713 } 714 } 715 spin_unlock (&parportlist_lock); 716 return result; 717 } 718 719 /** 720 * parport_find_base - find a parallel port by base address 721 * @base: base I/O address 722 * 723 * This returns the parallel port with the specified base 724 * address, or %NULL if there is none. 725 * 726 * There is an implicit parport_get_port() done already; to throw 727 * away the reference to the port that parport_find_base() 728 * gives you, use parport_put_port(). 729 */ 730 731 struct parport *parport_find_base (unsigned long base) 732 { 733 struct parport *port, *result = NULL; 734 735 if (list_empty(&portlist)) 736 get_lowlevel_driver (); 737 738 spin_lock (&parportlist_lock); 739 list_for_each_entry(port, &portlist, list) { 740 if (port->base == base) { 741 result = parport_get_port (port); 742 break; 743 } 744 } 745 spin_unlock (&parportlist_lock); 746 return result; 747 } 748 749 /** 750 * parport_claim - claim access to a parallel port device 751 * @dev: pointer to structure representing a device on the port 752 * 753 * This function will not block and so can be used from interrupt 754 * context. If parport_claim() succeeds in claiming access to 755 * the port it returns zero and the port is available to use. It 756 * may fail (returning non-zero) if the port is in use by another 757 * driver and that driver is not willing to relinquish control of 758 * the port. 759 **/ 760 761 int parport_claim(struct pardevice *dev) 762 { 763 struct pardevice *oldcad; 764 struct parport *port = dev->port->physport; 765 unsigned long flags; 766 767 if (port->cad == dev) { 768 printk(KERN_INFO "%s: %s already owner\n", 769 dev->port->name,dev->name); 770 return 0; 771 } 772 773 /* Preempt any current device */ 774 write_lock_irqsave (&port->cad_lock, flags); 775 if ((oldcad = port->cad) != NULL) { 776 if (oldcad->preempt) { 777 if (oldcad->preempt(oldcad->private)) 778 goto blocked; 779 port->ops->save_state(port, dev->state); 780 } else 781 goto blocked; 782 783 if (port->cad != oldcad) { 784 /* I think we'll actually deadlock rather than 785 get here, but just in case.. */ 786 printk(KERN_WARNING 787 "%s: %s released port when preempted!\n", 788 port->name, oldcad->name); 789 if (port->cad) 790 goto blocked; 791 } 792 } 793 794 /* Can't fail from now on, so mark ourselves as no longer waiting. */ 795 if (dev->waiting & 1) { 796 dev->waiting = 0; 797 798 /* Take ourselves out of the wait list again. */ 799 spin_lock_irq (&port->waitlist_lock); 800 if (dev->waitprev) 801 dev->waitprev->waitnext = dev->waitnext; 802 else 803 port->waithead = dev->waitnext; 804 if (dev->waitnext) 805 dev->waitnext->waitprev = dev->waitprev; 806 else 807 port->waittail = dev->waitprev; 808 spin_unlock_irq (&port->waitlist_lock); 809 dev->waitprev = dev->waitnext = NULL; 810 } 811 812 /* Now we do the change of devices */ 813 port->cad = dev; 814 815 #ifdef CONFIG_PARPORT_1284 816 /* If it's a mux port, select it. */ 817 if (dev->port->muxport >= 0) { 818 /* FIXME */ 819 port->muxsel = dev->port->muxport; 820 } 821 822 /* If it's a daisy chain device, select it. */ 823 if (dev->daisy >= 0) { 824 /* This could be lazier. */ 825 if (!parport_daisy_select (port, dev->daisy, 826 IEEE1284_MODE_COMPAT)) 827 port->daisy = dev->daisy; 828 } 829 #endif /* IEEE1284.3 support */ 830 831 /* Restore control registers */ 832 port->ops->restore_state(port, dev->state); 833 write_unlock_irqrestore(&port->cad_lock, flags); 834 dev->time = jiffies; 835 return 0; 836 837 blocked: 838 /* If this is the first time we tried to claim the port, register an 839 interest. This is only allowed for devices sleeping in 840 parport_claim_or_block(), or those with a wakeup function. */ 841 842 /* The cad_lock is still held for writing here */ 843 if (dev->waiting & 2 || dev->wakeup) { 844 spin_lock (&port->waitlist_lock); 845 if (test_and_set_bit(0, &dev->waiting) == 0) { 846 /* First add ourselves to the end of the wait list. */ 847 dev->waitnext = NULL; 848 dev->waitprev = port->waittail; 849 if (port->waittail) { 850 port->waittail->waitnext = dev; 851 port->waittail = dev; 852 } else 853 port->waithead = port->waittail = dev; 854 } 855 spin_unlock (&port->waitlist_lock); 856 } 857 write_unlock_irqrestore (&port->cad_lock, flags); 858 return -EAGAIN; 859 } 860 861 /** 862 * parport_claim_or_block - claim access to a parallel port device 863 * @dev: pointer to structure representing a device on the port 864 * 865 * This behaves like parport_claim(), but will block if necessary 866 * to wait for the port to be free. A return value of 1 867 * indicates that it slept; 0 means that it succeeded without 868 * needing to sleep. A negative error code indicates failure. 869 **/ 870 871 int parport_claim_or_block(struct pardevice *dev) 872 { 873 int r; 874 875 /* Signal to parport_claim() that we can wait even without a 876 wakeup function. */ 877 dev->waiting = 2; 878 879 /* Try to claim the port. If this fails, we need to sleep. */ 880 r = parport_claim(dev); 881 if (r == -EAGAIN) { 882 #ifdef PARPORT_DEBUG_SHARING 883 printk(KERN_DEBUG "%s: parport_claim() returned -EAGAIN\n", dev->name); 884 #endif 885 /* 886 * FIXME!!! Use the proper locking for dev->waiting, 887 * and make this use the "wait_event_interruptible()" 888 * interfaces. The cli/sti that used to be here 889 * did nothing. 890 * 891 * See also parport_release() 892 */ 893 894 /* If dev->waiting is clear now, an interrupt 895 gave us the port and we would deadlock if we slept. */ 896 if (dev->waiting) { 897 interruptible_sleep_on (&dev->wait_q); 898 if (signal_pending (current)) { 899 return -EINTR; 900 } 901 r = 1; 902 } else { 903 r = 0; 904 #ifdef PARPORT_DEBUG_SHARING 905 printk(KERN_DEBUG "%s: didn't sleep in parport_claim_or_block()\n", 906 dev->name); 907 #endif 908 } 909 910 #ifdef PARPORT_DEBUG_SHARING 911 if (dev->port->physport->cad != dev) 912 printk(KERN_DEBUG "%s: exiting parport_claim_or_block " 913 "but %s owns port!\n", dev->name, 914 dev->port->physport->cad ? 915 dev->port->physport->cad->name:"nobody"); 916 #endif 917 } 918 dev->waiting = 0; 919 return r; 920 } 921 922 /** 923 * parport_release - give up access to a parallel port device 924 * @dev: pointer to structure representing parallel port device 925 * 926 * This function cannot fail, but it should not be called without 927 * the port claimed. Similarly, if the port is already claimed 928 * you should not try claiming it again. 929 **/ 930 931 void parport_release(struct pardevice *dev) 932 { 933 struct parport *port = dev->port->physport; 934 struct pardevice *pd; 935 unsigned long flags; 936 937 /* Make sure that dev is the current device */ 938 write_lock_irqsave(&port->cad_lock, flags); 939 if (port->cad != dev) { 940 write_unlock_irqrestore (&port->cad_lock, flags); 941 printk(KERN_WARNING "%s: %s tried to release parport " 942 "when not owner\n", port->name, dev->name); 943 return; 944 } 945 946 #ifdef CONFIG_PARPORT_1284 947 /* If this is on a mux port, deselect it. */ 948 if (dev->port->muxport >= 0) { 949 /* FIXME */ 950 port->muxsel = -1; 951 } 952 953 /* If this is a daisy device, deselect it. */ 954 if (dev->daisy >= 0) { 955 parport_daisy_deselect_all (port); 956 port->daisy = -1; 957 } 958 #endif 959 960 port->cad = NULL; 961 write_unlock_irqrestore(&port->cad_lock, flags); 962 963 /* Save control registers */ 964 port->ops->save_state(port, dev->state); 965 966 /* If anybody is waiting, find out who's been there longest and 967 then wake them up. (Note: no locking required) */ 968 /* !!! LOCKING IS NEEDED HERE */ 969 for (pd = port->waithead; pd; pd = pd->waitnext) { 970 if (pd->waiting & 2) { /* sleeping in claim_or_block */ 971 parport_claim(pd); 972 if (waitqueue_active(&pd->wait_q)) 973 wake_up_interruptible(&pd->wait_q); 974 return; 975 } else if (pd->wakeup) { 976 pd->wakeup(pd->private); 977 if (dev->port->cad) /* racy but no matter */ 978 return; 979 } else { 980 printk(KERN_ERR "%s: don't know how to wake %s\n", port->name, pd->name); 981 } 982 } 983 984 /* Nobody was waiting, so walk the list to see if anyone is 985 interested in being woken up. (Note: no locking required) */ 986 /* !!! LOCKING IS NEEDED HERE */ 987 for (pd = port->devices; (port->cad == NULL) && pd; pd = pd->next) { 988 if (pd->wakeup && pd != dev) 989 pd->wakeup(pd->private); 990 } 991 } 992 993 /* Exported symbols for modules. */ 994 995 EXPORT_SYMBOL(parport_claim); 996 EXPORT_SYMBOL(parport_claim_or_block); 997 EXPORT_SYMBOL(parport_release); 998 EXPORT_SYMBOL(parport_register_port); 999 EXPORT_SYMBOL(parport_announce_port); 1000 EXPORT_SYMBOL(parport_remove_port); 1001 EXPORT_SYMBOL(parport_register_driver); 1002 EXPORT_SYMBOL(parport_unregister_driver); 1003 EXPORT_SYMBOL(parport_register_device); 1004 EXPORT_SYMBOL(parport_unregister_device); 1005 EXPORT_SYMBOL(parport_get_port); 1006 EXPORT_SYMBOL(parport_put_port); 1007 EXPORT_SYMBOL(parport_find_number); 1008 EXPORT_SYMBOL(parport_find_base); 1009 1010 MODULE_LICENSE("GPL"); 1011