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