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