4 * The libusual contains the table of devices common for ub and usb-storage.
6 #include <linux/kernel.h>
7 #include <linux/module.h>
9 #include <linux/usb_usual.h>
10 #include <linux/vmalloc.h>
11 #include <linux/kthread.h>
15 #define USU_MOD_FL_THREAD 1 /* Thread is running */
16 #define USU_MOD_FL_PRESENT 2 /* The module is loaded */
22 static struct mod_status stat
[3];
23 static DEFINE_SPINLOCK(usu_lock
);
27 #define USB_US_DEFAULT_BIAS USB_US_TYPE_STOR
28 static atomic_t usu_bias
= ATOMIC_INIT(USB_US_DEFAULT_BIAS
);
30 #define BIAS_NAME_SIZE (sizeof("usb-storage"))
31 static const char *bias_names
[3] = { "none", "usb-storage", "ub" };
33 static DECLARE_MUTEX_LOCKED(usu_init_notify
);
34 static DECLARE_COMPLETION(usu_end_notify
);
35 static atomic_t total_threads
= ATOMIC_INIT(0);
37 static int usu_probe_thread(void *arg
);
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) }
48 #define USUAL_DEV(useProto, useTrans, useType) \
49 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
50 .driver_info = ((useType)<<24) }
52 struct usb_device_id storage_usb_ids
[] = {
53 # include "unusual_devs.h"
54 { } /* Terminating entry */
60 MODULE_DEVICE_TABLE(usb
, storage_usb_ids
);
61 EXPORT_SYMBOL_GPL(storage_usb_ids
);
64 * @type: the module type as an integer
66 void usb_usual_set_present(int type
)
68 struct mod_status
*st
;
71 if (type
<= 0 || type
>= 3)
74 spin_lock_irqsave(&usu_lock
, flags
);
75 st
->fls
|= USU_MOD_FL_PRESENT
;
76 spin_unlock_irqrestore(&usu_lock
, flags
);
78 EXPORT_SYMBOL_GPL(usb_usual_set_present
);
80 void usb_usual_clear_present(int type
)
82 struct mod_status
*st
;
85 if (type
<= 0 || type
>= 3)
88 spin_lock_irqsave(&usu_lock
, flags
);
89 st
->fls
&= ~USU_MOD_FL_PRESENT
;
90 spin_unlock_irqrestore(&usu_lock
, flags
);
92 EXPORT_SYMBOL_GPL(usb_usual_clear_present
);
95 * Match the calling driver type against the table.
96 * Returns: 0 if the device matches.
98 int usb_usual_check_type(const struct usb_device_id
*id
, int caller_type
)
100 int id_type
= USB_US_TYPE(id
->driver_info
);
102 if (caller_type
<= 0 || caller_type
>= 3)
105 /* Drivers grab fixed assignment devices */
106 if (id_type
== caller_type
)
108 /* Drivers grab devices biased to them */
109 if (id_type
== USB_US_TYPE_NONE
&& caller_type
== atomic_read(&usu_bias
))
113 EXPORT_SYMBOL_GPL(usb_usual_check_type
);
117 static int usu_probe(struct usb_interface
*intf
,
118 const struct usb_device_id
*id
)
121 struct task_struct
* task
;
124 type
= USB_US_TYPE(id
->driver_info
);
126 type
= atomic_read(&usu_bias
);
128 spin_lock_irqsave(&usu_lock
, flags
);
129 if ((stat
[type
].fls
& (USU_MOD_FL_THREAD
|USU_MOD_FL_PRESENT
)) != 0) {
130 spin_unlock_irqrestore(&usu_lock
, flags
);
133 stat
[type
].fls
|= USU_MOD_FL_THREAD
;
134 spin_unlock_irqrestore(&usu_lock
, flags
);
136 task
= kthread_run(usu_probe_thread
, (void*)type
, "libusual_%d", type
);
138 int rc
= PTR_ERR(task
);
139 printk(KERN_WARNING
"libusual: "
140 "Unable to start the thread for %s: %d\n",
141 bias_names
[type
], rc
);
142 spin_lock_irqsave(&usu_lock
, flags
);
143 stat
[type
].fls
&= ~USU_MOD_FL_THREAD
;
144 spin_unlock_irqrestore(&usu_lock
, flags
);
145 return rc
; /* Not being -ENXIO causes a message printed */
147 atomic_inc(&total_threads
);
152 static void usu_disconnect(struct usb_interface
*intf
)
154 ; /* We should not be here. */
157 static struct usb_driver usu_driver
= {
160 .disconnect
= usu_disconnect
,
161 .id_table
= storage_usb_ids
,
165 * A whole new thread for a purpose of request_module seems quite stupid.
166 * The request_module forks once inside again. However, if we attempt
167 * to load a storage module from our own modprobe thread, that module
168 * references our symbols, which cannot be resolved until our module is
169 * initialized. I wish there was a way to wait for the end of initialization.
170 * The module notifier reports MODULE_STATE_COMING only.
171 * So, we wait until module->init ends as the next best thing.
173 static int usu_probe_thread(void *arg
)
175 int type
= (unsigned long) arg
;
176 struct mod_status
*st
= &stat
[type
];
180 /* A completion does not work here because it's counted. */
181 down(&usu_init_notify
);
182 up(&usu_init_notify
);
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) {
188 * This should not happen, but let us keep tabs on it.
190 printk(KERN_NOTICE
"libusual: "
191 "modprobe for %s succeeded, but module is not present\n",
194 st
->fls
&= ~USU_MOD_FL_THREAD
;
195 spin_unlock_irqrestore(&usu_lock
, flags
);
197 complete_and_exit(&usu_end_notify
, 0);
202 static int __init
usb_usual_init(void)
206 rc
= usb_register(&usu_driver
);
207 up(&usu_init_notify
);
211 static void __exit
usb_usual_exit(void)
214 * We do not check for any drivers present, because
215 * they keep us pinned with symbol references.
218 usb_deregister(&usu_driver
);
220 while (atomic_read(&total_threads
) > 0) {
221 wait_for_completion(&usu_end_notify
);
222 atomic_dec(&total_threads
);
227 * Validate and accept the bias parameter.
229 static int usu_set_bias(const char *bias_s
, struct kernel_param
*kp
)
235 len
= strlen(bias_s
);
238 if (bias_s
[len
-1] == '\n')
241 for (i
= 1; i
< 3; i
++) {
242 if (strncmp(bias_s
, bias_names
[i
], len
) == 0) {
250 atomic_set(&usu_bias
, bias_n
);
254 static int usu_get_bias(char *buffer
, struct kernel_param
*kp
)
256 return strlen(strcpy(buffer
, bias_names
[atomic_read(&usu_bias
)]));
259 module_init(usb_usual_init
);
260 module_exit(usb_usual_exit
);
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");
266 MODULE_LICENSE("GPL");