tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
18struct mod_status {
19 unsigned long fls;
20};
21
22static struct mod_status stat[3];
23static DEFINE_SPINLOCK(usu_lock);
24
25/*
26 */
27#define USB_US_DEFAULT_BIAS USB_US_TYPE_STOR
28static atomic_t usu_bias = ATOMIC_INIT(USB_US_DEFAULT_BIAS);
29
30#define BIAS_NAME_SIZE (sizeof("usb-storage"))
31static const char *bias_names[3] = { "none", "usb-storage", "ub" };
32
33static struct semaphore usu_init_notify;
34static DECLARE_COMPLETION(usu_end_notify);
35static atomic_t total_threads = ATOMIC_INIT(0);
36
37static 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
52struct 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
60MODULE_DEVICE_TABLE(usb, storage_usb_ids);
61EXPORT_SYMBOL_GPL(storage_usb_ids);
62
63/*
64 * @type: the module type as an integer
65 */
66void 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}
78EXPORT_SYMBOL_GPL(usb_usual_set_present);
79
80void 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}
92EXPORT_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 */
98int 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}
113EXPORT_SYMBOL_GPL(usb_usual_check_type);
114
115/*
116 */
117static 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
153static void usu_disconnect(struct usb_interface *intf)
154{
155 ; /* We should not be here. */
156}
157
158static 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 */
174static 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 */
203static int __init usb_usual_init(void)
204{
205 int rc;
206
207 sema_init(&usu_init_notify, 0);
208
209 rc = usb_register(&usu_driver);
210 up(&usu_init_notify);
211 return rc;
212}
213
214static void __exit usb_usual_exit(void)
215{
216 /*
217 * We do not check for any drivers present, because
218 * they keep us pinned with symbol references.
219 */
220
221 usb_deregister(&usu_driver);
222
223 while (atomic_read(&total_threads) > 0) {
224 wait_for_completion(&usu_end_notify);
225 atomic_dec(&total_threads);
226 }
227}
228
229/*
230 * Validate and accept the bias parameter.
231 */
232static int usu_set_bias(const char *bias_s, struct kernel_param *kp)
233{
234 int i;
235 int len;
236 int bias_n = 0;
237
238 len = strlen(bias_s);
239 if (len == 0)
240 return -EDOM;
241 if (bias_s[len-1] == '\n')
242 --len;
243
244 for (i = 1; i < 3; i++) {
245 if (strncmp(bias_s, bias_names[i], len) == 0) {
246 bias_n = i;
247 break;
248 }
249 }
250 if (bias_n == 0)
251 return -EINVAL;
252
253 atomic_set(&usu_bias, bias_n);
254 return 0;
255}
256
257static int usu_get_bias(char *buffer, struct kernel_param *kp)
258{
259 return strlen(strcpy(buffer, bias_names[atomic_read(&usu_bias)]));
260}
261
262module_init(usb_usual_init);
263module_exit(usb_usual_exit);
264
265module_param_call(bias, usu_set_bias, usu_get_bias, NULL, S_IRUGO|S_IWUSR);
266__MODULE_PARM_TYPE(bias, "string");
267MODULE_PARM_DESC(bias, "Bias to usb-storage or ub");
268
269MODULE_LICENSE("GPL");