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