drivers/net/irda/sir_dongle.c

   1 /*********************************************************************
   2  *
   3  *      sir_dongle.c:   manager for serial dongle protocol drivers
   4  *
   5  *      Copyright (c) 2002 Martin Diehl
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License as
   9  *      published by the Free Software Foundation; either version 2 of
  10  *      the License, or (at your option) any later version.
  11  *
  12  ********************************************************************/
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/kmod.h>
  18 #include <linux/mutex.h>
  19
  20 #include <net/irda/irda.h>
  21
  22 #include "sir-dev.h"
  23
  24 /**************************************************************************
  25  *
  26  * dongle registration and attachment
  27  *
  28  */
  29
  30 static LIST_HEAD(dongle_list);                  /* list of registered dongle drivers */
  31 static DEFINE_MUTEX(dongle_list_lock);          /* protects the list */
  32
  33 int irda_register_dongle(struct dongle_driver *new)
  34 {
  35         struct list_head *entry;
  36         struct dongle_driver *drv;
  37
  38         IRDA_DEBUG(0, "%s : registering dongle \"%s\" (%d).\n",
  39                    __FUNCTION__, new->driver_name, new->type);
  40
  41         mutex_lock(&dongle_list_lock);
  42         list_for_each(entry, &dongle_list) {
  43                 drv = list_entry(entry, struct dongle_driver, dongle_list);
  44                 if (new->type == drv->type) {
  45                         mutex_unlock(&dongle_list_lock);
  46                         return -EEXIST;
  47                 }
  48         }
  49         list_add(&new->dongle_list, &dongle_list);
  50         mutex_unlock(&dongle_list_lock);
  51         return 0;
  52 }
  53 EXPORT_SYMBOL(irda_register_dongle);
  54
  55 int irda_unregister_dongle(struct dongle_driver *drv)
  56 {
  57         mutex_lock(&dongle_list_lock);
  58         list_del(&drv->dongle_list);
  59         mutex_unlock(&dongle_list_lock);
  60         return 0;
  61 }
  62 EXPORT_SYMBOL(irda_unregister_dongle);
  63
  64 int sirdev_get_dongle(struct sir_dev *dev, IRDA_DONGLE type)
  65 {
  66         struct list_head *entry;
  67         const struct dongle_driver *drv = NULL;
  68         int err = -EINVAL;
  69
  70 #ifdef CONFIG_KMOD
  71         request_module("irda-dongle-%d", type);
  72 #endif
  73
  74         if (dev->dongle_drv != NULL)
  75                 return -EBUSY;
  76
  77         /* serialize access to the list of registered dongles */
  78         mutex_lock(&dongle_list_lock);
  79
  80         list_for_each(entry, &dongle_list) {
  81                 drv = list_entry(entry, struct dongle_driver, dongle_list);
  82                 if (drv->type == type)
  83                         break;
  84                 else
  85                         drv = NULL;
  86         }
  87
  88         if (!drv) {
  89                 err = -ENODEV;
  90                 goto out_unlock;        /* no such dongle */
  91         }
  92
  93         /* handling of SMP races with dongle module removal - three cases:
  94          * 1) dongle driver was already unregistered - then we haven't found the
  95          *      requested dongle above and are already out here
  96          * 2) the module is already marked deleted but the driver is still
  97          *      registered - then the try_module_get() below will fail
  98          * 3) the try_module_get() below succeeds before the module is marked
  99          *      deleted - then sys_delete_module() fails and prevents the removal
 100          *      because the module is in use.
 101          */
 102
 103         if (!try_module_get(drv->owner)) {
 104                 err = -ESTALE;
 105                 goto out_unlock;        /* rmmod already pending */
 106         }
 107         dev->dongle_drv = drv;
 108
 109         if (!drv->open  ||  (err=drv->open(dev))!=0)
 110                 goto out_reject;                /* failed to open driver */
 111
 112         mutex_unlock(&dongle_list_lock);
 113         return 0;
 114
 115 out_reject:
 116         dev->dongle_drv = NULL;
 117         module_put(drv->owner);
 118 out_unlock:
 119         mutex_unlock(&dongle_list_lock);
 120         return err;
 121 }
 122
 123 int sirdev_put_dongle(struct sir_dev *dev)
 124 {
 125         const struct dongle_driver *drv = dev->dongle_drv;
 126
 127         if (drv) {
 128                 if (drv->close)
 129                         drv->close(dev);                /* close this dongle instance */
 130
 131                 dev->dongle_drv = NULL;                 /* unlink the dongle driver */
 132                 module_put(drv->owner);/* decrement driver's module refcount */
 133         }
 134
 135         return 0;
 136 }