drivers/usb/storage/libusual.c

   1 /*
   2  * libusual
   3  *
   4  * The libusual contains the table of devices common for ub and usb-storage.
   5  */
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/usb.h>
   9 #include <linux/usb_usual.h>
  10 #include <linux/vmalloc.h>
  11
  12 /*
  13  */
  14 #define USU_MOD_FL_THREAD   1   /* Thread is running */
  15 #define USU_MOD_FL_PRESENT  2   /* The module is loaded */
  16
  17 struct mod_status {
  18         unsigned long fls;
  19 };
  20
  21 static struct mod_status stat[3];
  22 static DEFINE_SPINLOCK(usu_lock);
  23
  24 /*
  25  */
  26 #define USB_US_DEFAULT_BIAS     USB_US_TYPE_STOR
  27 static atomic_t usu_bias = ATOMIC_INIT(USB_US_DEFAULT_BIAS);
  28
  29 #define BIAS_NAME_SIZE  (sizeof("usb-storage"))
  30 static const char *bias_names[3] = { "none", "usb-storage", "ub" };
  31
  32 static DECLARE_MUTEX_LOCKED(usu_init_notify);
  33 static DECLARE_COMPLETION(usu_end_notify);
  34 static atomic_t total_threads = ATOMIC_INIT(0);
  35
  36 static int usu_probe_thread(void *arg);
  37
  38 /*
  39  * The table.
  40  */
  41 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
  42                     vendorName, productName,useProtocol, useTransport, \
  43                     initFunction, flags) \
  44 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
  45   .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
  46
  47 #define USUAL_DEV(useProto, useTrans, useType) \
  48 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
  49   .driver_info = ((useType)<<24) }
  50
  51 struct usb_device_id storage_usb_ids [] = {
  52 #       include "unusual_devs.h"
  53         { } /* Terminating entry */
  54 };
  55
  56 #undef USUAL_DEV
  57 #undef UNUSUAL_DEV
  58
  59 MODULE_DEVICE_TABLE(usb, storage_usb_ids);
  60 EXPORT_SYMBOL_GPL(storage_usb_ids);
  61
  62 /*
  63  * @type: the module type as an integer
  64  */
  65 void usb_usual_set_present(int type)
  66 {
  67         struct mod_status *st;
  68         unsigned long flags;
  69
  70         if (type <= 0 || type >= 3)
  71                 return;
  72         st = &stat[type];
  73         spin_lock_irqsave(&usu_lock, flags);
  74         st->fls |= USU_MOD_FL_PRESENT;
  75         spin_unlock_irqrestore(&usu_lock, flags);
  76 }
  77 EXPORT_SYMBOL_GPL(usb_usual_set_present);
  78
  79 void usb_usual_clear_present(int type)
  80 {
  81         struct mod_status *st;
  82         unsigned long flags;
  83
  84         if (type <= 0 || type >= 3)
  85                 return;
  86         st = &stat[type];
  87         spin_lock_irqsave(&usu_lock, flags);
  88         st->fls &= ~USU_MOD_FL_PRESENT;
  89         spin_unlock_irqrestore(&usu_lock, flags);
  90 }
  91 EXPORT_SYMBOL_GPL(usb_usual_clear_present);
  92
  93 /*
  94  * Match the calling driver type against the table.
  95  * Returns: 0 if the device matches.
  96  */
  97 int usb_usual_check_type(const struct usb_device_id *id, int caller_type)
  98 {
  99         int id_type = USB_US_TYPE(id->driver_info);
 100
 101         if (caller_type <= 0 || caller_type >= 3)
 102                 return -EINVAL;
 103
 104         /* Drivers grab fixed assignment devices */
 105         if (id_type == caller_type)
 106                 return 0;
 107         /* Drivers grab devices biased to them */
 108         if (id_type == USB_US_TYPE_NONE && caller_type == atomic_read(&usu_bias))
 109                 return 0;
 110         return -ENODEV;
 111 }
 112 EXPORT_SYMBOL_GPL(usb_usual_check_type);
 113
 114 /*
 115  */
 116 static int usu_probe(struct usb_interface *intf,
 117                          const struct usb_device_id *id)
 118 {
 119         int type;
 120         int rc;
 121         unsigned long flags;
 122
 123         type = USB_US_TYPE(id->driver_info);
 124         if (type == 0)
 125                 type = atomic_read(&usu_bias);
 126
 127         spin_lock_irqsave(&usu_lock, flags);
 128         if ((stat[type].fls & (USU_MOD_FL_THREAD|USU_MOD_FL_PRESENT)) != 0) {
 129                 spin_unlock_irqrestore(&usu_lock, flags);
 130                 return -ENXIO;
 131         }
 132         stat[type].fls |= USU_MOD_FL_THREAD;
 133         spin_unlock_irqrestore(&usu_lock, flags);
 134
 135         rc = kernel_thread(usu_probe_thread, (void*)type, CLONE_VM);
 136         if (rc < 0) {
 137                 printk(KERN_WARNING "libusual: "
 138                     "Unable to start the thread for %s: %d\n",
 139                     bias_names[type], rc);
 140                 spin_lock_irqsave(&usu_lock, flags);
 141                 stat[type].fls &= ~USU_MOD_FL_THREAD;
 142                 spin_unlock_irqrestore(&usu_lock, flags);
 143                 return rc;      /* Not being -ENXIO causes a message printed */
 144         }
 145         atomic_inc(&total_threads);
 146
 147         return -ENXIO;
 148 }
 149
 150 static void usu_disconnect(struct usb_interface *intf)
 151 {
 152         ;       /* We should not be here. */
 153 }
 154
 155 static struct usb_driver usu_driver = {
 156         .name =         "libusual",
 157         .probe =        usu_probe,
 158         .disconnect =   usu_disconnect,
 159         .id_table =     storage_usb_ids,
 160 };
 161
 162 /*
 163  * A whole new thread for a purpose of request_module seems quite stupid.
 164  * The request_module forks once inside again. However, if we attempt
 165  * to load a storage module from our own modprobe thread, that module
 166  * references our symbols, which cannot be resolved until our module is
 167  * initialized. I wish there was a way to wait for the end of initialization.
 168  * The module notifier reports MODULE_STATE_COMING only.
 169  * So, we wait until module->init ends as the next best thing.
 170  */
 171 static int usu_probe_thread(void *arg)
 172 {
 173         int type = (unsigned long) arg;
 174         struct mod_status *st = &stat[type];
 175         int rc;
 176         unsigned long flags;
 177
 178         daemonize("libusual_%d", type); /* "usb-storage" is kinda too long */
 179
 180         /* A completion does not work here because it's counted. */
 181         down(&usu_init_notify);
 182         up(&usu_init_notify);
 183
 184         rc = request_module(bias_names[type]);
 185         spin_lock_irqsave(&usu_lock, flags);
 186         if (rc == 0 && (st->fls & USU_MOD_FL_PRESENT) == 0) {
 187                 /*
 188                  * This should not happen, but let us keep tabs on it.
 189                  */
 190                 printk(KERN_NOTICE "libusual: "
 191                     "modprobe for %s succeeded, but module is not present\n",
 192                     bias_names[type]);
 193         }
 194         st->fls &= ~USU_MOD_FL_THREAD;
 195         spin_unlock_irqrestore(&usu_lock, flags);
 196
 197         complete_and_exit(&usu_end_notify, 0);
 198 }
 199
 200 /*
 201  */
 202 static int __init usb_usual_init(void)
 203 {
 204         int rc;
 205
 206         rc = usb_register(&usu_driver);
 207         up(&usu_init_notify);
 208         return rc;
 209 }
 210
 211 static void __exit usb_usual_exit(void)
 212 {
 213         /*
 214          * We do not check for any drivers present, because
 215          * they keep us pinned with symbol references.
 216          */
 217
 218         usb_deregister(&usu_driver);
 219
 220         while (atomic_read(&total_threads) > 0) {
 221                 wait_for_completion(&usu_end_notify);
 222                 atomic_dec(&total_threads);
 223         }
 224 }
 225
 226 /*
 227  * Validate and accept the bias parameter.
 228  */
 229 static int usu_set_bias(const char *bias_s, struct kernel_param *kp)
 230 {
 231         int i;
 232         int len;
 233         int bias_n = 0;
 234
 235         len = strlen(bias_s);
 236         if (len == 0)
 237                 return -EDOM;
 238         if (bias_s[len-1] == '\n')
 239                 --len;
 240
 241         for (i = 1; i < 3; i++) {
 242                 if (strncmp(bias_s, bias_names[i], len) == 0) {
 243                         bias_n = i;
 244                         break;
 245                 }
 246         }
 247         if (bias_n == 0)
 248                 return -EINVAL;
 249
 250         atomic_set(&usu_bias, bias_n);
 251         return 0;
 252 }
 253
 254 static int usu_get_bias(char *buffer, struct kernel_param *kp)
 255 {
 256         return strlen(strcpy(buffer, bias_names[atomic_read(&usu_bias)]));
 257 }
 258
 259 module_init(usb_usual_init);
 260 module_exit(usb_usual_exit);
 261
 262 module_param_call(bias, usu_set_bias, usu_get_bias, NULL, S_IRUGO|S_IWUSR);
 263 __MODULE_PARM_TYPE(bias, "string");
 264 MODULE_PARM_DESC(bias, "Bias to usb-storage or ub");
 265
 266 MODULE_LICENSE("GPL");