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