Loading...
1/* -*- linux-c -*- */
2
3/*
4 * Driver for USB Rio 500
5 *
6 * Cesar Miquel (miquel@df.uba.ar)
7 *
8 * based on hp_scanner.c by David E. Nelson (dnelson@jump.net)
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of the
13 * License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *
24 * Based upon mouse.c (Brad Keryan) and printer.c (Michael Gee).
25 *
26 * Changelog:
27 * 30/05/2003 replaced lock/unlock kernel with up/down
28 * Daniele Bellucci bellucda@tiscali.it
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/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 * Version Information
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/* stall/wait timeout for rio */
56#define NAK_TIMEOUT (HZ)
57
58#define IBUF_SIZE 0x1000
59
60/* Size of the rio buffer */
61#define OBUF_SIZE 0x10000
62
63struct rio_usb_data {
64 struct usb_device *rio_dev; /* init: probe_rio */
65 unsigned int ifnum; /* Interface number of the USB device */
66 int isopen; /* nz if open */
67 int present; /* Device is present on the bus */
68 char *obuf, *ibuf; /* transfer buffers */
69 char bulk_in_ep, bulk_out_ep; /* Endpoint assignments */
70 wait_queue_head_t wait_q; /* for timeouts */
71 struct mutex lock; /* general race avoidance */
72};
73
74static DEFINE_MUTEX(rio500_mutex);
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 /* against disconnect() */
82 mutex_lock(&rio500_mutex);
83 mutex_lock(&(rio->lock));
84
85 if (rio->isopen || !rio->present) {
86 mutex_unlock(&(rio->lock));
87 mutex_unlock(&rio500_mutex);
88 return -EBUSY;
89 }
90 rio->isopen = 1;
91
92 init_waitqueue_head(&rio->wait_q);
93
94 mutex_unlock(&(rio->lock));
95
96 dev_info(&rio->rio_dev->dev, "Rio opened.\n");
97 mutex_unlock(&rio500_mutex);
98
99 return 0;
100}
101
102static int close_rio(struct inode *inode, struct file *file)
103{
104 struct rio_usb_data *rio = &rio_instance;
105
106 rio->isopen = 0;
107
108 dev_info(&rio->rio_dev->dev, "Rio closed.\n");
109 return 0;
110}
111
112static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
113{
114 struct RioCommand rio_cmd;
115 struct rio_usb_data *rio = &rio_instance;
116 void __user *data;
117 unsigned char *buffer;
118 int result, requesttype;
119 int retries;
120 int retval=0;
121
122 mutex_lock(&(rio->lock));
123 /* Sanity check to make sure rio is connected, powered, etc */
124 if (rio->present == 0 || rio->rio_dev == NULL) {
125 retval = -ENODEV;
126 goto err_out;
127 }
128
129 switch (cmd) {
130 case RIO_RECV_COMMAND:
131 data = (void __user *) arg;
132 if (data == NULL)
133 break;
134 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
135 retval = -EFAULT;
136 goto err_out;
137 }
138 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
139 retval = -EINVAL;
140 goto err_out;
141 }
142 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
143 if (buffer == NULL) {
144 retval = -ENOMEM;
145 goto err_out;
146 }
147 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
148 retval = -EFAULT;
149 free_page((unsigned long) buffer);
150 goto err_out;
151 }
152
153 requesttype = rio_cmd.requesttype | USB_DIR_IN |
154 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
155 dev_dbg(&rio->rio_dev->dev,
156 "sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
157 requesttype, rio_cmd.request, rio_cmd.value,
158 rio_cmd.index, rio_cmd.length);
159 /* Send rio control message */
160 retries = 3;
161 while (retries) {
162 result = usb_control_msg(rio->rio_dev,
163 usb_rcvctrlpipe(rio-> rio_dev, 0),
164 rio_cmd.request,
165 requesttype,
166 rio_cmd.value,
167 rio_cmd.index, buffer,
168 rio_cmd.length,
169 jiffies_to_msecs(rio_cmd.timeout));
170 if (result == -ETIMEDOUT)
171 retries--;
172 else if (result < 0) {
173 dev_err(&rio->rio_dev->dev,
174 "Error executing ioctrl. code = %d\n",
175 result);
176 retries = 0;
177 } else {
178 dev_dbg(&rio->rio_dev->dev,
179 "Executed ioctl. Result = %d (data=%02x)\n",
180 result, buffer[0]);
181 if (copy_to_user(rio_cmd.buffer, buffer,
182 rio_cmd.length)) {
183 free_page((unsigned long) buffer);
184 retval = -EFAULT;
185 goto err_out;
186 }
187 retries = 0;
188 }
189
190 /* rio_cmd.buffer contains a raw stream of single byte
191 data which has been returned from rio. Data is
192 interpreted at application level. For data that
193 will be cast to data types longer than 1 byte, data
194 will be little_endian and will potentially need to
195 be swapped at the app level */
196
197 }
198 free_page((unsigned long) buffer);
199 break;
200
201 case RIO_SEND_COMMAND:
202 data = (void __user *) arg;
203 if (data == NULL)
204 break;
205 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
206 retval = -EFAULT;
207 goto err_out;
208 }
209 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
210 retval = -EINVAL;
211 goto err_out;
212 }
213 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
214 if (buffer == NULL) {
215 retval = -ENOMEM;
216 goto err_out;
217 }
218 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
219 free_page((unsigned long)buffer);
220 retval = -EFAULT;
221 goto err_out;
222 }
223
224 requesttype = rio_cmd.requesttype | USB_DIR_OUT |
225 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
226 dev_dbg(&rio->rio_dev->dev,
227 "sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
228 requesttype, rio_cmd.request, rio_cmd.value,
229 rio_cmd.index, rio_cmd.length);
230 /* Send rio control message */
231 retries = 3;
232 while (retries) {
233 result = usb_control_msg(rio->rio_dev,
234 usb_sndctrlpipe(rio-> rio_dev, 0),
235 rio_cmd.request,
236 requesttype,
237 rio_cmd.value,
238 rio_cmd.index, buffer,
239 rio_cmd.length,
240 jiffies_to_msecs(rio_cmd.timeout));
241 if (result == -ETIMEDOUT)
242 retries--;
243 else if (result < 0) {
244 dev_err(&rio->rio_dev->dev,
245 "Error executing ioctrl. code = %d\n",
246 result);
247 retries = 0;
248 } else {
249 dev_dbg(&rio->rio_dev->dev,
250 "Executed ioctl. Result = %d\n", result);
251 retries = 0;
252
253 }
254
255 }
256 free_page((unsigned long) buffer);
257 break;
258
259 default:
260 retval = -ENOTTY;
261 break;
262 }
263
264
265err_out:
266 mutex_unlock(&(rio->lock));
267 return retval;
268}
269
270static ssize_t
271write_rio(struct file *file, const char __user *buffer,
272 size_t count, loff_t * ppos)
273{
274 DEFINE_WAIT(wait);
275 struct rio_usb_data *rio = &rio_instance;
276
277 unsigned long copy_size;
278 unsigned long bytes_written = 0;
279 unsigned int partial;
280
281 int result = 0;
282 int maxretry;
283 int errn = 0;
284 int intr;
285
286 intr = mutex_lock_interruptible(&(rio->lock));
287 if (intr)
288 return -EINTR;
289 /* Sanity check to make sure rio is connected, powered, etc */
290 if (rio->present == 0 || rio->rio_dev == NULL) {
291 mutex_unlock(&(rio->lock));
292 return -ENODEV;
293 }
294
295
296
297 do {
298 unsigned long thistime;
299 char *obuf = rio->obuf;
300
301 thistime = copy_size =
302 (count >= OBUF_SIZE) ? OBUF_SIZE : count;
303 if (copy_from_user(rio->obuf, buffer, copy_size)) {
304 errn = -EFAULT;
305 goto error;
306 }
307 maxretry = 5;
308 while (thistime) {
309 if (!rio->rio_dev) {
310 errn = -ENODEV;
311 goto error;
312 }
313 if (signal_pending(current)) {
314 mutex_unlock(&(rio->lock));
315 return bytes_written ? bytes_written : -EINTR;
316 }
317
318 result = usb_bulk_msg(rio->rio_dev,
319 usb_sndbulkpipe(rio->rio_dev, 2),
320 obuf, thistime, &partial, 5000);
321
322 dev_dbg(&rio->rio_dev->dev,
323 "write stats: result:%d thistime:%lu partial:%u\n",
324 result, thistime, partial);
325
326 if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
327 if (!maxretry--) {
328 errn = -ETIME;
329 goto error;
330 }
331 prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
332 schedule_timeout(NAK_TIMEOUT);
333 finish_wait(&rio->wait_q, &wait);
334 continue;
335 } else if (!result && partial) {
336 obuf += partial;
337 thistime -= partial;
338 } else
339 break;
340 }
341 if (result) {
342 dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
343 result);
344 errn = -EIO;
345 goto error;
346 }
347 bytes_written += copy_size;
348 count -= copy_size;
349 buffer += copy_size;
350 } while (count > 0);
351
352 mutex_unlock(&(rio->lock));
353
354 return bytes_written ? bytes_written : -EIO;
355
356error:
357 mutex_unlock(&(rio->lock));
358 return errn;
359}
360
361static ssize_t
362read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
363{
364 DEFINE_WAIT(wait);
365 struct rio_usb_data *rio = &rio_instance;
366 ssize_t read_count;
367 unsigned int partial;
368 int this_read;
369 int result;
370 int maxretry = 10;
371 char *ibuf;
372 int intr;
373
374 intr = mutex_lock_interruptible(&(rio->lock));
375 if (intr)
376 return -EINTR;
377 /* Sanity check to make sure rio is connected, powered, etc */
378 if (rio->present == 0 || rio->rio_dev == NULL) {
379 mutex_unlock(&(rio->lock));
380 return -ENODEV;
381 }
382
383 ibuf = rio->ibuf;
384
385 read_count = 0;
386
387
388 while (count > 0) {
389 if (signal_pending(current)) {
390 mutex_unlock(&(rio->lock));
391 return read_count ? read_count : -EINTR;
392 }
393 if (!rio->rio_dev) {
394 mutex_unlock(&(rio->lock));
395 return -ENODEV;
396 }
397 this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
398
399 result = usb_bulk_msg(rio->rio_dev,
400 usb_rcvbulkpipe(rio->rio_dev, 1),
401 ibuf, this_read, &partial,
402 8000);
403
404 dev_dbg(&rio->rio_dev->dev,
405 "read stats: result:%d this_read:%u partial:%u\n",
406 result, this_read, partial);
407
408 if (partial) {
409 count = this_read = partial;
410 } else if (result == -ETIMEDOUT || result == 15) { /* FIXME: 15 ??? */
411 if (!maxretry--) {
412 mutex_unlock(&(rio->lock));
413 dev_err(&rio->rio_dev->dev,
414 "read_rio: maxretry timeout\n");
415 return -ETIME;
416 }
417 prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
418 schedule_timeout(NAK_TIMEOUT);
419 finish_wait(&rio->wait_q, &wait);
420 continue;
421 } else if (result != -EREMOTEIO) {
422 mutex_unlock(&(rio->lock));
423 dev_err(&rio->rio_dev->dev,
424 "Read Whoops - result:%u partial:%u this_read:%u\n",
425 result, partial, this_read);
426 return -EIO;
427 } else {
428 mutex_unlock(&(rio->lock));
429 return (0);
430 }
431
432 if (this_read) {
433 if (copy_to_user(buffer, ibuf, this_read)) {
434 mutex_unlock(&(rio->lock));
435 return -EFAULT;
436 }
437 count -= this_read;
438 read_count += this_read;
439 buffer += this_read;
440 }
441 }
442 mutex_unlock(&(rio->lock));
443 return read_count;
444}
445
446static const struct file_operations usb_rio_fops = {
447 .owner = THIS_MODULE,
448 .read = read_rio,
449 .write = write_rio,
450 .unlocked_ioctl = ioctl_rio,
451 .open = open_rio,
452 .release = close_rio,
453 .llseek = noop_llseek,
454};
455
456static struct usb_class_driver usb_rio_class = {
457 .name = "rio500%d",
458 .fops = &usb_rio_fops,
459 .minor_base = RIO_MINOR,
460};
461
462static int probe_rio(struct usb_interface *intf,
463 const struct usb_device_id *id)
464{
465 struct usb_device *dev = interface_to_usbdev(intf);
466 struct rio_usb_data *rio = &rio_instance;
467 int retval;
468
469 dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
470
471 retval = usb_register_dev(intf, &usb_rio_class);
472 if (retval) {
473 dev_err(&dev->dev,
474 "Not able to get a minor for this device.\n");
475 return -ENOMEM;
476 }
477
478 rio->rio_dev = dev;
479
480 if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
481 dev_err(&dev->dev,
482 "probe_rio: Not enough memory for the output buffer\n");
483 usb_deregister_dev(intf, &usb_rio_class);
484 return -ENOMEM;
485 }
486 dev_dbg(&intf->dev, "obuf address:%p\n", rio->obuf);
487
488 if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
489 dev_err(&dev->dev,
490 "probe_rio: Not enough memory for the input buffer\n");
491 usb_deregister_dev(intf, &usb_rio_class);
492 kfree(rio->obuf);
493 return -ENOMEM;
494 }
495 dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf);
496
497 mutex_init(&(rio->lock));
498
499 usb_set_intfdata (intf, rio);
500 rio->present = 1;
501
502 return 0;
503}
504
505static void disconnect_rio(struct usb_interface *intf)
506{
507 struct rio_usb_data *rio = usb_get_intfdata (intf);
508
509 usb_set_intfdata (intf, NULL);
510 mutex_lock(&rio500_mutex);
511 if (rio) {
512 usb_deregister_dev(intf, &usb_rio_class);
513
514 mutex_lock(&(rio->lock));
515 if (rio->isopen) {
516 rio->isopen = 0;
517 /* better let it finish - the release will do whats needed */
518 rio->rio_dev = NULL;
519 mutex_unlock(&(rio->lock));
520 mutex_unlock(&rio500_mutex);
521 return;
522 }
523 kfree(rio->ibuf);
524 kfree(rio->obuf);
525
526 dev_info(&intf->dev, "USB Rio disconnected.\n");
527
528 rio->present = 0;
529 mutex_unlock(&(rio->lock));
530 }
531 mutex_unlock(&rio500_mutex);
532}
533
534static const struct usb_device_id rio_table[] = {
535 { USB_DEVICE(0x0841, 1) }, /* Rio 500 */
536 { } /* Terminating entry */
537};
538
539MODULE_DEVICE_TABLE (usb, rio_table);
540
541static struct usb_driver rio_driver = {
542 .name = "rio500",
543 .probe = probe_rio,
544 .disconnect = disconnect_rio,
545 .id_table = rio_table,
546};
547
548module_usb_driver(rio_driver);
549
550MODULE_AUTHOR( DRIVER_AUTHOR );
551MODULE_DESCRIPTION( DRIVER_DESC );
552MODULE_LICENSE("GPL");
553
1// SPDX-License-Identifier: GPL-2.0+
2/* -*- linux-c -*- */
3
4/*
5 * Driver for USB Rio 500
6 *
7 * Cesar Miquel (miquel@df.uba.ar)
8 *
9 * based on hp_scanner.c by David E. Nelson (dnelson@jump.net)
10 *
11 * Based upon mouse.c (Brad Keryan) and printer.c (Michael Gee).
12 *
13 * Changelog:
14 * 30/05/2003 replaced lock/unlock kernel with up/down
15 * Daniele Bellucci bellucda@tiscali.it
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/* stall/wait timeout for rio */
39#define NAK_TIMEOUT (HZ)
40
41#define IBUF_SIZE 0x1000
42
43/* Size of the rio buffer */
44#define OBUF_SIZE 0x10000
45
46struct rio_usb_data {
47 struct usb_device *rio_dev; /* init: probe_rio */
48 unsigned int ifnum; /* Interface number of the USB device */
49 int isopen; /* nz if open */
50 int present; /* Device is present on the bus */
51 char *obuf, *ibuf; /* transfer buffers */
52 char bulk_in_ep, bulk_out_ep; /* Endpoint assignments */
53 wait_queue_head_t wait_q; /* for timeouts */
54 struct mutex lock; /* general race avoidance */
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 /* against disconnect() */
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 /* Sanity check to make sure rio is connected, powered, etc */
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 /* Send rio control message */
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 /* rio_cmd.buffer contains a raw stream of single byte
174 data which has been returned from rio. Data is
175 interpreted at application level. For data that
176 will be cast to data types longer than 1 byte, data
177 will be little_endian and will potentially need to
178 be swapped at the app level */
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 /* Send rio control message */
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 /* Sanity check to make sure rio is connected, powered, etc */
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) { /* NAK - so hold for a while */
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 /* Sanity check to make sure rio is connected, powered, etc */
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) { /* FIXME: 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 /* better let it finish - the release will do whats needed */
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) }, /* Rio 500 */
519 { } /* Terminating entry */
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