linux/drivers/parport/share.c
<<
>>
Prefs
   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(&registration_lock);
 162        list_for_each_entry(port, &portlist, list)
 163                drv->attach(port);
 164        list_add(&drv->list, &drivers);
 165        mutex_unlock(&registration_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(&registration_lock);
 192        list_del_init(&drv->list);
 193        list_for_each_entry(port, &portlist, list)
 194                drv->detach(port);
 195        mutex_unlock(&registration_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 = 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
 358void 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(&registration_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(&registration_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
 412void parport_remove_port(struct parport *port)
 413{
 414        int i;
 415
 416        mutex_lock(&registration_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(&registration_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
 523struct pardevice *
 524parport_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
 640void 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
 712struct 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
 742struct 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
 772int 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
 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                 * 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
 942void 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
1004irqreturn_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
1015EXPORT_SYMBOL(parport_claim);
1016EXPORT_SYMBOL(parport_claim_or_block);
1017EXPORT_SYMBOL(parport_release);
1018EXPORT_SYMBOL(parport_register_port);
1019EXPORT_SYMBOL(parport_announce_port);
1020EXPORT_SYMBOL(parport_remove_port);
1021EXPORT_SYMBOL(parport_register_driver);
1022EXPORT_SYMBOL(parport_unregister_driver);
1023EXPORT_SYMBOL(parport_register_device);
1024EXPORT_SYMBOL(parport_unregister_device);
1025EXPORT_SYMBOL(parport_get_port);
1026EXPORT_SYMBOL(parport_put_port);
1027EXPORT_SYMBOL(parport_find_number);
1028EXPORT_SYMBOL(parport_find_base);
1029EXPORT_SYMBOL(parport_irq_handler);
1030
1031MODULE_LICENSE("GPL");
1032
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.