1/* 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 41unsigned long parport_default_timeslice = PARPORT_DEFAULT_TIMESLICE; 42int parport_default_spintime = DEFAULT_SPIN_TIME; 43 44static LIST_HEAD(portlist); 45static DEFINE_SPINLOCK(parportlist_lock); 46 47/* list of all allocated ports, sorted by ->number */ 48static LIST_HEAD(all_ports); 49static DEFINE_SPINLOCK(full_list_lock); 50 51static LIST_HEAD(drivers); 52 53static DEFINE_MUTEX(registration_lock); 54 55/* What you can do to a port that's gone away.. */ 56static void dead_write_lines (struct parport *p, unsigned char b){} 57static unsigned char dead_read_lines (struct parport *p) { return 0; } 58static unsigned char dead_frob_lines (struct parport *p, unsigned char b, 59 unsigned char c) { return 0; } 60static void dead_onearg (struct parport *p){} 61static void dead_initstate (struct pardevice *d, struct parport_state *s) { } 62static void dead_state (struct parport *p, struct parport_state *s) { } 63static size_t dead_write (struct parport *p, const void *b, size_t l, int f) 64{ return 0; } 65static size_t dead_read (struct parport *p, void *b, size_t l, int f) 66{ return 0; } 67static 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. */ 104static 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. */ 113static 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. */ 122static 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 154int 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 187void 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 198static 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 224struct 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 238void 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 276struct 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 359void 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 if (!port->dev) 369 printk(KERN_WARNING "%s: fix this legacy " 370 "no-device port driver!\n", 371 port->name); 372 373 parport_proc_register(port); 374 mutex_lock(®istration_lock); 375 spin_lock_irq(&parportlist_lock); 376 list_add_tail(&port->list, &portlist); 377 for (i = 1; i < 3; i++) { 378 struct parport *slave = port->slaves[i-1]; 379 if (slave) 380 list_add_tail(&slave->list, &portlist); 381 } 382 spin_unlock_irq(&parportlist_lock); 383 384 /* Let drivers know that new port(s) has arrived. */ 385 attach_driver_chain (port); 386 for (i = 1; i < 3; i++) { 387 struct parport *slave = port->slaves[i-1]; 388 if (slave) 389 attach_driver_chain(slave); 390 } 391 mutex_unlock(®istration_lock); 392} 393 394/** 395 * parport_remove_port - deregister a parallel port 396 * @port: parallel port to deregister 397 * 398 * When a parallel port driver is forcibly unloaded, or a 399 * parallel port becomes inaccessible, the port driver must call 400 * this function in order to deal with device drivers that still 401 * want to use it. 402 * 403 * The parport structure associated with the port has its 404 * operations structure replaced with one containing 'null' 405 * operations that return errors or just don't do anything. 406 * 407 * Any drivers that have registered themselves using 408 * parport_register_driver() are notified that the port is no 409 * longer accessible by having their detach() routines called 410 * with @port as the parameter. 411 **/ 412 413void parport_remove_port(struct parport *port) 414{ 415 int i; 416 417 mutex_lock(®istration_lock); 418 419 /* Spread the word. */ 420 detach_driver_chain (port); 421 422#ifdef CONFIG_PARPORT_1284 423 /* Forget the IEEE1284.3 topology of the port. */ 424 parport_daisy_fini(port); 425 for (i = 1; i < 3; i++) { 426 struct parport *slave = port->slaves[i-1]; 427 if (!slave) 428 continue; 429 detach_driver_chain(slave); 430 parport_daisy_fini(slave); 431 } 432#endif 433 434 port->ops = &dead_ops; 435 spin_lock(&parportlist_lock); 436 list_del_init(&port->list); 437 for (i = 1; i < 3; i++) { 438 struct parport *slave = port->slaves[i-1]; 439 if (slave) 440 list_del_init(&slave->list); 441 } 442 spin_unlock(&parportlist_lock); 443 444 mutex_unlock(®istration_lock); 445 446 parport_proc_unregister(port); 447 448 for (i = 1; i < 3; i++) { 449 struct parport *slave = port->slaves[i-1]; 450 if (slave) 451 parport_put_port(slave); 452 } 453} 454 455/** 456 * parport_register_device - register a device on a parallel port 457 * @port: port to which the device is attached 458 * @name: a name to refer to the device 459 * @pf: preemption callback 460 * @kf: kick callback (wake-up) 461 * @irq_func: interrupt handler 462 * @flags: registration flags 463 * @handle: data for callback functions 464 * 465 * This function, called by parallel port device drivers, 466 * declares that a device is connected to a port, and tells the 467 * system all it needs to know. 468 * 469 * The @name is allocated by the caller and must not be 470 * deallocated until the caller calls @parport_unregister_device 471 * for that device. 472 * 473 * The preemption callback function, @pf, is called when this 474 * device driver has claimed access to the port but another 475 * device driver wants to use it. It is given @handle as its 476 * parameter, and should return zero if it is willing for the 477 * system to release the port to another driver on its behalf. 478 * If it wants to keep control of the port it should return 479 * non-zero, and no action will be taken. It is good manners for 480 * the driver to try to release the port at the earliest 481 * opportunity after its preemption callback rejects a preemption 482 * attempt. Note that if a preemption callback is happy for 483 * preemption to go ahead, there is no need to release the port; 484 * it is done automatically. This function may not block, as it 485 * may be called from interrupt context. If the device driver 486 * does not support preemption, @pf can be %NULL. 487 * 488 * The wake-up ("kick") callback function, @kf, is called when 489 * the port is available to be claimed for exclusive access; that 490 * is, parport_claim() is guaranteed to succeed when called from 491 * inside the wake-up callback function. If the driver wants to 492 * claim the port it should do so; otherwise, it need not take 493 * any action. This function may not block, as it may be called 494 * from interrupt context. If the device driver does not want to 495 * be explicitly invited to claim the port in this way, @kf can 496 * be %NULL. 497 * 498 * The interrupt handler, @irq_func, is called when an interrupt 499 * arrives from the parallel port. Note that if a device driver 500 * wants to use interrupts it should use parport_enable_irq(), 501 * and can also check the irq member of the parport structure 502 * representing the port. 503 * 504 * The parallel port (lowlevel) driver is the one that has called 505 * request_irq() and whose interrupt handler is called first. 506 * This handler does whatever needs to be done to the hardware to 507 * acknowledge the interrupt (for PC-style ports there is nothing 508 * special to be done). It then tells the IEEE 1284 code about 509 * the interrupt, which may involve reacting to an IEEE 1284 510 * event depending on the current IEEE 1284 phase. After this, 511 * it calls @irq_func. Needless to say, @irq_func will be called 512 * from interrupt context, and may not block. 513 * 514 * The %PARPORT_DEV_EXCL flag is for preventing port sharing, and 515 * so should only be used when sharing the port with other device 516 * drivers is impossible and would lead to incorrect behaviour. 517 * Use it sparingly! Normally, @flags will be zero. 518 * 519 * This function returns a pointer to a structure that represents 520 * the device on the port, or %NULL if there is not enough memory 521 * to allocate space for that structure. 522 **/ 523 524struct pardevice * 525parport_register_device(struct parport *port, const char *name, 526 int (*pf)(void *), void (*kf)(void *), 527 void (*irq_func)(void *), 528 int flags, void *handle) 529{ 530 struct pardevice *tmp; 531 532 if (port->physport->flags & PARPORT_FLAG_EXCL) { 533 /* An exclusive device is registered. */ 534 printk (KERN_DEBUG "%s: no more devices allowed\n", 535 port->name); 536 return NULL; 537 } 538 539 if (flags & PARPORT_DEV_LURK) { 540 if (!pf || !kf) { 541 printk(KERN_INFO "%s: refused to register lurking device (%s) without callbacks\n", port->name, name); 542 return NULL; 543 } 544 } 545 546 /* We up our own module reference count, and that of the port 547 on which a device is to be registered, to ensure that 548 neither of us gets unloaded while we sleep in (e.g.) 549 kmalloc. 550 */ 551 if (!try_module_get(port->ops->owner)) { 552 return NULL; 553 } 554 555 parport_get_port (port); 556 557 tmp = kmalloc(sizeof(struct pardevice), GFP_KERNEL); 558 if (tmp == NULL) { 559 printk(KERN_WARNING "%s: memory squeeze, couldn't register %s.\n", port->name, name); 560 goto out; 561 } 562 563 tmp->state = kmalloc(sizeof(struct parport_state), GFP_KERNEL); 564 if (tmp->state == NULL) { 565 printk(KERN_WARNING "%s: memory squeeze, couldn't register %s.\n", port->name, name); 566 goto out_free_pardevice; 567 } 568 569 tmp->name = name; 570 tmp->port = port; 571 tmp->daisy = -1; 572 tmp->preempt = pf; 573 tmp->wakeup = kf; 574 tmp->private = handle; 575 tmp->flags = flags; 576 tmp->irq_func = irq_func; 577 tmp->waiting = 0; 578 tmp->timeout = 5 * HZ; 579 580 /* Chain this onto the list */ 581 tmp->prev = NULL; 582 /* 583 * This function must not run from an irq handler so we don' t need 584 * to clear irq on the local CPU. -arca 585 */ 586 spin_lock(&port->physport->pardevice_lock); 587 588 if (flags & PARPORT_DEV_EXCL) { 589 if (port->physport->devices) { 590 spin_unlock (&port->physport->pardevice_lock); 591 printk (KERN_DEBUG 592 "%s: cannot grant exclusive access for " 593 "device %s\n", port->name, name); 594 goto out_free_all; 595 } 596 port->flags |= PARPORT_FLAG_EXCL; 597 } 598 599 tmp->next = port->physport->devices; 600 wmb(); /* Make sure that tmp->next is written before it's 601 added to the list; see comments marked 'no locking 602 required' */ 603 if (port->physport->devices) 604 port->physport->devices->prev = tmp; 605 port->physport->devices = tmp; 606 spin_unlock(&port->physport->pardevice_lock); 607 608 init_waitqueue_head(&tmp->wait_q); 609 tmp->timeslice = parport_default_timeslice; 610 tmp->waitnext = tmp->waitprev = NULL; 611 612 /* 613 * This has to be run as last thing since init_state may need other 614 * pardevice fields. -arca 615 */ 616 port->ops->init_state(tmp, tmp->state); 617 if (!test_and_set_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags)) { 618 port->proc_device = tmp; 619 parport_device_proc_register(tmp); 620 } 621 return tmp; 622 623 out_free_all: 624 kfree(tmp->state); 625 out_free_pardevice: 626 kfree(tmp); 627 out: 628 parport_put_port (port); 629 module_put(port->ops->owner); 630 631 return NULL; 632} 633 634/** 635 * parport_unregister_device - deregister a device on a parallel port 636 * @dev: pointer to structure representing device 637 * 638 * This undoes the effect of parport_register_device(). 639 **/ 640 641void parport_unregister_device(struct pardevice *dev) 642{ 643 struct parport *port; 644 645#ifdef PARPORT_PARANOID 646 if (dev == NULL) { 647 printk(KERN_ERR "parport_unregister_device: passed NULL\n"); 648 return; 649 } 650#endif 651 652 port = dev->port->physport; 653 654 if (port->proc_device == dev) { 655 port->proc_device = NULL; 656 clear_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags); 657 parport_device_proc_unregister(dev); 658 } 659 660 if (port->cad == dev) { 661 printk(KERN_DEBUG "%s: %s forgot to release port\n", 662 port->name, dev->name); 663 parport_release (dev); 664 } 665 666 spin_lock(&port->pardevice_lock); 667 if (dev->next) 668 dev->next->prev = dev->prev; 669 if (dev->prev) 670 dev->prev->next = dev->next; 671 else 672 port->devices = dev->next; 673 674 if (dev->flags & PARPORT_DEV_EXCL) 675 port->flags &= ~PARPORT_FLAG_EXCL; 676 677 spin_unlock(&port->pardevice_lock); 678 679 /* Make sure we haven't left any pointers around in the wait 680 * list. */ 681 spin_lock (&port->waitlist_lock); 682 if (dev->waitprev || dev->waitnext || port->waithead == dev) { 683 if (dev->waitprev) 684 dev->waitprev->waitnext = dev->waitnext; 685 else 686 port->waithead = dev->waitnext; 687 if (dev->waitnext) 688 dev->waitnext->waitprev = dev->waitprev; 689 else 690 port->waittail = dev->waitprev; 691 } 692 spin_unlock (&port->waitlist_lock); 693 694 kfree(dev->state); 695 kfree(dev); 696 697 module_put(port->ops->owner); 698 parport_put_port (port); 699} 700 701/** 702 * parport_find_number - find a parallel port by number 703 * @number: parallel port number 704 * 705 * This returns the parallel port with the specified number, or 706 * %NULL if there is none. 707 * 708 * There is an implicit parport_get_port() done already; to throw 709 * away the reference to the port that parport_find_number() 710 * gives you, use parport_put_port(). 711 */ 712 713struct parport *parport_find_number (int number) 714{ 715 struct parport *port, *result = NULL; 716 717 if (list_empty(&portlist)) 718 get_lowlevel_driver (); 719 720 spin_lock (&parportlist_lock); 721 list_for_each_entry(port, &portlist, list) { 722 if (port->number == number) { 723 result = parport_get_port (port); 724 break; 725 } 726 } 727 spin_unlock (&parportlist_lock); 728 return result; 729} 730 731/** 732 * parport_find_base - find a parallel port by base address 733 * @base: base I/O address 734 * 735 * This returns the parallel port with the specified base 736 * address, or %NULL if there is none. 737 * 738 * There is an implicit parport_get_port() done already; to throw 739 * away the reference to the port that parport_find_base() 740 * gives you, use parport_put_port(). 741 */ 742 743struct parport *parport_find_base (unsigned long base) 744{ 745 struct parport *port, *result = NULL; 746 747 if (list_empty(&portlist)) 748 get_lowlevel_driver (); 749 750 spin_lock (&parportlist_lock); 751 list_for_each_entry(port, &portlist, list) { 752 if (port->base == base) { 753 result = parport_get_port (port); 754 break; 755 } 756 } 757 spin_unlock (&parportlist_lock); 758 return result; 759} 760 761/** 762 * parport_claim - claim access to a parallel port device 763 * @dev: pointer to structure representing a device on the port 764 * 765 * This function will not block and so can be used from interrupt 766 * context. If parport_claim() succeeds in claiming access to 767 * the port it returns zero and the port is available to use. It 768 * may fail (returning non-zero) if the port is in use by another 769 * driver and that driver is not willing to relinquish control of 770 * the port. 771 **/ 772 773int parport_claim(struct pardevice *dev) 774{ 775 struct pardevice *oldcad; 776 struct parport *port = dev->port->physport; 777 unsigned long flags; 778 779 if (port->cad == dev) { 780 printk(KERN_INFO "%s: %s already owner\n", 781 dev->port->name,dev->name); 782 return 0; 783 } 784 785 /* Preempt any current device */ 786 write_lock_irqsave (&port->cad_lock, flags); 787 if ((oldcad = port->cad) != NULL) { 788 if (oldcad->preempt) { 789 if (oldcad->preempt(oldcad->private)) 790 goto blocked; 791 port->ops->save_state(port, dev->state); 792 } else 793 goto blocked; 794 795 if (port->cad != oldcad) { 796 /* I think we'll actually deadlock rather than 797 get here, but just in case.. */ 798 printk(KERN_WARNING 799 "%s: %s released port when preempted!\n", 800 port->name, oldcad->name); 801 if (port->cad) 802 goto blocked; 803 } 804 } 805 806 /* Can't fail from now on, so mark ourselves as no longer waiting. */ 807 if (dev->waiting & 1) { 808 dev->waiting = 0; 809 810 /* Take ourselves out of the wait list again. */ 811 spin_lock_irq (&port->waitlist_lock); 812 if (dev->waitprev) 813 dev->waitprev->waitnext = dev->waitnext; 814 else 815 port->waithead = dev->waitnext; 816 if (dev->waitnext) 817 dev->waitnext->waitprev = dev->waitprev; 818 else 819 port->waittail = dev->waitprev; 820 spin_unlock_irq (&port->waitlist_lock); 821 dev->waitprev = dev->waitnext = NULL; 822 } 823 824 /* Now we do the change of devices */ 825 port->cad = dev; 826 827#ifdef CONFIG_PARPORT_1284 828 /* If it's a mux port, select it. */ 829 if (dev->port->muxport >= 0) { 830 port->muxsel = dev->port->muxport; 831 } 832 833 /* If it's a daisy chain device, select it. */ 834 if (dev->daisy >= 0) { 835 /* This could be lazier. */ 836 if (!parport_daisy_select (port, dev->daisy, 837 IEEE1284_MODE_COMPAT)) 838 port->daisy = dev->daisy; 839 } 840#endif /* IEEE1284.3 support */ 841 842 /* Restore control registers */ 843 port->ops->restore_state(port, dev->state); 844 write_unlock_irqrestore(&port->cad_lock, flags); 845 dev->time = jiffies; 846 return 0; 847 848blocked: 849 /* If this is the first time we tried to claim the port, register an 850 interest. This is only allowed for devices sleeping in 851 parport_claim_or_block(), or those with a wakeup function. */ 852 853 /* The cad_lock is still held for writing here */ 854 if (dev->waiting & 2 || dev->wakeup) { 855 spin_lock (&port->waitlist_lock); 856 if (test_and_set_bit(0, &dev->waiting) == 0) { 857 /* First add ourselves to the end of the wait list. */ 858 dev->waitnext = NULL; 859 dev->waitprev = port->waittail; 860 if (port->waittail) { 861 port->waittail->waitnext = dev; 862 port->waittail = dev; 863 } else 864 port->waithead = port->waittail = dev; 865 } 866 spin_unlock (&port->waitlist_lock); 867 } 868 write_unlock_irqrestore (&port->cad_lock, flags); 869 return -EAGAIN; 870} 871 872/** 873 * parport_claim_or_block - claim access to a parallel port device 874 * @dev: pointer to structure representing a device on the port 875 * 876 * This behaves like parport_claim(), but will block if necessary 877 * to wait for the port to be free. A return value of 1 878 * indicates that it slept; 0 means that it succeeded without 879 * needing to sleep. A negative error code indicates failure. 880 **/ 881 882int parport_claim_or_block(struct pardevice *dev) 883{ 884 int r; 885 886 /* Signal to parport_claim() that we can wait even without a 887 wakeup function. */ 888 dev->waiting = 2; 889 890 /* Try to claim the port. If this fails, we need to sleep. */ 891 r = parport_claim(dev); 892 if (r == -EAGAIN) { 893#ifdef PARPORT_DEBUG_SHARING 894 printk(KERN_DEBUG "%s: parport_claim() returned -EAGAIN\n", dev->name); 895#endif 896 897 /* If dev->waiting is clear now, an interrupt 898 gave us the port and we would deadlock if we slept. */ 899 if (dev->waiting) { 900 interruptible_sleep_on (&dev->wait_q); 901 if (signal_pending (current)) { 902 return -EINTR; 903 } 904 r = 1; 905 } else { 906 r = 0; 907#ifdef PARPORT_DEBUG_SHARING 908 printk(KERN_DEBUG "%s: didn't sleep in parport_claim_or_block()\n", 909 dev->name); 910#endif 911 } 912 913#ifdef PARPORT_DEBUG_SHARING 914 if (dev->port->physport->cad != dev) 915 printk(KERN_DEBUG "%s: exiting parport_claim_or_block " 916 "but %s owns port!\n", dev->name, 917 dev->port->physport->cad ? 918 dev->port->physport->cad->name:"nobody"); 919#endif 920 } 921 dev->waiting = 0; 922 return r; 923} 924 925/** 926 * parport_release - give up access to a parallel port device 927 * @dev: pointer to structure representing parallel port device 928 * 929 * This function cannot fail, but it should not be called without 930 * the port claimed. Similarly, if the port is already claimed 931 * you should not try claiming it again. 932 **/ 933 934void parport_release(struct pardevice *dev) 935{ 936 struct parport *port = dev->port->physport; 937 struct pardevice *pd; 938 unsigned long flags; 939 940 /* Make sure that dev is the current device */ 941 write_lock_irqsave(&port->cad_lock, flags); 942 if (port->cad != dev) { 943 write_unlock_irqrestore (&port->cad_lock, flags); 944 printk(KERN_WARNING "%s: %s tried to release parport " 945 "when not owner\n", port->name, dev->name); 946 return; 947 } 948 949#ifdef CONFIG_PARPORT_1284 950 /* If this is on a mux port, deselect it. */ 951 if (dev->port->muxport >= 0) { 952 port->muxsel = -1; 953 } 954 955 /* If this is a daisy device, deselect it. */ 956 if (dev->daisy >= 0) { 957 parport_daisy_deselect_all (port); 958 port->daisy = -1; 959 } 960#endif 961 962 port->cad = NULL; 963 write_unlock_irqrestore(&port->cad_lock, flags); 964 965 /* Save control registers */ 966 port->ops->save_state(port, dev->state); 967 968 /* If anybody is waiting, find out who's been there longest and 969 then wake them up. (Note: no locking required) */ 970 /* !!! LOCKING IS NEEDED HERE */ 971 for (pd = port->waithead; pd; pd = pd->waitnext) { 972 if (pd->waiting & 2) { /* sleeping in claim_or_block */ 973 parport_claim(pd); 974 if (waitqueue_active(&pd->wait_q)) 975 wake_up_interruptible(&pd->wait_q); 976 return; 977 } else if (pd->wakeup) { 978 pd->wakeup(pd->private); 979 if (dev->port->cad) /* racy but no matter */ 980 return; 981 } else { 982 printk(KERN_ERR "%s: don't know how to wake %s\n", port->name, pd->name); 983 } 984 } 985 986 /* Nobody was waiting, so walk the list to see if anyone is 987 interested in being woken up. (Note: no locking required) */ 988 /* !!! LOCKING IS NEEDED HERE */ 989 for (pd = port->devices; (port->cad == NULL) && pd; pd = pd->next) { 990 if (pd->wakeup && pd != dev) 991 pd->wakeup(pd->private); 992 } 993} 994 995irqreturn_t parport_irq_handler(int irq, void *dev_id) 996{ 997 struct parport *port = dev_id; 998 999 parport_generic_irq(port); 1000 1001 return IRQ_HANDLED; 1002} 1003 1004/* Exported symbols for modules. */ 1005 1006EXPORT_SYMBOL(parport_claim); 1007EXPORT_SYMBOL(parport_claim_or_block); 1008EXPORT_SYMBOL(parport_release); 1009EXPORT_SYMBOL(parport_register_port); 1010EXPORT_SYMBOL(parport_announce_port); 1011EXPORT_SYMBOL(parport_remove_port); 1012EXPORT_SYMBOL(parport_register_driver); 1013EXPORT_SYMBOL(parport_unregister_driver); 1014EXPORT_SYMBOL(parport_register_device); 1015EXPORT_SYMBOL(parport_unregister_device); 1016EXPORT_SYMBOL(parport_get_port); 1017EXPORT_SYMBOL(parport_put_port); 1018EXPORT_SYMBOL(parport_find_number); 1019EXPORT_SYMBOL(parport_find_base); 1020EXPORT_SYMBOL(parport_irq_handler); 1021 1022MODULE_LICENSE("GPL"); 1023