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 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 = kzalloc(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 tmp->base = base; 293 tmp->irq = irq; 294 tmp->dma = dma; 295 tmp->muxport = tmp->daisy = tmp->muxsel = -1; 296 tmp->modes = 0; 297 INIT_LIST_HEAD(&tmp->list); 298 tmp->devices = tmp->cad = NULL; 299 tmp->flags = 0; 300 tmp->ops = ops; 301 tmp->physport = tmp; 302 memset (tmp->probe_info, 0, 5 * sizeof (struct parport_device_info)); 303 rwlock_init(&tmp->cad_lock); 304 spin_lock_init(&tmp->waitlist_lock); 305 spin_lock_init(&tmp->pardevice_lock); 306 tmp->ieee1284.mode = IEEE1284_MODE_COMPAT; 307 tmp->ieee1284.phase = IEEE1284_PH_FWD_IDLE; 308 sema_init(&tmp->ieee1284.irq, 0); 309 tmp->spintime = parport_default_spintime; 310 atomic_set (&tmp->ref_count, 1); 311 INIT_LIST_HEAD(&tmp->full_list); 312 313 name = kmalloc(15, GFP_KERNEL); 314 if (!name) { 315 printk(KERN_ERR "parport: memory squeeze\n"); 316 kfree(tmp); 317 return NULL; 318 } 319 /* Search for the lowest free parport number. */ 320 321 spin_lock(&full_list_lock); 322 for (l = all_ports.next, num = 0; l != &all_ports; l = l->next, num++) { 323 struct parport *p = list_entry(l, struct parport, full_list); 324 if (p->number != num) 325 break; 326 } 327 tmp->portnum = tmp->number = num; 328 list_add_tail(&tmp->full_list, l); 329 spin_unlock(&full_list_lock); 330 331 /* 332 * Now that the portnum is known finish doing the Init. 333 */ 334 sprintf(name, "parport%d", tmp->portnum = tmp->number); 335 tmp->name = name; 336 337 for (device = 0; device < 5; device++) 338 /* assume the worst */ 339 tmp->probe_info[device].class = PARPORT_CLASS_LEGACY; 340 341 tmp->waithead = tmp->waittail = NULL; 342 343 return tmp; 344 } 345 346 /** 347 * parport_announce_port - tell device drivers about a parallel port 348 * @port: parallel port to announce 349 * 350 * After a port driver has registered a parallel port with 351 * parport_register_port, and performed any necessary 352 * initialisation or adjustments, it should call 353 * parport_announce_port() in order to notify all device drivers 354 * that have called parport_register_driver(). Their attach() 355 * functions will be called, with @port as the parameter. 356 **/ 357 358 void parport_announce_port (struct parport *port) 359 { 360 int i; 361 362 #ifdef CONFIG_PARPORT_1284 363 /* Analyse the IEEE1284.3 topology of the port. */ 364 parport_daisy_init(port); 365 #endif 366 367 if (!port->dev) 368 printk(KERN_WARNING "%s: fix this legacy " 369 "no-device port driver!\n", 370 port->name); 371 372 parport_proc_register(port); 373 mutex_lock(®istration_lock); 374 spin_lock_irq(&parportlist_lock); 375 list_add_tail(&port->list, &portlist); 376 for (i = 1; i < 3; i++) { 377 struct parport *slave = port->slaves[i-1]; 378 if (slave) 379 list_add_tail(&slave->list, &portlist); 380 } 381 spin_unlock_irq(&parportlist_lock); 382 383 /* Let drivers know that new port(s) has arrived. */ 384 attach_driver_chain (port); 385 for (i = 1; i < 3; i++) { 386 struct parport *slave = port->slaves[i-1]; 387 if (slave) 388 attach_driver_chain(slave); 389 } 390 mutex_unlock(®istration_lock); 391 } 392 393 /** 394 * parport_remove_port - deregister a parallel port 395 * @port: parallel port to deregister 396 * 397 * When a parallel port driver is forcibly unloaded, or a 398 * parallel port becomes inaccessible, the port driver must call 399 * this function in order to deal with device drivers that still 400 * want to use it. 401 * 402 * The parport structure associated with the port has its 403 * operations structure replaced with one containing 'null' 404 * operations that return errors or just don't do anything. 405 * 406 * Any drivers that have registered themselves using 407 * parport_register_driver() are notified that the port is no 408 * longer accessible by having their detach() routines called 409 * with @port as the parameter. 410 **/ 411 412 void parport_remove_port(struct parport *port) 413 { 414 int i; 415 416 mutex_lock(®istration_lock); 417 418 /* Spread the word. */ 419 detach_driver_chain (port); 420 421 #ifdef CONFIG_PARPORT_1284 422 /* Forget the IEEE1284.3 topology of the port. */ 423 parport_daisy_fini(port); 424 for (i = 1; i < 3; i++) { 425 struct parport *slave = port->slaves[i-1]; 426 if (!slave) 427 continue; 428 detach_driver_chain(slave); 429 parport_daisy_fini(slave); 430 } 431 #endif 432 433 port->ops = &dead_ops; 434 spin_lock(&parportlist_lock); 435 list_del_init(&port->list); 436 for (i = 1; i < 3; i++) { 437 struct parport *slave = port->slaves[i-1]; 438 if (slave) 439 list_del_init(&slave->list); 440 } 441 spin_unlock(&parportlist_lock); 442 443 mutex_unlock(®istration_lock); 444 445 parport_proc_unregister(port); 446 447 for (i = 1; i < 3; i++) { 448 struct parport *slave = port->slaves[i-1]; 449 if (slave) 450 parport_put_port(slave); 451 } 452 } 453 454 /** 455 * parport_register_device - register a device on a parallel port 456 * @port: port to which the device is attached 457 * @name: a name to refer to the device 458 * @pf: preemption callback 459 * @kf: kick callback (wake-up) 460 * @irq_func: interrupt handler 461 * @flags: registration flags 462 * @handle: data for callback functions 463 * 464 * This function, called by parallel port device drivers, 465 * declares that a device is connected to a port, and tells the 466 * system all it needs to know. 467 * 468 * The @name is allocated by the caller and must not be 469 * deallocated until the caller calls @parport_unregister_device 470 * for that device. 471 * 472 * The preemption callback function, @pf, is called when this 473 * device driver has claimed access to the port but another 474 * device driver wants to use it. It is given @handle as its 475 * parameter, and should return zero if it is willing for the 476 * system to release the port to another driver on its behalf. 477 * If it wants to keep control of the port it should return 478 * non-zero, and no action will be taken. It is good manners for 479 * the driver to try to release the port at the earliest 480 * opportunity after its preemption callback rejects a preemption 481 * attempt. Note that if a preemption callback is happy for 482 * preemption to go ahead, there is no need to release the port; 483 * it is done automatically. This function may not block, as it 484 * may be called from interrupt context. If the device driver 485 * does not support preemption, @pf can be %NULL. 486 * 487 * The wake-up ("kick") callback function, @kf, is called when 488 * the port is available to be claimed for exclusive access; that 489 * is, parport_claim() is guaranteed to succeed when called from 490 * inside the wake-up callback function. If the driver wants to 491 * claim the port it should do so; otherwise, it need not take 492 * any action. This function may not block, as it may be called 493 * from interrupt context. If the device driver does not want to 494 * be explicitly invited to claim the port in this way, @kf can 495 * be %NULL. 496 * 497 * The interrupt handler, @irq_func, is called when an interrupt 498 * arrives from the parallel port. Note that if a device driver 499 * wants to use interrupts it should use parport_enable_irq(), 500 * and can also check the irq member of the parport structure 501 * representing the port. 502 * 503 * The parallel port (lowlevel) driver is the one that has called 504 * request_irq() and whose interrupt handler is called first. 505 * This handler does whatever needs to be done to the hardware to 506 * acknowledge the interrupt (for PC-style ports there is nothing 507 * special to be done). It then tells the IEEE 1284 code about 508 * the interrupt, which may involve reacting to an IEEE 1284 509 * event depending on the current IEEE 1284 phase. After this, 510 * it calls @irq_func. Needless to say, @irq_func will be called 511 * from interrupt context, and may not block. 512 * 513 * The %PARPORT_DEV_EXCL flag is for preventing port sharing, and 514 * so should only be used when sharing the port with other device 515 * drivers is impossible and would lead to incorrect behaviour. 516 * Use it sparingly! Normally, @flags will be zero. 517 * 518 * This function returns a pointer to a structure that represents 519 * the device on the port, or %NULL if there is not enough memory 520 * to allocate space for that structure. 521 **/ 522 523 struct pardevice * 524 parport_register_device(struct parport *port, const char *name, 525 int (*pf)(void *), void (*kf)(void *), 526 void (*irq_func)(void *), 527 int flags, void *handle) 528 { 529 struct pardevice *tmp; 530 531 if (port->physport->flags & PARPORT_FLAG_EXCL) { 532 /* An exclusive device is registered. */ 533 printk (KERN_DEBUG "%s: no more devices allowed\n", 534 port->name); 535 return NULL; 536 } 537 538 if (flags & PARPORT_DEV_LURK) { 539 if (!pf || !kf) { 540 printk(KERN_INFO "%s: refused to register lurking device (%s) without callbacks\n", port->name, name); 541 return NULL; 542 } 543 } 544 545 /* We up our own module reference count, and that of the port 546 on which a device is to be registered, to ensure that 547 neither of us gets unloaded while we sleep in (e.g.) 548 kmalloc. 549 */ 550 if (!try_module_get(port->ops->owner)) { 551 return NULL; 552 } 553 554 parport_get_port (port); 555 556 tmp = kmalloc(sizeof(struct pardevice), GFP_KERNEL); 557 if (tmp == NULL) { 558 printk(KERN_WARNING "%s: memory squeeze, couldn't register %s.\n", port->name, name); 559 goto out; 560 } 561 562 tmp->state = kmalloc(sizeof(struct parport_state), GFP_KERNEL); 563 if (tmp->state == NULL) { 564 printk(KERN_WARNING "%s: memory squeeze, couldn't register %s.\n", port->name, name); 565 goto out_free_pardevice; 566 } 567 568 tmp->name = name; 569 tmp->port = port; 570 tmp->daisy = -1; 571 tmp->preempt = pf; 572 tmp->wakeup = kf; 573 tmp->private = handle; 574 tmp->flags = flags; 575 tmp->irq_func = irq_func; 576 tmp->waiting = 0; 577 tmp->timeout = 5 * HZ; 578 579 /* Chain this onto the list */ 580 tmp->prev = NULL; 581 /* 582 * This function must not run from an irq handler so we don' t need 583 * to clear irq on the local CPU. -arca 584 */ 585 spin_lock(&port->physport->pardevice_lock); 586 587 if (flags & PARPORT_DEV_EXCL) { 588 if (port->physport->devices) { 589 spin_unlock (&port->physport->pardevice_lock); 590 printk (KERN_DEBUG 591 "%s: cannot grant exclusive access for " 592 "device %s\n", port->name, name); 593 goto out_free_all; 594 } 595 port->flags |= PARPORT_FLAG_EXCL; 596 } 597 598 tmp->next = port->physport->devices; 599 wmb(); /* Make sure that tmp->next is written before it's 600 added to the list; see comments marked 'no locking 601 required' */ 602 if (port->physport->devices) 603 port->physport->devices->prev = tmp; 604 port->physport->devices = tmp; 605 spin_unlock(&port->physport->pardevice_lock); 606 607 init_waitqueue_head(&tmp->wait_q); 608 tmp->timeslice = parport_default_timeslice; 609 tmp->waitnext = tmp->waitprev = NULL; 610 611 /* 612 * This has to be run as last thing since init_state may need other 613 * pardevice fields. -arca 614 */ 615 port->ops->init_state(tmp, tmp->state); 616 if (!test_and_set_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags)) { 617 port->proc_device = tmp; 618 parport_device_proc_register(tmp); 619 } 620 return tmp; 621 622 out_free_all: 623 kfree(tmp->state); 624 out_free_pardevice: 625 kfree(tmp); 626 out: 627 parport_put_port (port); 628 module_put(port->ops->owner); 629 630 return NULL; 631 } 632 633 /** 634 * parport_unregister_device - deregister a device on a parallel port 635 * @dev: pointer to structure representing device 636 * 637 * This undoes the effect of parport_register_device(). 638 **/ 639 640 void parport_unregister_device(struct pardevice *dev) 641 { 642 struct parport *port; 643 644 #ifdef PARPORT_PARANOID 645 if (dev == NULL) { 646 printk(KERN_ERR "parport_unregister_device: passed NULL\n"); 647 return; 648 } 649 #endif 650 651 port = dev->port->physport; 652 653 if (port->proc_device == dev) { 654 port->proc_device = NULL; 655 clear_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags); 656 parport_device_proc_unregister(dev); 657 } 658 659 if (port->cad == dev) { 660 printk(KERN_DEBUG "%s: %s forgot to release port\n", 661 port->name, dev->name); 662 parport_release (dev); 663 } 664 665 spin_lock(&port->pardevice_lock); 666 if (dev->next) 667 dev->next->prev = dev->prev; 668 if (dev->prev) 669 dev->prev->next = dev->next; 670 else 671 port->devices = dev->next; 672 673 if (dev->flags & PARPORT_DEV_EXCL) 674 port->flags &= ~PARPORT_FLAG_EXCL; 675 676 spin_unlock(&port->pardevice_lock); 677 678 /* Make sure we haven't left any pointers around in the wait 679 * list. */ 680 spin_lock_irq(&port->waitlist_lock); 681 if (dev->waitprev || dev->waitnext || port->waithead == dev) { 682 if (dev->waitprev) 683 dev->waitprev->waitnext = dev->waitnext; 684 else 685 port->waithead = dev->waitnext; 686 if (dev->waitnext) 687 dev->waitnext->waitprev = dev->waitprev; 688 else 689 port->waittail = dev->waitprev; 690 } 691 spin_unlock_irq(&port->waitlist_lock); 692 693 kfree(dev->state); 694 kfree(dev); 695 696 module_put(port->ops->owner); 697 parport_put_port (port); 698 } 699 700 /** 701 * parport_find_number - find a parallel port by number 702 * @number: parallel port number 703 * 704 * This returns the parallel port with the specified number, or 705 * %NULL if there is none. 706 * 707 * There is an implicit parport_get_port() done already; to throw 708 * away the reference to the port that parport_find_number() 709 * gives you, use parport_put_port(). 710 */ 711 712 struct parport *parport_find_number (int number) 713 { 714 struct parport *port, *result = NULL; 715 716 if (list_empty(&portlist)) 717 get_lowlevel_driver (); 718 719 spin_lock (&parportlist_lock); 720 list_for_each_entry(port, &portlist, list) { 721 if (port->number == number) { 722 result = parport_get_port (port); 723 break; 724 } 725 } 726 spin_unlock (&parportlist_lock); 727 return result; 728 } 729 730 /** 731 * parport_find_base - find a parallel port by base address 732 * @base: base I/O address 733 * 734 * This returns the parallel port with the specified base 735 * address, or %NULL if there is none. 736 * 737 * There is an implicit parport_get_port() done already; to throw 738 * away the reference to the port that parport_find_base() 739 * gives you, use parport_put_port(). 740 */ 741 742 struct parport *parport_find_base (unsigned long base) 743 { 744 struct parport *port, *result = NULL; 745 746 if (list_empty(&portlist)) 747 get_lowlevel_driver (); 748 749 spin_lock (&parportlist_lock); 750 list_for_each_entry(port, &portlist, list) { 751 if (port->base == base) { 752 result = parport_get_port (port); 753 break; 754 } 755 } 756 spin_unlock (&parportlist_lock); 757 return result; 758 } 759 760 /** 761 * parport_claim - claim access to a parallel port device 762 * @dev: pointer to structure representing a device on the port 763 * 764 * This function will not block and so can be used from interrupt 765 * context. If parport_claim() succeeds in claiming access to 766 * the port it returns zero and the port is available to use. It 767 * may fail (returning non-zero) if the port is in use by another 768 * driver and that driver is not willing to relinquish control of 769 * the port. 770 **/ 771 772 int parport_claim(struct pardevice *dev) 773 { 774 struct pardevice *oldcad; 775 struct parport *port = dev->port->physport; 776 unsigned long flags; 777 778 if (port->cad == dev) { 779 printk(KERN_INFO "%s: %s already owner\n", 780 dev->port->name,dev->name); 781 return 0; 782 } 783 784 /* Preempt any current device */ 785 write_lock_irqsave (&port->cad_lock, flags); 786 if ((oldcad = port->cad) != NULL) { 787 if (oldcad->preempt) { 788 if (oldcad->preempt(oldcad->private)) 789 goto blocked; 790 port->ops->save_state(port, dev->state); 791 } else 792 goto blocked; 793 794 if (port->cad != oldcad) { 795 /* I think we'll actually deadlock rather than 796 get here, but just in case.. */ 797 printk(KERN_WARNING 798 "%s: %s released port when preempted!\n", 799 port->name, oldcad->name); 800 if (port->cad) 801 goto blocked; 802 } 803 } 804 805 /* Can't fail from now on, so mark ourselves as no longer waiting. */ 806 if (dev->waiting & 1) { 807 dev->waiting = 0; 808 809 /* Take ourselves out of the wait list again. */ 810 spin_lock_irq (&port->waitlist_lock); 811 if (dev->waitprev) 812 dev->waitprev->waitnext = dev->waitnext; 813 else 814 port->waithead = dev->waitnext; 815 if (dev->waitnext) 816 dev->waitnext->waitprev = dev->waitprev; 817 else 818 port->waittail = dev->waitprev; 819 spin_unlock_irq (&port->waitlist_lock); 820 dev->waitprev = dev->waitnext = NULL; 821 } 822 823 /* Now we do the change of devices */ 824 port->cad = dev; 825 826 #ifdef CONFIG_PARPORT_1284 827 /* If it's a mux port, select it. */ 828 if (dev->port->muxport >= 0) { 829 /* FIXME */ 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 848 blocked: 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 882 int 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 * FIXME!!! Use the proper locking for dev->waiting, 898 * and make this use the "wait_event_interruptible()" 899 * interfaces. The cli/sti that used to be here 900 * did nothing. 901 * 902 * See also parport_release() 903 */ 904 905 /* If dev->waiting is clear now, an interrupt 906 gave us the port and we would deadlock if we slept. */ 907 if (dev->waiting) { 908 interruptible_sleep_on (&dev->wait_q); 909 if (signal_pending (current)) { 910 return -EINTR; 911 } 912 r = 1; 913 } else { 914 r = 0; 915 #ifdef PARPORT_DEBUG_SHARING 916 printk(KERN_DEBUG "%s: didn't sleep in parport_claim_or_block()\n", 917 dev->name); 918 #endif 919 } 920 921 #ifdef PARPORT_DEBUG_SHARING 922 if (dev->port->physport->cad != dev) 923 printk(KERN_DEBUG "%s: exiting parport_claim_or_block " 924 "but %s owns port!\n", dev->name, 925 dev->port->physport->cad ? 926 dev->port->physport->cad->name:"nobody"); 927 #endif 928 } 929 dev->waiting = 0; 930 return r; 931 } 932 933 /** 934 * parport_release - give up access to a parallel port device 935 * @dev: pointer to structure representing parallel port device 936 * 937 * This function cannot fail, but it should not be called without 938 * the port claimed. Similarly, if the port is already claimed 939 * you should not try claiming it again. 940 **/ 941 942 void parport_release(struct pardevice *dev) 943 { 944 struct parport *port = dev->port->physport; 945 struct pardevice *pd; 946 unsigned long flags; 947 948 /* Make sure that dev is the current device */ 949 write_lock_irqsave(&port->cad_lock, flags); 950 if (port->cad != dev) { 951 write_unlock_irqrestore (&port->cad_lock, flags); 952 printk(KERN_WARNING "%s: %s tried to release parport " 953 "when not owner\n", port->name, dev->name); 954 return; 955 } 956 957 #ifdef CONFIG_PARPORT_1284 958 /* If this is on a mux port, deselect it. */ 959 if (dev->port->muxport >= 0) { 960 /* FIXME */ 961 port->muxsel = -1; 962 } 963 964 /* If this is a daisy device, deselect it. */ 965 if (dev->daisy >= 0) { 966 parport_daisy_deselect_all (port); 967 port->daisy = -1; 968 } 969 #endif 970 971 port->cad = NULL; 972 write_unlock_irqrestore(&port->cad_lock, flags); 973 974 /* Save control registers */ 975 port->ops->save_state(port, dev->state); 976 977 /* If anybody is waiting, find out who's been there longest and 978 then wake them up. (Note: no locking required) */ 979 /* !!! LOCKING IS NEEDED HERE */ 980 for (pd = port->waithead; pd; pd = pd->waitnext) { 981 if (pd->waiting & 2) { /* sleeping in claim_or_block */ 982 parport_claim(pd); 983 if (waitqueue_active(&pd->wait_q)) 984 wake_up_interruptible(&pd->wait_q); 985 return; 986 } else if (pd->wakeup) { 987 pd->wakeup(pd->private); 988 if (dev->port->cad) /* racy but no matter */ 989 return; 990 } else { 991 printk(KERN_ERR "%s: don't know how to wake %s\n", port->name, pd->name); 992 } 993 } 994 995 /* Nobody was waiting, so walk the list to see if anyone is 996 interested in being woken up. (Note: no locking required) */ 997 /* !!! LOCKING IS NEEDED HERE */ 998 for (pd = port->devices; (port->cad == NULL) && pd; pd = pd->next) { 999 if (pd->wakeup && pd != dev) 1000 pd->wakeup(pd->private); 1001 } 1002 } 1003 1004 irqreturn_t parport_irq_handler(int irq, void *dev_id) 1005 { 1006 struct parport *port = dev_id; 1007 1008 parport_generic_irq(port); 1009 1010 return IRQ_HANDLED; 1011 } 1012 1013 /* Exported symbols for modules. */ 1014 1015 EXPORT_SYMBOL(parport_claim); 1016 EXPORT_SYMBOL(parport_claim_or_block); 1017 EXPORT_SYMBOL(parport_release); 1018 EXPORT_SYMBOL(parport_register_port); 1019 EXPORT_SYMBOL(parport_announce_port); 1020 EXPORT_SYMBOL(parport_remove_port); 1021 EXPORT_SYMBOL(parport_register_driver); 1022 EXPORT_SYMBOL(parport_unregister_driver); 1023 EXPORT_SYMBOL(parport_register_device); 1024 EXPORT_SYMBOL(parport_unregister_device); 1025 EXPORT_SYMBOL(parport_get_port); 1026 EXPORT_SYMBOL(parport_put_port); 1027 EXPORT_SYMBOL(parport_find_number); 1028 EXPORT_SYMBOL(parport_find_base); 1029 EXPORT_SYMBOL(parport_irq_handler); 1030 1031 MODULE_LICENSE("GPL"); 1032