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