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/smp_lock.h>
36#include <linux/errno.h>
37#include <linux/random.h>
38#include <linux/poll.h>
39#include <linux/init.h>
40#include <linux/slab.h>
41#include <linux/spinlock.h>
42#include <linux/usb.h>
43#include <linux/wait.h>
44
45#include "rio500_usb.h"
46
47
48
49
50#define DRIVER_VERSION "v1.1"
51#define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
52#define DRIVER_DESC "USB Rio 500 driver"
53
54#define RIO_MINOR 64
55
56
57#define NAK_TIMEOUT (HZ)
58
59#define IBUF_SIZE 0x1000
60
61
62#define OBUF_SIZE 0x10000
63
64struct rio_usb_data {
65 struct usb_device *rio_dev;
66 unsigned int ifnum;
67 int isopen;
68 int present;
69 char *obuf, *ibuf;
70 char bulk_in_ep, bulk_out_ep;
71 wait_queue_head_t wait_q;
72 struct mutex lock;
73};
74
75static struct rio_usb_data rio_instance;
76
77static int open_rio(struct inode *inode, struct file *file)
78{
79 struct rio_usb_data *rio = &rio_instance;
80
81 mutex_lock(&(rio->lock));
82
83 if (rio->isopen || !rio->present) {
84 mutex_unlock(&(rio->lock));
85 return -EBUSY;
86 }
87 rio->isopen = 1;
88
89 init_waitqueue_head(&rio->wait_q);
90
91 mutex_unlock(&(rio->lock));
92
93 dev_info(&rio->rio_dev->dev, "Rio opened.\n");
94
95 return 0;
96}
97
98static int close_rio(struct inode *inode, struct file *file)
99{
100 struct rio_usb_data *rio = &rio_instance;
101
102 rio->isopen = 0;
103
104 dev_info(&rio->rio_dev->dev, "Rio closed.\n");
105 return 0;
106}
107
108static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
109{
110 struct RioCommand rio_cmd;
111 struct rio_usb_data *rio = &rio_instance;
112 void __user *data;
113 unsigned char *buffer;
114 int result, requesttype;
115 int retries;
116 int retval=0;
117
118 lock_kernel();
119 mutex_lock(&(rio->lock));
120
121 if (rio->present == 0 || rio->rio_dev == NULL) {
122 retval = -ENODEV;
123 goto err_out;
124 }
125
126 switch (cmd) {
127 case RIO_RECV_COMMAND:
128 data = (void __user *) arg;
129 if (data == NULL)
130 break;
131 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
132 retval = -EFAULT;
133 goto err_out;
134 }
135 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
136 retval = -EINVAL;
137 goto err_out;
138 }
139 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
140 if (buffer == NULL) {
141 retval = -ENOMEM;
142 goto err_out;
143 }
144 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
145 retval = -EFAULT;
146 free_page((unsigned long) buffer);
147 goto err_out;
148 }
149
150 requesttype = rio_cmd.requesttype | USB_DIR_IN |
151 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
152 dbg
153 ("sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
154 requesttype, rio_cmd.request, rio_cmd.value,
155 rio_cmd.index, rio_cmd.length);
156
157 retries = 3;
158 while (retries) {
159 result = usb_control_msg(rio->rio_dev,
160 usb_rcvctrlpipe(rio-> rio_dev, 0),
161 rio_cmd.request,
162 requesttype,
163 rio_cmd.value,
164 rio_cmd.index, buffer,
165 rio_cmd.length,
166 jiffies_to_msecs(rio_cmd.timeout));
167 if (result == -ETIMEDOUT)
168 retries--;
169 else if (result < 0) {
170 err("Error executing ioctrl. code = %d", result);
171 retries = 0;
172 } else {
173 dbg("Executed ioctl. Result = %d (data=%02x)",
174 result, buffer[0]);
175 if (copy_to_user(rio_cmd.buffer, buffer,
176 rio_cmd.length)) {
177 free_page((unsigned long) buffer);
178 retval = -EFAULT;
179 goto err_out;
180 }
181 retries = 0;
182 }
183
184
185
186
187
188
189
190
191 }
192 free_page((unsigned long) buffer);
193 break;
194
195 case RIO_SEND_COMMAND:
196 data = (void __user *) arg;
197 if (data == NULL)
198 break;
199 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
200 retval = -EFAULT;
201 goto err_out;
202 }
203 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
204 retval = -EINVAL;
205 goto err_out;
206 }
207 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
208 if (buffer == NULL) {
209 retval = -ENOMEM;
210 goto err_out;
211 }
212 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
213 free_page((unsigned long)buffer);
214 retval = -EFAULT;
215 goto err_out;
216 }
217
218 requesttype = rio_cmd.requesttype | USB_DIR_OUT |
219 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
220 dbg("sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
221 requesttype, rio_cmd.request, rio_cmd.value,
222 rio_cmd.index, rio_cmd.length);
223
224 retries = 3;
225 while (retries) {
226 result = usb_control_msg(rio->rio_dev,
227 usb_sndctrlpipe(rio-> rio_dev, 0),
228 rio_cmd.request,
229 requesttype,
230 rio_cmd.value,
231 rio_cmd.index, buffer,
232 rio_cmd.length,
233 jiffies_to_msecs(rio_cmd.timeout));
234 if (result == -ETIMEDOUT)
235 retries--;
236 else if (result < 0) {
237 err("Error executing ioctrl. code = %d", result);
238 retries = 0;
239 } else {
240 dbg("Executed ioctl. Result = %d", result);
241 retries = 0;
242
243 }
244
245 }
246 free_page((unsigned long) buffer);
247 break;
248
249 default:
250 retval = -ENOTTY;
251 break;
252 }
253
254
255err_out:
256 mutex_unlock(&(rio->lock));
257 unlock_kernel();
258 return retval;
259}
260
261static ssize_t
262write_rio(struct file *file, const char __user *buffer,
263 size_t count, loff_t * ppos)
264{
265 DEFINE_WAIT(wait);
266 struct rio_usb_data *rio = &rio_instance;
267
268 unsigned long copy_size;
269 unsigned long bytes_written = 0;
270 unsigned int partial;
271
272 int result = 0;
273 int maxretry;
274 int errn = 0;
275 int intr;
276
277 intr = mutex_lock_interruptible(&(rio->lock));
278 if (intr)
279 return -EINTR;
280
281 if (rio->present == 0 || rio->rio_dev == NULL) {
282 mutex_unlock(&(rio->lock));
283 return -ENODEV;
284 }
285
286
287
288 do {
289 unsigned long thistime;
290 char *obuf = rio->obuf;
291
292 thistime = copy_size =
293 (count >= OBUF_SIZE) ? OBUF_SIZE : count;
294 if (copy_from_user(rio->obuf, buffer, copy_size)) {
295 errn = -EFAULT;
296 goto error;
297 }
298 maxretry = 5;
299 while (thistime) {
300 if (!rio->rio_dev) {
301 errn = -ENODEV;
302 goto error;
303 }
304 if (signal_pending(current)) {
305 mutex_unlock(&(rio->lock));
306 return bytes_written ? bytes_written : -EINTR;
307 }
308
309 result = usb_bulk_msg(rio->rio_dev,
310 usb_sndbulkpipe(rio->rio_dev, 2),
311 obuf, thistime, &partial, 5000);
312
313 dbg("write stats: result:%d thistime:%lu partial:%u",
314 result, thistime, partial);
315
316 if (result == -ETIMEDOUT) {
317 if (!maxretry--) {
318 errn = -ETIME;
319 goto error;
320 }
321 prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
322 schedule_timeout(NAK_TIMEOUT);
323 finish_wait(&rio->wait_q, &wait);
324 continue;
325 } else if (!result && partial) {
326 obuf += partial;
327 thistime -= partial;
328 } else
329 break;
330 };
331 if (result) {
332 err("Write Whoops - %x", result);
333 errn = -EIO;
334 goto error;
335 }
336 bytes_written += copy_size;
337 count -= copy_size;
338 buffer += copy_size;
339 } while (count > 0);
340
341 mutex_unlock(&(rio->lock));
342
343 return bytes_written ? bytes_written : -EIO;
344
345error:
346 mutex_unlock(&(rio->lock));
347 return errn;
348}
349
350static ssize_t
351read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
352{
353 DEFINE_WAIT(wait);
354 struct rio_usb_data *rio = &rio_instance;
355 ssize_t read_count;
356 unsigned int partial;
357 int this_read;
358 int result;
359 int maxretry = 10;
360 char *ibuf;
361 int intr;
362
363 intr = mutex_lock_interruptible(&(rio->lock));
364 if (intr)
365 return -EINTR;
366
367 if (rio->present == 0 || rio->rio_dev == NULL) {
368 mutex_unlock(&(rio->lock));
369 return -ENODEV;
370 }
371
372 ibuf = rio->ibuf;
373
374 read_count = 0;
375
376
377 while (count > 0) {
378 if (signal_pending(current)) {
379 mutex_unlock(&(rio->lock));
380 return read_count ? read_count : -EINTR;
381 }
382 if (!rio->rio_dev) {
383 mutex_unlock(&(rio->lock));
384 return -ENODEV;
385 }
386 this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
387
388 result = usb_bulk_msg(rio->rio_dev,
389 usb_rcvbulkpipe(rio->rio_dev, 1),
390 ibuf, this_read, &partial,
391 8000);
392
393 dbg("read stats: result:%d this_read:%u partial:%u",
394 result, this_read, partial);
395
396 if (partial) {
397 count = this_read = partial;
398 } else if (result == -ETIMEDOUT || result == 15) {
399 if (!maxretry--) {
400 mutex_unlock(&(rio->lock));
401 err("read_rio: maxretry timeout");
402 return -ETIME;
403 }
404 prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
405 schedule_timeout(NAK_TIMEOUT);
406 finish_wait(&rio->wait_q, &wait);
407 continue;
408 } else if (result != -EREMOTEIO) {
409 mutex_unlock(&(rio->lock));
410 err("Read Whoops - result:%u partial:%u this_read:%u",
411 result, partial, this_read);
412 return -EIO;
413 } else {
414 mutex_unlock(&(rio->lock));
415 return (0);
416 }
417
418 if (this_read) {
419 if (copy_to_user(buffer, ibuf, this_read)) {
420 mutex_unlock(&(rio->lock));
421 return -EFAULT;
422 }
423 count -= this_read;
424 read_count += this_read;
425 buffer += this_read;
426 }
427 }
428 mutex_unlock(&(rio->lock));
429 return read_count;
430}
431
432static const struct file_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 dev_info(&intf->dev, "USB Rio found at address %d\n", 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 dev_info(&intf->dev, "USB Rio disconnected.\n");
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 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
535 DRIVER_DESC "\n");
536
537out:
538 return retval;
539}
540
541
542static void __exit usb_rio_cleanup(void)
543{
544 struct rio_usb_data *rio = &rio_instance;
545
546 rio->present = 0;
547 usb_deregister(&rio_driver);
548
549
550}
551
552module_init(usb_rio_init);
553module_exit(usb_rio_cleanup);
554
555MODULE_AUTHOR( DRIVER_AUTHOR );
556MODULE_DESCRIPTION( DRIVER_DESC );
557MODULE_LICENSE("GPL");
558
559
