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 #include <linux/device.h> 33 34 #include <linux/spinlock.h> 35 #include <linux/mutex.h> 36 #include <asm/irq.h> 37 38 #undef PARPORT_PARANOID 39 40 #define PARPORT_DEFAULT_TIMESLICE (HZ/5) 41 42 unsigned long parport_default_timeslice = PARPORT_DEFAULT_TIMESLICE; 43 int parport_default_spintime = DEFAULT_SPIN_TIME; 44 45 static LIST_HEAD(portlist); 46 static DEFINE_SPINLOCK(parportlist_lock); 47 48 /* list of all allocated ports, sorted by ->number */ 49 static LIST_HEAD(all_ports); 50 static DEFINE_SPINLOCK(full_list_lock); 51 52 static LIST_HEAD(drivers); 53 54 static DEFINE_MUTEX(registration_lock); 55 56 /* What you can do to a port that's gone away.. */ 57 static void dead_write_lines (struct parport *p, unsigned char b){} 58 static unsigned char dead_read_lines (struct parport *p) { return 0; } 59 static unsigned char dead_frob_lines (struct parport *p, unsigned char b, 60 unsigned char c) { return 0; } 61 static void dead_onearg (struct parport *p){} 62 static void dead_initstate (struct pardevice *d, struct parport_state *s) { } 63 static void dead_state (struct parport *p, struct parport_state *s) { } 64 static size_t dead_write (struct parport *p, const void *b, size_t l, int f) 65 { return 0; } 66 static size_t dead_read (struct parport *p, void *b, size_t l, int f) 67 { return 0; } 68 static struct parport_operations dead_ops = { 69 .write_data = dead_write_lines, /* data */ 70 .read_data = dead_read_lines, 71 72 .write_control = dead_write_lines, /* control */ 73 .read_control = dead_read_lines, 74 .frob_control = dead_frob_lines, 75 76 .read_status = dead_read_lines, /* status */ 77 78 .enable_irq = dead_onearg, /* enable_irq */ 79 .disable_irq = dead_onearg, /* disable_irq */ 80 81 .data_forward = dead_onearg, /* data_forward */ 82 .data_reverse = dead_onearg, /* data_reverse */ 83 84 .init_state = dead_initstate, /* init_state */ 85 .save_state = dead_state, 86 .restore_state = dead_state, 87 88 .epp_write_data = dead_write, /* epp */ 89 .epp_read_data = dead_read, 90 .epp_write_addr = dead_write, 91 .epp_read_addr = dead_read, 92 93 .ecp_write_data = dead_write, /* ecp */ 94 .ecp_read_data = dead_read, 95 .ecp_write_addr = dead_write, 96 97 .compat_write_data = dead_write, /* compat */ 98 .nibble_read_data = dead_read, /* nibble */ 99 .byte_read_data = dead_read, /* byte */ 100 101 .owner = NULL, 102 }; 103 104 static struct device_type parport_device_type = { 105 .name = "parport", 106 }; 107 108 static int is_parport(struct device *dev) 109 { 110 return dev->type == &parport_device_type; 111 } 112 113 static int parport_probe(struct device *dev) 114 { 115 struct parport_driver *drv; 116 117 if (is_parport(dev)) 118 return -ENODEV; 119 120 drv = to_parport_driver(dev->driver); 121 if (!drv->probe) { 122 /* if driver has not defined a custom probe */ 123 struct pardevice *par_dev = to_pardevice(dev); 124 125 if (strcmp(par_dev->name, drv->name)) 126 return -ENODEV; 127 return 0; 128 } 129 /* if driver defined its own probe */ 130 return drv->probe(to_pardevice(dev)); 131 } 132 133 static struct bus_type parport_bus_type = { 134 .name = "parport", 135 .probe = parport_probe, 136 }; 137 138 int parport_bus_init(void) 139 { 140 return bus_register(&parport_bus_type); 141 } 142 143 void parport_bus_exit(void) 144 { 145 bus_unregister(&parport_bus_type); 146 } 147 148 /* 149 * iterates through all the drivers registered with the bus and sends the port 150 * details to the match_port callback of the driver, so that the driver can 151 * know about the new port that just registered with the bus and decide if it 152 * wants to use this new port. 153 */ 154 static int driver_check(struct device_driver *dev_drv, void *_port) 155 { 156 struct parport *port = _port; 157 struct parport_driver *drv = to_parport_driver(dev_drv); 158 159 if (drv->match_port) 160 drv->match_port(port); 161 return 0; 162 } 163 164 /* Call attach(port) for each registered driver. */ 165 static void attach_driver_chain(struct parport *port) 166 { 167 /* caller has exclusive registration_lock */ 168 struct parport_driver *drv; 169 170 list_for_each_entry(drv, &drivers, list) 171 drv->attach(port); 172 173 /* 174 * call the driver_check function of the drivers registered in 175 * new device model 176 */ 177 178 bus_for_each_drv(&parport_bus_type, NULL, port, driver_check); 179 } 180 181 static int driver_detach(struct device_driver *_drv, void *_port) 182 { 183 struct parport *port = _port; 184 struct parport_driver *drv = to_parport_driver(_drv); 185 186 if (drv->detach) 187 drv->detach(port); 188 return 0; 189 } 190 191 /* Call detach(port) for each registered driver. */ 192 static void detach_driver_chain(struct parport *port) 193 { 194 struct parport_driver *drv; 195 /* caller has exclusive registration_lock */ 196 list_for_each_entry(drv, &drivers, list) 197 drv->detach (port); 198 199 /* 200 * call the detach function of the drivers registered in 201 * new device model 202 */ 203 204 bus_for_each_drv(&parport_bus_type, NULL, port, driver_detach); 205 } 206 207 /* Ask kmod for some lowlevel drivers. */ 208 static void get_lowlevel_driver (void) 209 { 210 /* 211 * There is no actual module called this: you should set 212 * up an alias for modutils. 213 */ 214 request_module ("parport_lowlevel"); 215 } 216 217 /* 218 * iterates through all the devices connected to the bus and sends the device 219 * details to the match_port callback of the driver, so that the driver can 220 * know what are all the ports that are connected to the bus and choose the 221 * port to which it wants to register its device. 222 */ 223 static int port_check(struct device *dev, void *dev_drv) 224 { 225 struct parport_driver *drv = dev_drv; 226 227 /* only send ports, do not send other devices connected to bus */ 228 if (is_parport(dev)) 229 drv->match_port(to_parport_dev(dev)); 230 return 0; 231 } 232 233 /** 234 * parport_register_driver - register a parallel port device driver 235 * @drv: structure describing the driver 236 * @owner: owner module of drv 237 * @mod_name: module name string 238 * 239 * This can be called by a parallel port device driver in order 240 * to receive notifications about ports being found in the 241 * system, as well as ports no longer available. 242 * 243 * If devmodel is true then the new device model is used 244 * for registration. 245 * 246 * The @drv structure is allocated by the caller and must not be 247 * deallocated until after calling parport_unregister_driver(). 248 * 249 * If using the non device model: 250 * The driver's attach() function may block. The port that 251 * attach() is given will be valid for the duration of the 252 * callback, but if the driver wants to take a copy of the 253 * pointer it must call parport_get_port() to do so. Calling 254 * parport_register_device() on that port will do this for you. 255 * 256 * The driver's detach() function may block. The port that 257 * detach() is given will be valid for the duration of the 258 * callback, but if the driver wants to take a copy of the 259 * pointer it must call parport_get_port() to do so. 260 * 261 * 262 * Returns 0 on success. The non device model will always succeeds. 263 * but the new device model can fail and will return the error code. 264 **/ 265 266 int __parport_register_driver(struct parport_driver *drv, struct module *owner, 267 const char *mod_name) 268 { 269 if (list_empty(&portlist)) 270 get_lowlevel_driver (); 271 272 if (drv->devmodel) { 273 /* using device model */ 274 int ret; 275 276 /* initialize common driver fields */ 277 drv->driver.name = drv->name; 278 drv->driver.bus = &parport_bus_type; 279 drv->driver.owner = owner; 280 drv->driver.mod_name = mod_name; 281 ret = driver_register(&drv->driver); 282 if (ret) 283 return ret; 284 285 mutex_lock(®istration_lock); 286 if (drv->match_port) 287 bus_for_each_dev(&parport_bus_type, NULL, drv, 288 port_check); 289 mutex_unlock(®istration_lock); 290 } else { 291 struct parport *port; 292 293 drv->devmodel = false; 294 295 mutex_lock(®istration_lock); 296 list_for_each_entry(port, &portlist, list) 297 drv->attach(port); 298 list_add(&drv->list, &drivers); 299 mutex_unlock(®istration_lock); 300 } 301 302 return 0; 303 } 304 EXPORT_SYMBOL(__parport_register_driver); 305 306 static int port_detach(struct device *dev, void *_drv) 307 { 308 struct parport_driver *drv = _drv; 309 310 if (is_parport(dev) && drv->detach) 311 drv->detach(to_parport_dev(dev)); 312 313 return 0; 314 } 315 316 /** 317 * parport_unregister_driver - deregister a parallel port device driver 318 * @drv: structure describing the driver that was given to 319 * parport_register_driver() 320 * 321 * This should be called by a parallel port device driver that 322 * has registered itself using parport_register_driver() when it 323 * is about to be unloaded. 324 * 325 * When it returns, the driver's attach() routine will no longer 326 * be called, and for each port that attach() was called for, the 327 * detach() routine will have been called. 328 * 329 * All the driver's attach() and detach() calls are guaranteed to have 330 * finished by the time this function returns. 331 **/ 332 333 void parport_unregister_driver (struct parport_driver *drv) 334 { 335 struct parport *port; 336 337 mutex_lock(®istration_lock); 338 if (drv->devmodel) { 339 bus_for_each_dev(&parport_bus_type, NULL, drv, port_detach); 340 driver_unregister(&drv->driver); 341 } else { 342 list_del_init(&drv->list); 343 list_for_each_entry(port, &portlist, list) 344 drv->detach(port); 345 } 346 mutex_unlock(®istration_lock); 347 } 348 EXPORT_SYMBOL(parport_unregister_driver); 349 350 static void free_port(struct device *dev) 351 { 352 int d; 353 struct parport *port = to_parport_dev(dev); 354 355 spin_lock(&full_list_lock); 356 list_del(&port->full_list); 357 spin_unlock(&full_list_lock); 358 for (d = 0; d < 5; d++) { 359 kfree(port->probe_info[d].class_name); 360 kfree(port->probe_info[d].mfr); 361 kfree(port->probe_info[d].model); 362 kfree(port->probe_info[d].cmdset); 363 kfree(port->probe_info[d].description); 364 } 365 366 kfree(port->name); 367 kfree(port); 368 } 369 370 /** 371 * parport_get_port - increment a port's reference count 372 * @port: the port 373 * 374 * This ensures that a struct parport pointer remains valid 375 * until the matching parport_put_port() call. 376 **/ 377 378 struct parport *parport_get_port (struct parport *port) 379 { 380 struct device *dev = get_device(&port->bus_dev); 381 382 return to_parport_dev(dev); 383 } 384 EXPORT_SYMBOL(parport_get_port); 385 386 void parport_del_port(struct parport *port) 387 { 388 device_unregister(&port->bus_dev); 389 } 390 EXPORT_SYMBOL(parport_del_port); 391 392 /** 393 * parport_put_port - decrement a port's reference count 394 * @port: the port 395 * 396 * This should be called once for each call to parport_get_port(), 397 * once the port is no longer needed. When the reference count reaches 398 * zero (port is no longer used), free_port is called. 399 **/ 400 401 void parport_put_port (struct parport *port) 402 { 403 put_device(&port->bus_dev); 404 } 405 EXPORT_SYMBOL(parport_put_port); 406 407 /** 408 * parport_register_port - register a parallel port 409 * @base: base I/O address 410 * @irq: IRQ line 411 * @dma: DMA channel 412 * @ops: pointer to the port driver's port operations structure 413 * 414 * When a parallel port (lowlevel) driver finds a port that 415 * should be made available to parallel port device drivers, it 416 * should call parport_register_port(). The @base, @irq, and 417 * @dma parameters are for the convenience of port drivers, and 418 * for ports where they aren't meaningful needn't be set to 419 * anything special. They can be altered afterwards by adjusting 420 * the relevant members of the parport structure that is returned 421 * and represents the port. They should not be tampered with 422 * after calling parport_announce_port, however. 423 * 424 * If there are parallel port device drivers in the system that 425 * have registered themselves using parport_register_driver(), 426 * they are not told about the port at this time; that is done by 427 * parport_announce_port(). 428 * 429 * The @ops structure is allocated by the caller, and must not be 430 * deallocated before calling parport_remove_port(). 431 * 432 * If there is no memory to allocate a new parport structure, 433 * this function will return %NULL. 434 **/ 435 436 struct parport *parport_register_port(unsigned long base, int irq, int dma, 437 struct parport_operations *ops) 438 { 439 struct list_head *l; 440 struct parport *tmp; 441 int num; 442 int device; 443 char *name; 444 int ret; 445 446 tmp = kzalloc(sizeof(struct parport), GFP_KERNEL); 447 if (!tmp) { 448 printk(KERN_WARNING "parport: memory squeeze\n"); 449 return NULL; 450 } 451 452 /* Init our structure */ 453 tmp->base = base; 454 tmp->irq = irq; 455 tmp->dma = dma; 456 tmp->muxport = tmp->daisy = tmp->muxsel = -1; 457 tmp->modes = 0; 458 INIT_LIST_HEAD(&tmp->list); 459 tmp->devices = tmp->cad = NULL; 460 tmp->flags = 0; 461 tmp->ops = ops; 462 tmp->physport = tmp; 463 memset (tmp->probe_info, 0, 5 * sizeof (struct parport_device_info)); 464 rwlock_init(&tmp->cad_lock); 465 spin_lock_init(&tmp->waitlist_lock); 466 spin_lock_init(&tmp->pardevice_lock); 467 tmp->ieee1284.mode = IEEE1284_MODE_COMPAT; 468 tmp->ieee1284.phase = IEEE1284_PH_FWD_IDLE; 469 sema_init(&tmp->ieee1284.irq, 0); 470 tmp->spintime = parport_default_spintime; 471 atomic_set (&tmp->ref_count, 1); 472 INIT_LIST_HEAD(&tmp->full_list); 473 474 name = kmalloc(15, GFP_KERNEL); 475 if (!name) { 476 printk(KERN_ERR "parport: memory squeeze\n"); 477 kfree(tmp); 478 return NULL; 479 } 480 /* Search for the lowest free parport number. */ 481 482 spin_lock(&full_list_lock); 483 for (l = all_ports.next, num = 0; l != &all_ports; l = l->next, num++) { 484 struct parport *p = list_entry(l, struct parport, full_list); 485 if (p->number != num) 486 break; 487 } 488 tmp->portnum = tmp->number = num; 489 list_add_tail(&tmp->full_list, l); 490 spin_unlock(&full_list_lock); 491 492 /* 493 * Now that the portnum is known finish doing the Init. 494 */ 495 sprintf(name, "parport%d", tmp->portnum = tmp->number); 496 tmp->name = name; 497 tmp->bus_dev.bus = &parport_bus_type; 498 tmp->bus_dev.release = free_port; 499 dev_set_name(&tmp->bus_dev, name); 500 tmp->bus_dev.type = &parport_device_type; 501 502 for (device = 0; device < 5; device++) 503 /* assume the worst */ 504 tmp->probe_info[device].class = PARPORT_CLASS_LEGACY; 505 506 tmp->waithead = tmp->waittail = NULL; 507 508 ret = device_register(&tmp->bus_dev); 509 if (ret) { 510 put_device(&tmp->bus_dev); 511 return NULL; 512 } 513 514 return tmp; 515 } 516 EXPORT_SYMBOL(parport_register_port); 517 518 /** 519 * parport_announce_port - tell device drivers about a parallel port 520 * @port: parallel port to announce 521 * 522 * After a port driver has registered a parallel port with 523 * parport_register_port, and performed any necessary 524 * initialisation or adjustments, it should call 525 * parport_announce_port() in order to notify all device drivers 526 * that have called parport_register_driver(). Their attach() 527 * functions will be called, with @port as the parameter. 528 **/ 529 530 void parport_announce_port (struct parport *port) 531 { 532 int i; 533 534 #ifdef CONFIG_PARPORT_1284 535 /* Analyse the IEEE1284.3 topology of the port. */ 536 parport_daisy_init(port); 537 #endif 538 539 if (!port->dev) 540 printk(KERN_WARNING "%s: fix this legacy no-device port driver!\n", 541 port->name); 542 543 parport_proc_register(port); 544 mutex_lock(®istration_lock); 545 spin_lock_irq(&parportlist_lock); 546 list_add_tail(&port->list, &portlist); 547 for (i = 1; i < 3; i++) { 548 struct parport *slave = port->slaves[i-1]; 549 if (slave) 550 list_add_tail(&slave->list, &portlist); 551 } 552 spin_unlock_irq(&parportlist_lock); 553 554 /* Let drivers know that new port(s) has arrived. */ 555 attach_driver_chain (port); 556 for (i = 1; i < 3; i++) { 557 struct parport *slave = port->slaves[i-1]; 558 if (slave) 559 attach_driver_chain(slave); 560 } 561 mutex_unlock(®istration_lock); 562 } 563 EXPORT_SYMBOL(parport_announce_port); 564 565 /** 566 * parport_remove_port - deregister a parallel port 567 * @port: parallel port to deregister 568 * 569 * When a parallel port driver is forcibly unloaded, or a 570 * parallel port becomes inaccessible, the port driver must call 571 * this function in order to deal with device drivers that still 572 * want to use it. 573 * 574 * The parport structure associated with the port has its 575 * operations structure replaced with one containing 'null' 576 * operations that return errors or just don't do anything. 577 * 578 * Any drivers that have registered themselves using 579 * parport_register_driver() are notified that the port is no 580 * longer accessible by having their detach() routines called 581 * with @port as the parameter. 582 **/ 583 584 void parport_remove_port(struct parport *port) 585 { 586 int i; 587 588 mutex_lock(®istration_lock); 589 590 /* Spread the word. */ 591 detach_driver_chain (port); 592 593 #ifdef CONFIG_PARPORT_1284 594 /* Forget the IEEE1284.3 topology of the port. */ 595 parport_daisy_fini(port); 596 for (i = 1; i < 3; i++) { 597 struct parport *slave = port->slaves[i-1]; 598 if (!slave) 599 continue; 600 detach_driver_chain(slave); 601 parport_daisy_fini(slave); 602 } 603 #endif 604 605 port->ops = &dead_ops; 606 spin_lock(&parportlist_lock); 607 list_del_init(&port->list); 608 for (i = 1; i < 3; i++) { 609 struct parport *slave = port->slaves[i-1]; 610 if (slave) 611 list_del_init(&slave->list); 612 } 613 spin_unlock(&parportlist_lock); 614 615 mutex_unlock(®istration_lock); 616 617 parport_proc_unregister(port); 618 619 for (i = 1; i < 3; i++) { 620 struct parport *slave = port->slaves[i-1]; 621 if (slave) 622 parport_put_port(slave); 623 } 624 } 625 EXPORT_SYMBOL(parport_remove_port); 626 627 /** 628 * parport_register_device - register a device on a parallel port 629 * @port: port to which the device is attached 630 * @name: a name to refer to the device 631 * @pf: preemption callback 632 * @kf: kick callback (wake-up) 633 * @irq_func: interrupt handler 634 * @flags: registration flags 635 * @handle: data for callback functions 636 * 637 * This function, called by parallel port device drivers, 638 * declares that a device is connected to a port, and tells the 639 * system all it needs to know. 640 * 641 * The @name is allocated by the caller and must not be 642 * deallocated until the caller calls @parport_unregister_device 643 * for that device. 644 * 645 * The preemption callback function, @pf, is called when this 646 * device driver has claimed access to the port but another 647 * device driver wants to use it. It is given @handle as its 648 * parameter, and should return zero if it is willing for the 649 * system to release the port to another driver on its behalf. 650 * If it wants to keep control of the port it should return 651 * non-zero, and no action will be taken. It is good manners for 652 * the driver to try to release the port at the earliest 653 * opportunity after its preemption callback rejects a preemption 654 * attempt. Note that if a preemption callback is happy for 655 * preemption to go ahead, there is no need to release the port; 656 * it is done automatically. This function may not block, as it 657 * may be called from interrupt context. If the device driver 658 * does not support preemption, @pf can be %NULL. 659 * 660 * The wake-up ("kick") callback function, @kf, is called when 661 * the port is available to be claimed for exclusive access; that 662 * is, parport_claim() is guaranteed to succeed when called from 663 * inside the wake-up callback function. If the driver wants to 664 * claim the port it should do so; otherwise, it need not take 665 * any action. This function may not block, as it may be called 666 * from interrupt context. If the device driver does not want to 667 * be explicitly invited to claim the port in this way, @kf can 668 * be %NULL. 669 * 670 * The interrupt handler, @irq_func, is called when an interrupt 671 * arrives from the parallel port. Note that if a device driver 672 * wants to use interrupts it should use parport_enable_irq(), 673 * and can also check the irq member of the parport structure 674 * representing the port. 675 * 676 * The parallel port (lowlevel) driver is the one that has called 677 * request_irq() and whose interrupt handler is called first. 678 * This handler does whatever needs to be done to the hardware to 679 * acknowledge the interrupt (for PC-style ports there is nothing 680 * special to be done). It then tells the IEEE 1284 code about 681 * the interrupt, which may involve reacting to an IEEE 1284 682 * event depending on the current IEEE 1284 phase. After this, 683 * it calls @irq_func. Needless to say, @irq_func will be called 684 * from interrupt context, and may not block. 685 * 686 * The %PARPORT_DEV_EXCL flag is for preventing port sharing, and 687 * so should only be used when sharing the port with other device 688 * drivers is impossible and would lead to incorrect behaviour. 689 * Use it sparingly! Normally, @flags will be zero. 690 * 691 * This function returns a pointer to a structure that represents 692 * the device on the port, or %NULL if there is not enough memory 693 * to allocate space for that structure. 694 **/ 695 696 struct pardevice * 697 parport_register_device(struct parport *port, const char *name, 698 int (*pf)(void *), void (*kf)(void *), 699 void (*irq_func)(void *), 700 int flags, void *handle) 701 { 702 struct pardevice *tmp; 703 704 if (port->physport->flags & PARPORT_FLAG_EXCL) { 705 /* An exclusive device is registered. */ 706 printk (KERN_DEBUG "%s: no more devices allowed\n", 707 port->name); 708 return NULL; 709 } 710 711 if (flags & PARPORT_DEV_LURK) { 712 if (!pf || !kf) { 713 printk(KERN_INFO "%s: refused to register lurking device (%s) without callbacks\n", port->name, name); 714 return NULL; 715 } 716 } 717 718 if (flags & PARPORT_DEV_EXCL) { 719 if (port->physport->devices) { 720 /* 721 * If a device is already registered and this new 722 * device wants exclusive access, then no need to 723 * continue as we can not grant exclusive access to 724 * this device. 725 */ 726 pr_err("%s: cannot grant exclusive access for device %s\n", 727 port->name, name); 728 return NULL; 729 } 730 } 731 732 /* 733 * We up our own module reference count, and that of the port 734 * on which a device is to be registered, to ensure that 735 * neither of us gets unloaded while we sleep in (e.g.) 736 * kmalloc. 737 */ 738 if (!try_module_get(port->ops->owner)) { 739 return NULL; 740 } 741 742 parport_get_port (port); 743 744 tmp = kmalloc(sizeof(struct pardevice), GFP_KERNEL); 745 if (tmp == NULL) { 746 printk(KERN_WARNING "%s: memory squeeze, couldn't register %s.\n", port->name, name); 747 goto out; 748 } 749 750 tmp->state = kmalloc(sizeof(struct parport_state), GFP_KERNEL); 751 if (tmp->state == NULL) { 752 printk(KERN_WARNING "%s: memory squeeze, couldn't register %s.\n", port->name, name); 753 goto out_free_pardevice; 754 } 755 756 tmp->name = name; 757 tmp->port = port; 758 tmp->daisy = -1; 759 tmp->preempt = pf; 760 tmp->wakeup = kf; 761 tmp->private = handle; 762 tmp->flags = flags; 763 tmp->irq_func = irq_func; 764 tmp->waiting = 0; 765 tmp->timeout = 5 * HZ; 766 tmp->devmodel = false; 767 768 /* Chain this onto the list */ 769 tmp->prev = NULL; 770 /* 771 * This function must not run from an irq handler so we don' t need 772 * to clear irq on the local CPU. -arca 773 */ 774 spin_lock(&port->physport->pardevice_lock); 775 776 if (flags & PARPORT_DEV_EXCL) { 777 if (port->physport->devices) { 778 spin_unlock (&port->physport->pardevice_lock); 779 printk (KERN_DEBUG 780 "%s: cannot grant exclusive access for device %s\n", 781 port->name, name); 782 goto out_free_all; 783 } 784 port->flags |= PARPORT_FLAG_EXCL; 785 } 786 787 tmp->next = port->physport->devices; 788 wmb(); /* 789 * Make sure that tmp->next is written before it's 790 * added to the list; see comments marked 'no locking 791 * required' 792 */ 793 if (port->physport->devices) 794 port->physport->devices->prev = tmp; 795 port->physport->devices = tmp; 796 spin_unlock(&port->physport->pardevice_lock); 797 798 init_waitqueue_head(&tmp->wait_q); 799 tmp->timeslice = parport_default_timeslice; 800 tmp->waitnext = tmp->waitprev = NULL; 801 802 /* 803 * This has to be run as last thing since init_state may need other 804 * pardevice fields. -arca 805 */ 806 port->ops->init_state(tmp, tmp->state); 807 if (!test_and_set_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags)) { 808 port->proc_device = tmp; 809 parport_device_proc_register(tmp); 810 } 811 return tmp; 812 813 out_free_all: 814 kfree(tmp->state); 815 out_free_pardevice: 816 kfree(tmp); 817 out: 818 parport_put_port (port); 819 module_put(port->ops->owner); 820 821 return NULL; 822 } 823 EXPORT_SYMBOL(parport_register_device); 824 825 static void free_pardevice(struct device *dev) 826 { 827 struct pardevice *par_dev = to_pardevice(dev); 828 829 kfree(par_dev->name); 830 kfree(par_dev); 831 } 832 833 struct pardevice * 834 parport_register_dev_model(struct parport *port, const char *name, 835 const struct pardev_cb *par_dev_cb, int id) 836 { 837 struct pardevice *par_dev; 838 int ret; 839 char *devname; 840 841 if (port->physport->flags & PARPORT_FLAG_EXCL) { 842 /* An exclusive device is registered. */ 843 pr_err("%s: no more devices allowed\n", port->name); 844 return NULL; 845 } 846 847 if (par_dev_cb->flags & PARPORT_DEV_LURK) { 848 if (!par_dev_cb->preempt || !par_dev_cb->wakeup) { 849 pr_info("%s: refused to register lurking device (%s) without callbacks\n", 850 port->name, name); 851 return NULL; 852 } 853 } 854 855 if (par_dev_cb->flags & PARPORT_DEV_EXCL) { 856 if (port->physport->devices) { 857 /* 858 * If a device is already registered and this new 859 * device wants exclusive access, then no need to 860 * continue as we can not grant exclusive access to 861 * this device. 862 */ 863 pr_err("%s: cannot grant exclusive access for device %s\n", 864 port->name, name); 865 return NULL; 866 } 867 } 868 869 if (!try_module_get(port->ops->owner)) 870 return NULL; 871 872 parport_get_port(port); 873 874 par_dev = kzalloc(sizeof(*par_dev), GFP_KERNEL); 875 if (!par_dev) 876 goto err_put_port; 877 878 par_dev->state = kzalloc(sizeof(*par_dev->state), GFP_KERNEL); 879 if (!par_dev->state) 880 goto err_put_par_dev; 881 882 devname = kstrdup(name, GFP_KERNEL); 883 if (!devname) 884 goto err_free_par_dev; 885 886 par_dev->name = devname; 887 par_dev->port = port; 888 par_dev->daisy = -1; 889 par_dev->preempt = par_dev_cb->preempt; 890 par_dev->wakeup = par_dev_cb->wakeup; 891 par_dev->private = par_dev_cb->private; 892 par_dev->flags = par_dev_cb->flags; 893 par_dev->irq_func = par_dev_cb->irq_func; 894 par_dev->waiting = 0; 895 par_dev->timeout = 5 * HZ; 896 897 par_dev->dev.parent = &port->bus_dev; 898 par_dev->dev.bus = &parport_bus_type; 899 ret = dev_set_name(&par_dev->dev, "%s.%d", devname, id); 900 if (ret) 901 goto err_free_devname; 902 par_dev->dev.release = free_pardevice; 903 par_dev->devmodel = true; 904 ret = device_register(&par_dev->dev); 905 if (ret) { 906 put_device(&par_dev->dev); 907 goto err_put_port; 908 } 909 910 /* Chain this onto the list */ 911 par_dev->prev = NULL; 912 /* 913 * This function must not run from an irq handler so we don' t need 914 * to clear irq on the local CPU. -arca 915 */ 916 spin_lock(&port->physport->pardevice_lock); 917 918 if (par_dev_cb->flags & PARPORT_DEV_EXCL) { 919 if (port->physport->devices) { 920 spin_unlock(&port->physport->pardevice_lock); 921 pr_debug("%s: cannot grant exclusive access for device %s\n", 922 port->name, name); 923 device_unregister(&par_dev->dev); 924 goto err_put_port; 925 } 926 port->flags |= PARPORT_FLAG_EXCL; 927 } 928 929 par_dev->next = port->physport->devices; 930 wmb(); /* 931 * Make sure that tmp->next is written before it's 932 * added to the list; see comments marked 'no locking 933 * required' 934 */ 935 if (port->physport->devices) 936 port->physport->devices->prev = par_dev; 937 port->physport->devices = par_dev; 938 spin_unlock(&port->physport->pardevice_lock); 939 940 init_waitqueue_head(&par_dev->wait_q); 941 par_dev->timeslice = parport_default_timeslice; 942 par_dev->waitnext = NULL; 943 par_dev->waitprev = NULL; 944 945 /* 946 * This has to be run as last thing since init_state may need other 947 * pardevice fields. -arca 948 */ 949 port->ops->init_state(par_dev, par_dev->state); 950 port->proc_device = par_dev; 951 parport_device_proc_register(par_dev); 952 953 return par_dev; 954 955 err_free_devname: 956 kfree(devname); 957 err_free_par_dev: 958 kfree(par_dev->state); 959 err_put_par_dev: 960 if (!par_dev->devmodel) 961 kfree(par_dev); 962 err_put_port: 963 parport_put_port(port); 964 module_put(port->ops->owner); 965 966 return NULL; 967 } 968 EXPORT_SYMBOL(parport_register_dev_model); 969 970 /** 971 * parport_unregister_device - deregister a device on a parallel port 972 * @dev: pointer to structure representing device 973 * 974 * This undoes the effect of parport_register_device(). 975 **/ 976 977 void parport_unregister_device(struct pardevice *dev) 978 { 979 struct parport *port; 980 981 #ifdef PARPORT_PARANOID 982 if (dev == NULL) { 983 printk(KERN_ERR "parport_unregister_device: passed NULL\n"); 984 return; 985 } 986 #endif 987 988 port = dev->port->physport; 989 990 if (port->proc_device == dev) { 991 port->proc_device = NULL; 992 clear_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags); 993 parport_device_proc_unregister(dev); 994 } 995 996 if (port->cad == dev) { 997 printk(KERN_DEBUG "%s: %s forgot to release port\n", 998 port->name, dev->name); 999 parport_release (dev); 1000 } 1001 1002 spin_lock(&port->pardevice_lock); 1003 if (dev->next) 1004 dev->next->prev = dev->prev; 1005 if (dev->prev) 1006 dev->prev->next = dev->next; 1007 else 1008 port->devices = dev->next; 1009 1010 if (dev->flags & PARPORT_DEV_EXCL) 1011 port->flags &= ~PARPORT_FLAG_EXCL; 1012 1013 spin_unlock(&port->pardevice_lock); 1014 1015 /* 1016 * Make sure we haven't left any pointers around in the wait 1017 * list. 1018 */ 1019 spin_lock_irq(&port->waitlist_lock); 1020 if (dev->waitprev || dev->waitnext || port->waithead == dev) { 1021 if (dev->waitprev) 1022 dev->waitprev->waitnext = dev->waitnext; 1023 else 1024 port->waithead = dev->waitnext; 1025 if (dev->waitnext) 1026 dev->waitnext->waitprev = dev->waitprev; 1027 else 1028 port->waittail = dev->waitprev; 1029 } 1030 spin_unlock_irq(&port->waitlist_lock); 1031 1032 kfree(dev->state); 1033 if (dev->devmodel) 1034 device_unregister(&dev->dev); 1035 else 1036 kfree(dev); 1037 1038 module_put(port->ops->owner); 1039 parport_put_port (port); 1040 } 1041 EXPORT_SYMBOL(parport_unregister_device); 1042 1043 /** 1044 * parport_find_number - find a parallel port by number 1045 * @number: parallel port number 1046 * 1047 * This returns the parallel port with the specified number, or 1048 * %NULL if there is none. 1049 * 1050 * There is an implicit parport_get_port() done already; to throw 1051 * away the reference to the port that parport_find_number() 1052 * gives you, use parport_put_port(). 1053 */ 1054 1055 struct parport *parport_find_number (int number) 1056 { 1057 struct parport *port, *result = NULL; 1058 1059 if (list_empty(&portlist)) 1060 get_lowlevel_driver (); 1061 1062 spin_lock (&parportlist_lock); 1063 list_for_each_entry(port, &portlist, list) { 1064 if (port->number == number) { 1065 result = parport_get_port (port); 1066 break; 1067 } 1068 } 1069 spin_unlock (&parportlist_lock); 1070 return result; 1071 } 1072 EXPORT_SYMBOL(parport_find_number); 1073 1074 /** 1075 * parport_find_base - find a parallel port by base address 1076 * @base: base I/O address 1077 * 1078 * This returns the parallel port with the specified base 1079 * address, or %NULL if there is none. 1080 * 1081 * There is an implicit parport_get_port() done already; to throw 1082 * away the reference to the port that parport_find_base() 1083 * gives you, use parport_put_port(). 1084 */ 1085 1086 struct parport *parport_find_base (unsigned long base) 1087 { 1088 struct parport *port, *result = NULL; 1089 1090 if (list_empty(&portlist)) 1091 get_lowlevel_driver (); 1092 1093 spin_lock (&parportlist_lock); 1094 list_for_each_entry(port, &portlist, list) { 1095 if (port->base == base) { 1096 result = parport_get_port (port); 1097 break; 1098 } 1099 } 1100 spin_unlock (&parportlist_lock); 1101 return result; 1102 } 1103 EXPORT_SYMBOL(parport_find_base); 1104 1105 /** 1106 * parport_claim - claim access to a parallel port device 1107 * @dev: pointer to structure representing a device on the port 1108 * 1109 * This function will not block and so can be used from interrupt 1110 * context. If parport_claim() succeeds in claiming access to 1111 * the port it returns zero and the port is available to use. It 1112 * may fail (returning non-zero) if the port is in use by another 1113 * driver and that driver is not willing to relinquish control of 1114 * the port. 1115 **/ 1116 1117 int parport_claim(struct pardevice *dev) 1118 { 1119 struct pardevice *oldcad; 1120 struct parport *port = dev->port->physport; 1121 unsigned long flags; 1122 1123 if (port->cad == dev) { 1124 printk(KERN_INFO "%s: %s already owner\n", 1125 dev->port->name,dev->name); 1126 return 0; 1127 } 1128 1129 /* Preempt any current device */ 1130 write_lock_irqsave (&port->cad_lock, flags); 1131 if ((oldcad = port->cad) != NULL) { 1132 if (oldcad->preempt) { 1133 if (oldcad->preempt(oldcad->private)) 1134 goto blocked; 1135 port->ops->save_state(port, dev->state); 1136 } else 1137 goto blocked; 1138 1139 if (port->cad != oldcad) { 1140 /* 1141 * I think we'll actually deadlock rather than 1142 * get here, but just in case.. 1143 */ 1144 printk(KERN_WARNING 1145 "%s: %s released port when preempted!\n", 1146 port->name, oldcad->name); 1147 if (port->cad) 1148 goto blocked; 1149 } 1150 } 1151 1152 /* Can't fail from now on, so mark ourselves as no longer waiting. */ 1153 if (dev->waiting & 1) { 1154 dev->waiting = 0; 1155 1156 /* Take ourselves out of the wait list again. */ 1157 spin_lock_irq (&port->waitlist_lock); 1158 if (dev->waitprev) 1159 dev->waitprev->waitnext = dev->waitnext; 1160 else 1161 port->waithead = dev->waitnext; 1162 if (dev->waitnext) 1163 dev->waitnext->waitprev = dev->waitprev; 1164 else 1165 port->waittail = dev->waitprev; 1166 spin_unlock_irq (&port->waitlist_lock); 1167 dev->waitprev = dev->waitnext = NULL; 1168 } 1169 1170 /* Now we do the change of devices */ 1171 port->cad = dev; 1172 1173 #ifdef CONFIG_PARPORT_1284 1174 /* If it's a mux port, select it. */ 1175 if (dev->port->muxport >= 0) { 1176 /* FIXME */ 1177 port->muxsel = dev->port->muxport; 1178 } 1179 1180 /* If it's a daisy chain device, select it. */ 1181 if (dev->daisy >= 0) { 1182 /* This could be lazier. */ 1183 if (!parport_daisy_select (port, dev->daisy, 1184 IEEE1284_MODE_COMPAT)) 1185 port->daisy = dev->daisy; 1186 } 1187 #endif /* IEEE1284.3 support */ 1188 1189 /* Restore control registers */ 1190 port->ops->restore_state(port, dev->state); 1191 write_unlock_irqrestore(&port->cad_lock, flags); 1192 dev->time = jiffies; 1193 return 0; 1194 1195 blocked: 1196 /* 1197 * If this is the first time we tried to claim the port, register an 1198 * interest. This is only allowed for devices sleeping in 1199 * parport_claim_or_block(), or those with a wakeup function. 1200 */ 1201 1202 /* The cad_lock is still held for writing here */ 1203 if (dev->waiting & 2 || dev->wakeup) { 1204 spin_lock (&port->waitlist_lock); 1205 if (test_and_set_bit(0, &dev->waiting) == 0) { 1206 /* First add ourselves to the end of the wait list. */ 1207 dev->waitnext = NULL; 1208 dev->waitprev = port->waittail; 1209 if (port->waittail) { 1210 port->waittail->waitnext = dev; 1211 port->waittail = dev; 1212 } else 1213 port->waithead = port->waittail = dev; 1214 } 1215 spin_unlock (&port->waitlist_lock); 1216 } 1217 write_unlock_irqrestore (&port->cad_lock, flags); 1218 return -EAGAIN; 1219 } 1220 EXPORT_SYMBOL(parport_claim); 1221 1222 /** 1223 * parport_claim_or_block - claim access to a parallel port device 1224 * @dev: pointer to structure representing a device on the port 1225 * 1226 * This behaves like parport_claim(), but will block if necessary 1227 * to wait for the port to be free. A return value of 1 1228 * indicates that it slept; 0 means that it succeeded without 1229 * needing to sleep. A negative error code indicates failure. 1230 **/ 1231 1232 int parport_claim_or_block(struct pardevice *dev) 1233 { 1234 int r; 1235 1236 /* 1237 * Signal to parport_claim() that we can wait even without a 1238 * wakeup function. 1239 */ 1240 dev->waiting = 2; 1241 1242 /* Try to claim the port. If this fails, we need to sleep. */ 1243 r = parport_claim(dev); 1244 if (r == -EAGAIN) { 1245 #ifdef PARPORT_DEBUG_SHARING 1246 printk(KERN_DEBUG "%s: parport_claim() returned -EAGAIN\n", dev->name); 1247 #endif 1248 /* 1249 * FIXME!!! Use the proper locking for dev->waiting, 1250 * and make this use the "wait_event_interruptible()" 1251 * interfaces. The cli/sti that used to be here 1252 * did nothing. 1253 * 1254 * See also parport_release() 1255 */ 1256 1257 /* 1258 * If dev->waiting is clear now, an interrupt 1259 * gave us the port and we would deadlock if we slept. 1260 */ 1261 if (dev->waiting) { 1262 wait_event_interruptible(dev->wait_q, 1263 !dev->waiting); 1264 if (signal_pending (current)) { 1265 return -EINTR; 1266 } 1267 r = 1; 1268 } else { 1269 r = 0; 1270 #ifdef PARPORT_DEBUG_SHARING 1271 printk(KERN_DEBUG "%s: didn't sleep in parport_claim_or_block()\n", 1272 dev->name); 1273 #endif 1274 } 1275 1276 #ifdef PARPORT_DEBUG_SHARING 1277 if (dev->port->physport->cad != dev) 1278 printk(KERN_DEBUG "%s: exiting parport_claim_or_block but %s owns port!\n", 1279 dev->name, dev->port->physport->cad ? 1280 dev->port->physport->cad->name:"nobody"); 1281 #endif 1282 } 1283 dev->waiting = 0; 1284 return r; 1285 } 1286 EXPORT_SYMBOL(parport_claim_or_block); 1287 1288 /** 1289 * parport_release - give up access to a parallel port device 1290 * @dev: pointer to structure representing parallel port device 1291 * 1292 * This function cannot fail, but it should not be called without 1293 * the port claimed. Similarly, if the port is already claimed 1294 * you should not try claiming it again. 1295 **/ 1296 1297 void parport_release(struct pardevice *dev) 1298 { 1299 struct parport *port = dev->port->physport; 1300 struct pardevice *pd; 1301 unsigned long flags; 1302 1303 /* Make sure that dev is the current device */ 1304 write_lock_irqsave(&port->cad_lock, flags); 1305 if (port->cad != dev) { 1306 write_unlock_irqrestore (&port->cad_lock, flags); 1307 printk(KERN_WARNING "%s: %s tried to release parport when not owner\n", 1308 port->name, dev->name); 1309 return; 1310 } 1311 1312 #ifdef CONFIG_PARPORT_1284 1313 /* If this is on a mux port, deselect it. */ 1314 if (dev->port->muxport >= 0) { 1315 /* FIXME */ 1316 port->muxsel = -1; 1317 } 1318 1319 /* If this is a daisy device, deselect it. */ 1320 if (dev->daisy >= 0) { 1321 parport_daisy_deselect_all (port); 1322 port->daisy = -1; 1323 } 1324 #endif 1325 1326 port->cad = NULL; 1327 write_unlock_irqrestore(&port->cad_lock, flags); 1328 1329 /* Save control registers */ 1330 port->ops->save_state(port, dev->state); 1331 1332 /* 1333 * If anybody is waiting, find out who's been there longest and 1334 * then wake them up. (Note: no locking required) 1335 */ 1336 /* !!! LOCKING IS NEEDED HERE */ 1337 for (pd = port->waithead; pd; pd = pd->waitnext) { 1338 if (pd->waiting & 2) { /* sleeping in claim_or_block */ 1339 parport_claim(pd); 1340 if (waitqueue_active(&pd->wait_q)) 1341 wake_up_interruptible(&pd->wait_q); 1342 return; 1343 } else if (pd->wakeup) { 1344 pd->wakeup(pd->private); 1345 if (dev->port->cad) /* racy but no matter */ 1346 return; 1347 } else { 1348 printk(KERN_ERR "%s: don't know how to wake %s\n", port->name, pd->name); 1349 } 1350 } 1351 1352 /* 1353 * Nobody was waiting, so walk the list to see if anyone is 1354 * interested in being woken up. (Note: no locking required) 1355 */ 1356 /* !!! LOCKING IS NEEDED HERE */ 1357 for (pd = port->devices; (port->cad == NULL) && pd; pd = pd->next) { 1358 if (pd->wakeup && pd != dev) 1359 pd->wakeup(pd->private); 1360 } 1361 } 1362 EXPORT_SYMBOL(parport_release); 1363 1364 irqreturn_t parport_irq_handler(int irq, void *dev_id) 1365 { 1366 struct parport *port = dev_id; 1367 1368 parport_generic_irq(port); 1369 1370 return IRQ_HANDLED; 1371 } 1372 EXPORT_SYMBOL(parport_irq_handler); 1373 1374 MODULE_LICENSE("GPL"); 1375