1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#include <linux/module.h>
32#include <linux/kernel.h>
33#include <linux/signal.h>
34#include <linux/sched.h>
35#include <linux/errno.h>
36#include <linux/random.h>
37#include <linux/poll.h>
38#include <linux/init.h>
39#include <linux/slab.h>
40#include <linux/spinlock.h>
41#include <linux/usb.h>
42#include <linux/wait.h>
43
44#include "rio500_usb.h"
45
46
47
48
49#define DRIVER_VERSION "v1.1"
50#define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
51#define DRIVER_DESC "USB Rio 500 driver"
52
53#define RIO_MINOR 64
54
55
56#define NAK_TIMEOUT (HZ)
57
58#define IBUF_SIZE 0x1000
59
60
61#define OBUF_SIZE 0x10000
62
63struct rio_usb_data {
64 struct usb_device *rio_dev;
65 unsigned int ifnum;
66 int isopen;
67 int present;
68 char *obuf, *ibuf;
69 char bulk_in_ep, bulk_out_ep;
70 wait_queue_head_t wait_q;
71 struct mutex lock;
72};
73
74static struct rio_usb_data rio_instance;
75
76static int open_rio(struct inode *inode, struct file *file)
77{
78 struct rio_usb_data *rio = &rio_instance;
79
80 mutex_lock(&(rio->lock));
81
82 if (rio->isopen || !rio->present) {
83 mutex_unlock(&(rio->lock));
84 return -EBUSY;
85 }
86 rio->isopen = 1;
87
88 init_waitqueue_head(&rio->wait_q);
89
90 mutex_unlock(&(rio->lock));
91
92 info("Rio opened.");
93
94 return 0;
95}
96
97static int close_rio(struct inode *inode, struct file *file)
98{
99 struct rio_usb_data *rio = &rio_instance;
100
101 rio->isopen = 0;
102
103 info("Rio closed.");
104 return 0;
105}
106
107static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
108{
109 struct RioCommand rio_cmd;
110 struct rio_usb_data *rio = &rio_instance;
111 void __user *data;
112 unsigned char *buffer;
113 int result, requesttype;
114 int retries;
115 int retval=0;
116
117 lock_kernel();
118 mutex_lock(&(rio->lock));
119
120 if (rio->present == 0 || rio->rio_dev == NULL) {
121 retval = -ENODEV;
122 goto err_out;
123 }
124
125 switch (cmd) {
126 case RIO_RECV_COMMAND:
127 data = (void __user *) arg;
128 if (data == NULL)
129 break;
130 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
131 retval = -EFAULT;
132 goto err_out;
133 }
134 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
135 retval = -EINVAL;
136 goto err_out;
137 }
138 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
139 if (buffer == NULL) {
140 retval = -ENOMEM;
141 goto err_out;
142 }
143 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
144 retval = -EFAULT;
145 free_page((unsigned long) buffer);
146 goto err_out;
147 }
148
149 requesttype = rio_cmd.requesttype | USB_DIR_IN |
150 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
151 dbg
152 ("sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
153 requesttype, rio_cmd.request, rio_cmd.value,
154 rio_cmd.index, rio_cmd.length);
155
156 retries = 3;
157 while (retries) {
158 result = usb_control_msg(rio->rio_dev,
159 usb_rcvctrlpipe(rio-> rio_dev, 0),
160 rio_cmd.request,
161 requesttype,
162 rio_cmd.value,
163 rio_cmd.index, buffer,
164 rio_cmd.length,
165 jiffies_to_msecs(rio_cmd.timeout));
166 if (result == -ETIMEDOUT)
167 retries--;
168 else if (result < 0) {
169 err("Error executing ioctrl. code = %d", result);
170 retries = 0;
171 } else {
172 dbg("Executed ioctl. Result = %d (data=%02x)",
173 result, buffer[0]);
174 if (copy_to_user(rio_cmd.buffer, buffer,
175 rio_cmd.length)) {
176 free_page((unsigned long) buffer);
177 retval = -EFAULT;
178 goto err_out;
179 }
180 retries = 0;
181 }
182
183
184
185
186
187
188
189
190 }
191 free_page((unsigned long) buffer);
192 break;
193
194 case RIO_SEND_COMMAND:
195 data = (void __user *) arg;
196 if (data == NULL)
197 break;
198 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
199 retval = -EFAULT;
200 goto err_out;
201 }
202 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
203 retval = -EINVAL;
204 goto err_out;
205 }
206 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
207 if (buffer == NULL) {
208 retval = -ENOMEM;
209 goto err_out;
210 }
211 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
212 free_page((unsigned long)buffer);
213 retval = -EFAULT;
214 goto err_out;
215 }
216
217 requesttype = rio_cmd.requesttype | USB_DIR_OUT |
218 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
219 dbg("sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
220 requesttype, rio_cmd.request, rio_cmd.value,
221 rio_cmd.index, rio_cmd.length);
222
223 retries = 3;
224 while (retries) {
225 result = usb_control_msg(rio->rio_dev,
226 usb_sndctrlpipe(rio-> rio_dev, 0),
227 rio_cmd.request,
228 requesttype,
229 rio_cmd.value,
230 rio_cmd.index, buffer,
231 rio_cmd.length,
232 jiffies_to_msecs(rio_cmd.timeout));
233 if (result == -ETIMEDOUT)
234 retries--;
235 else if (result < 0) {
236 err("Error executing ioctrl. code = %d", result);
237 retries = 0;
238 } else {
239 dbg("Executed ioctl. Result = %d", result);
240 retries = 0;
241
242 }
243
244 }
245 free_page((unsigned long) buffer);
246 break;
247
248 default:
249 retval = -ENOTTY;
250 break;
251 }
252
253
254err_out:
255 mutex_unlock(&(rio->lock));
256 unlock_kernel();
257 return retval;
258}
259
260static ssize_t
261write_rio(struct file *file, const char __user *buffer,
262 size_t count, loff_t * ppos)
263{
264 DEFINE_WAIT(wait);
265 struct rio_usb_data *rio = &rio_instance;
266
267 unsigned long copy_size;
268 unsigned long bytes_written = 0;
269 unsigned int partial;
270
271 int result = 0;
272 int maxretry;
273 int errn = 0;
274 int intr;
275
276 intr = mutex_lock_interruptible(&(rio->lock));
277 if (intr)
278 return -EINTR;
279
280 if (rio->present == 0 || rio->rio_dev == NULL) {
281 mutex_unlock(&(rio->lock));
282 return -ENODEV;
283 }
284
285
286
287 do {
288 unsigned long thistime;
289 char *obuf = rio->obuf;
290
291 thistime = copy_size =
292 (count >= OBUF_SIZE) ? OBUF_SIZE : count;
293 if (copy_from_user(rio->obuf, buffer, copy_size)) {
294 errn = -EFAULT;
295 goto error;
296 }
297 maxretry = 5;
298 while (thistime) {
299 if (!rio->rio_dev) {
300 errn = -ENODEV;
301 goto error;
302 }
303 if (signal_pending(current)) {
304 mutex_unlock(&(rio->lock));
305 return bytes_written ? bytes_written : -EINTR;
306 }
307
308 result = usb_bulk_msg(rio->rio_dev,
309 usb_sndbulkpipe(rio->rio_dev, 2),
310 obuf, thistime, &partial, 5000);
311
312 dbg("write stats: result:%d thistime:%lu partial:%u",
313 result, thistime, partial);
314
315 if (result == -ETIMEDOUT) {
316 if (!maxretry--) {
317 errn = -ETIME;
318 goto error;
319 }
320 prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
321 schedule_timeout(NAK_TIMEOUT);
322 finish_wait(&rio->wait_q, &wait);
323 continue;
324 } else if (!result && partial) {
325 obuf += partial;
326 thistime -= partial;
327 } else
328 break;
329 };
330 if (result) {
331 err("Write Whoops - %x", result);
332 errn = -EIO;
333 goto error;
334 }
335 bytes_written += copy_size;
336 count -= copy_size;
337 buffer += copy_size;
338 } while (count > 0);
339
340 mutex_unlock(&(rio->lock));
341
342 return bytes_written ? bytes_written : -EIO;
343
344error:
345 mutex_unlock(&(rio->lock));
346 return errn;
347}
348
349static ssize_t
350read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
351{
352 DEFINE_WAIT(wait);
353 struct rio_usb_data *rio = &rio_instance;
354 ssize_t read_count;
355 unsigned int partial;
356 int this_read;
357 int result;
358 int maxretry = 10;
359 char *ibuf;
360 int intr;
361
362 intr = mutex_lock_interruptible(&(rio->lock));
363 if (intr)
364 return -EINTR;
365
366 if (rio->present == 0 || rio->rio_dev == NULL) {
367 mutex_unlock(&(rio->lock));
368 return -ENODEV;
369 }
370
371 ibuf = rio->ibuf;
372
373 read_count = 0;
374
375
376 while (count > 0) {
377 if (signal_pending(current)) {
378 mutex_unlock(&(rio->lock));
379 return read_count ? read_count : -EINTR;
380 }
381 if (!rio->rio_dev) {
382 mutex_unlock(&(rio->lock));
383 return -ENODEV;
384 }
385 this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
386
387 result = usb_bulk_msg(rio->rio_dev,
388 usb_rcvbulkpipe(rio->rio_dev, 1),
389 ibuf, this_read, &partial,
390 8000);
391
392 dbg("read stats: result:%d this_read:%u partial:%u",
393 result, this_read, partial);
394
395 if (partial) {
396 count = this_read = partial;
397 } else if (result == -ETIMEDOUT || result == 15) {
398 if (!maxretry--) {
399 mutex_unlock(&(rio->lock));
400 err("read_rio: maxretry timeout");
401 return -ETIME;
402 }
403 prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
404 schedule_timeout(NAK_TIMEOUT);
405 finish_wait(&rio->wait_q, &wait);
406 continue;
407 } else if (result != -EREMOTEIO) {
408 mutex_unlock(&(rio->lock));
409 err("Read Whoops - result:%u partial:%u this_read:%u",
410 result, partial, this_read);
411 return -EIO;
412 } else {
413 mutex_unlock(&(rio->lock));
414 return (0);
415 }
416
417 if (this_read) {
418 if (copy_to_user(buffer, ibuf, this_read)) {
419 mutex_unlock(&(rio->lock));
420 return -EFAULT;
421 }
422 count -= this_read;
423 read_count += this_read;
424 buffer += this_read;
425 }
426 }
427 mutex_unlock(&(rio->lock));
428 return read_count;
429}
430
431static struct
432file_operations usb_rio_fops = {
433 .owner = THIS_MODULE,
434 .read = read_rio,
435 .write = write_rio,
436 .unlocked_ioctl = ioctl_rio,
437 .open = open_rio,
438 .release = close_rio,
439};
440
441static struct usb_class_driver usb_rio_class = {
442 .name = "rio500%d",
443 .fops = &usb_rio_fops,
444 .minor_base = RIO_MINOR,
445};
446
447static int probe_rio(struct usb_interface *intf,
448 const struct usb_device_id *id)
449{
450 struct usb_device *dev = interface_to_usbdev(intf);
451 struct rio_usb_data *rio = &rio_instance;
452 int retval;
453
454 info("USB Rio found at address %d", dev->devnum);
455
456 retval = usb_register_dev(intf, &usb_rio_class);
457 if (retval) {
458 err("Not able to get a minor for this device.");
459 return -ENOMEM;
460 }
461
462 rio->rio_dev = dev;
463
464 if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
465 err("probe_rio: Not enough memory for the output buffer");
466 usb_deregister_dev(intf, &usb_rio_class);
467 return -ENOMEM;
468 }
469 dbg("probe_rio: obuf address:%p", rio->obuf);
470
471 if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
472 err("probe_rio: Not enough memory for the input buffer");
473 usb_deregister_dev(intf, &usb_rio_class);
474 kfree(rio->obuf);
475 return -ENOMEM;
476 }
477 dbg("probe_rio: ibuf address:%p", rio->ibuf);
478
479 mutex_init(&(rio->lock));
480
481 usb_set_intfdata (intf, rio);
482 rio->present = 1;
483
484 return 0;
485}
486
487static void disconnect_rio(struct usb_interface *intf)
488{
489 struct rio_usb_data *rio = usb_get_intfdata (intf);
490
491 usb_set_intfdata (intf, NULL);
492 if (rio) {
493 usb_deregister_dev(intf, &usb_rio_class);
494
495 mutex_lock(&(rio->lock));
496 if (rio->isopen) {
497 rio->isopen = 0;
498
499 rio->rio_dev = NULL;
500 mutex_unlock(&(rio->lock));
501 return;
502 }
503 kfree(rio->ibuf);
504 kfree(rio->obuf);
505
506 info("USB Rio disconnected.");
507
508 rio->present = 0;
509 mutex_unlock(&(rio->lock));
510 }
511}
512
513static struct usb_device_id rio_table [] = {
514 { USB_DEVICE(0x0841, 1) },
515 { }
516};
517
518MODULE_DEVICE_TABLE (usb, rio_table);
519
520static struct usb_driver rio_driver = {
521 .name = "rio500",
522 .probe = probe_rio,
523 .disconnect = disconnect_rio,
524 .id_table = rio_table,
525};
526
527static int __init usb_rio_init(void)
528{
529 int retval;
530 retval = usb_register(&rio_driver);
531 if (retval)
532 goto out;
533
534 info(DRIVER_VERSION ":" DRIVER_DESC);
535
536out:
537 return retval;
538}
539
540
541static void __exit usb_rio_cleanup(void)
542{
543 struct rio_usb_data *rio = &rio_instance;
544
545 rio->present = 0;
546 usb_deregister(&rio_driver);
547
548
549}
550
551module_init(usb_rio_init);
552module_exit(usb_rio_cleanup);
553
554MODULE_AUTHOR( DRIVER_AUTHOR );
555MODULE_DESCRIPTION( DRIVER_DESC );
556MODULE_LICENSE("GPL");
557
558
