Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rio500.c
Go to the documentation of this file.
1 /* -*- linux-c -*- */
2 
3 /*
4  * Driver for USB Rio 500
5  *
6  * Cesar Miquel ([email protected])
7  *
8  * based on hp_scanner.c by David E. Nelson ([email protected])
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 [email protected]
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  * Version Information
49  */
50 #define DRIVER_VERSION "v1.1"
51 #define DRIVER_AUTHOR "Cesar Miquel <[email protected]>"
52 #define DRIVER_DESC "USB Rio 500 driver"
53 
54 #define RIO_MINOR 64
55 
56 /* stall/wait timeout for rio */
57 #define NAK_TIMEOUT (HZ)
58 
59 #define IBUF_SIZE 0x1000
60 
61 /* Size of the rio buffer */
62 #define OBUF_SIZE 0x10000
63 
64 struct rio_usb_data {
65  struct usb_device *rio_dev; /* init: probe_rio */
66  unsigned int ifnum; /* Interface number of the USB device */
67  int isopen; /* nz if open */
68  int present; /* Device is present on the bus */
69  char *obuf, *ibuf; /* transfer buffers */
70  char bulk_in_ep, bulk_out_ep; /* Endpoint assignments */
71  wait_queue_head_t wait_q; /* for timeouts */
72  struct mutex lock; /* general race avoidance */
73 };
74 
75 static DEFINE_MUTEX(rio500_mutex);
76 static struct rio_usb_data rio_instance;
77 
78 static int open_rio(struct inode *inode, struct file *file)
79 {
80  struct rio_usb_data *rio = &rio_instance;
81 
82  /* against disconnect() */
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 
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 
103 static 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 
113 static 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  /* Sanity check to make sure rio is connected, powered, etc */
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 |
156  dev_dbg(&rio->rio_dev->dev,
157  "sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
158  requesttype, rio_cmd.request, rio_cmd.value,
159  rio_cmd.index, rio_cmd.length);
160  /* Send rio control message */
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  dev_err(&rio->rio_dev->dev,
175  "Error executing ioctrl. code = %d\n",
176  result);
177  retries = 0;
178  } else {
179  dev_dbg(&rio->rio_dev->dev,
180  "Executed ioctl. Result = %d (data=%02x)\n",
181  result, buffer[0]);
182  if (copy_to_user(rio_cmd.buffer, buffer,
183  rio_cmd.length)) {
184  free_page((unsigned long) buffer);
185  retval = -EFAULT;
186  goto err_out;
187  }
188  retries = 0;
189  }
190 
191  /* rio_cmd.buffer contains a raw stream of single byte
192  data which has been returned from rio. Data is
193  interpreted at application level. For data that
194  will be cast to data types longer than 1 byte, data
195  will be little_endian and will potentially need to
196  be swapped at the app level */
197 
198  }
199  free_page((unsigned long) buffer);
200  break;
201 
202  case RIO_SEND_COMMAND:
203  data = (void __user *) arg;
204  if (data == NULL)
205  break;
206  if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
207  retval = -EFAULT;
208  goto err_out;
209  }
210  if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
211  retval = -EINVAL;
212  goto err_out;
213  }
214  buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
215  if (buffer == NULL) {
216  retval = -ENOMEM;
217  goto err_out;
218  }
219  if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
220  free_page((unsigned long)buffer);
221  retval = -EFAULT;
222  goto err_out;
223  }
224 
225  requesttype = rio_cmd.requesttype | USB_DIR_OUT |
227  dev_dbg(&rio->rio_dev->dev,
228  "sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
229  requesttype, rio_cmd.request, rio_cmd.value,
230  rio_cmd.index, rio_cmd.length);
231  /* Send rio control message */
232  retries = 3;
233  while (retries) {
234  result = usb_control_msg(rio->rio_dev,
235  usb_sndctrlpipe(rio-> rio_dev, 0),
236  rio_cmd.request,
237  requesttype,
238  rio_cmd.value,
239  rio_cmd.index, buffer,
240  rio_cmd.length,
241  jiffies_to_msecs(rio_cmd.timeout));
242  if (result == -ETIMEDOUT)
243  retries--;
244  else if (result < 0) {
245  dev_err(&rio->rio_dev->dev,
246  "Error executing ioctrl. code = %d\n",
247  result);
248  retries = 0;
249  } else {
250  dev_dbg(&rio->rio_dev->dev,
251  "Executed ioctl. Result = %d\n", result);
252  retries = 0;
253 
254  }
255 
256  }
257  free_page((unsigned long) buffer);
258  break;
259 
260  default:
261  retval = -ENOTTY;
262  break;
263  }
264 
265 
266 err_out:
267  mutex_unlock(&(rio->lock));
268  return retval;
269 }
270 
271 static ssize_t
272 write_rio(struct file *file, const char __user *buffer,
273  size_t count, loff_t * ppos)
274 {
275  DEFINE_WAIT(wait);
276  struct rio_usb_data *rio = &rio_instance;
277 
278  unsigned long copy_size;
279  unsigned long bytes_written = 0;
280  unsigned int partial;
281 
282  int result = 0;
283  int maxretry;
284  int errn = 0;
285  int intr;
286 
287  intr = mutex_lock_interruptible(&(rio->lock));
288  if (intr)
289  return -EINTR;
290  /* Sanity check to make sure rio is connected, powered, etc */
291  if (rio->present == 0 || rio->rio_dev == NULL) {
292  mutex_unlock(&(rio->lock));
293  return -ENODEV;
294  }
295 
296 
297 
298  do {
299  unsigned long thistime;
300  char *obuf = rio->obuf;
301 
302  thistime = copy_size =
303  (count >= OBUF_SIZE) ? OBUF_SIZE : count;
304  if (copy_from_user(rio->obuf, buffer, copy_size)) {
305  errn = -EFAULT;
306  goto error;
307  }
308  maxretry = 5;
309  while (thistime) {
310  if (!rio->rio_dev) {
311  errn = -ENODEV;
312  goto error;
313  }
314  if (signal_pending(current)) {
315  mutex_unlock(&(rio->lock));
316  return bytes_written ? bytes_written : -EINTR;
317  }
318 
319  result = usb_bulk_msg(rio->rio_dev,
320  usb_sndbulkpipe(rio->rio_dev, 2),
321  obuf, thistime, &partial, 5000);
322 
323  dev_dbg(&rio->rio_dev->dev,
324  "write stats: result:%d thistime:%lu partial:%u\n",
325  result, thistime, partial);
326 
327  if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
328  if (!maxretry--) {
329  errn = -ETIME;
330  goto error;
331  }
334  finish_wait(&rio->wait_q, &wait);
335  continue;
336  } else if (!result && partial) {
337  obuf += partial;
338  thistime -= partial;
339  } else
340  break;
341  }
342  if (result) {
343  dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
344  result);
345  errn = -EIO;
346  goto error;
347  }
348  bytes_written += copy_size;
349  count -= copy_size;
350  buffer += copy_size;
351  } while (count > 0);
352 
353  mutex_unlock(&(rio->lock));
354 
355  return bytes_written ? bytes_written : -EIO;
356 
357 error:
358  mutex_unlock(&(rio->lock));
359  return errn;
360 }
361 
362 static ssize_t
363 read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
364 {
365  DEFINE_WAIT(wait);
366  struct rio_usb_data *rio = &rio_instance;
367  ssize_t read_count;
368  unsigned int partial;
369  int this_read;
370  int result;
371  int maxretry = 10;
372  char *ibuf;
373  int intr;
374 
375  intr = mutex_lock_interruptible(&(rio->lock));
376  if (intr)
377  return -EINTR;
378  /* Sanity check to make sure rio is connected, powered, etc */
379  if (rio->present == 0 || rio->rio_dev == NULL) {
380  mutex_unlock(&(rio->lock));
381  return -ENODEV;
382  }
383 
384  ibuf = rio->ibuf;
385 
386  read_count = 0;
387 
388 
389  while (count > 0) {
390  if (signal_pending(current)) {
391  mutex_unlock(&(rio->lock));
392  return read_count ? read_count : -EINTR;
393  }
394  if (!rio->rio_dev) {
395  mutex_unlock(&(rio->lock));
396  return -ENODEV;
397  }
398  this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
399 
400  result = usb_bulk_msg(rio->rio_dev,
401  usb_rcvbulkpipe(rio->rio_dev, 1),
402  ibuf, this_read, &partial,
403  8000);
404 
405  dev_dbg(&rio->rio_dev->dev,
406  "read stats: result:%d this_read:%u partial:%u\n",
407  result, this_read, partial);
408 
409  if (partial) {
410  count = this_read = partial;
411  } else if (result == -ETIMEDOUT || result == 15) { /* FIXME: 15 ??? */
412  if (!maxretry--) {
413  mutex_unlock(&(rio->lock));
414  dev_err(&rio->rio_dev->dev,
415  "read_rio: maxretry timeout\n");
416  return -ETIME;
417  }
420  finish_wait(&rio->wait_q, &wait);
421  continue;
422  } else if (result != -EREMOTEIO) {
423  mutex_unlock(&(rio->lock));
424  dev_err(&rio->rio_dev->dev,
425  "Read Whoops - result:%u partial:%u this_read:%u\n",
426  result, partial, this_read);
427  return -EIO;
428  } else {
429  mutex_unlock(&(rio->lock));
430  return (0);
431  }
432 
433  if (this_read) {
434  if (copy_to_user(buffer, ibuf, this_read)) {
435  mutex_unlock(&(rio->lock));
436  return -EFAULT;
437  }
438  count -= this_read;
439  read_count += this_read;
440  buffer += this_read;
441  }
442  }
443  mutex_unlock(&(rio->lock));
444  return read_count;
445 }
446 
447 static const struct file_operations usb_rio_fops = {
448  .owner = THIS_MODULE,
449  .read = read_rio,
450  .write = write_rio,
451  .unlocked_ioctl = ioctl_rio,
452  .open = open_rio,
453  .release = close_rio,
454  .llseek = noop_llseek,
455 };
456 
457 static struct usb_class_driver usb_rio_class = {
458  .name = "rio500%d",
459  .fops = &usb_rio_fops,
460  .minor_base = RIO_MINOR,
461 };
462 
463 static int probe_rio(struct usb_interface *intf,
464  const struct usb_device_id *id)
465 {
466  struct usb_device *dev = interface_to_usbdev(intf);
467  struct rio_usb_data *rio = &rio_instance;
468  int retval;
469 
470  dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
471 
472  retval = usb_register_dev(intf, &usb_rio_class);
473  if (retval) {
474  dev_err(&dev->dev,
475  "Not able to get a minor for this device.\n");
476  return -ENOMEM;
477  }
478 
479  rio->rio_dev = dev;
480 
481  if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
482  dev_err(&dev->dev,
483  "probe_rio: Not enough memory for the output buffer\n");
484  usb_deregister_dev(intf, &usb_rio_class);
485  return -ENOMEM;
486  }
487  dev_dbg(&intf->dev, "obuf address:%p\n", rio->obuf);
488 
489  if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
490  dev_err(&dev->dev,
491  "probe_rio: Not enough memory for the input buffer\n");
492  usb_deregister_dev(intf, &usb_rio_class);
493  kfree(rio->obuf);
494  return -ENOMEM;
495  }
496  dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf);
497 
498  mutex_init(&(rio->lock));
499 
500  usb_set_intfdata (intf, rio);
501  rio->present = 1;
502 
503  return 0;
504 }
505 
506 static void disconnect_rio(struct usb_interface *intf)
507 {
508  struct rio_usb_data *rio = usb_get_intfdata (intf);
509 
510  usb_set_intfdata (intf, NULL);
511  mutex_lock(&rio500_mutex);
512  if (rio) {
513  usb_deregister_dev(intf, &usb_rio_class);
514 
515  mutex_lock(&(rio->lock));
516  if (rio->isopen) {
517  rio->isopen = 0;
518  /* better let it finish - the release will do whats needed */
519  rio->rio_dev = NULL;
520  mutex_unlock(&(rio->lock));
521  mutex_unlock(&rio500_mutex);
522  return;
523  }
524  kfree(rio->ibuf);
525  kfree(rio->obuf);
526 
527  dev_info(&intf->dev, "USB Rio disconnected.\n");
528 
529  rio->present = 0;
530  mutex_unlock(&(rio->lock));
531  }
532  mutex_unlock(&rio500_mutex);
533 }
534 
535 static const struct usb_device_id rio_table[] = {
536  { USB_DEVICE(0x0841, 1) }, /* Rio 500 */
537  { } /* Terminating entry */
538 };
539 
540 MODULE_DEVICE_TABLE (usb, rio_table);
541 
542 static struct usb_driver rio_driver = {
543  .name = "rio500",
544  .probe = probe_rio,
545  .disconnect = disconnect_rio,
546  .id_table = rio_table,
547 };
548 
549 module_usb_driver(rio_driver);
550 
553 MODULE_LICENSE("GPL");
554