drivers/usb/misc/rio500.c

   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/errno.h>
  36 #include <linux/random.h>
  37 #include <linux/poll.h>
  38 #include <linux/init.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
  63 struct 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
  74 static struct rio_usb_data rio_instance;
  75
  76 static int open_rio(struct inode *inode, struct file *file)
  77 {
  78         struct rio_usb_data *rio = &rio_instance;
  79
  80         mutex_lock(&(rio->lock));
  81
  82         if (rio->isopen || !rio->present) {
  83                 mutex_unlock(&(rio->lock));
  84                 return -EBUSY;
  85         }
  86         rio->isopen = 1;
  87
  88         init_waitqueue_head(&rio->wait_q);
  89
  90         mutex_unlock(&(rio->lock));
  91
  92         info("Rio opened.");
  93
  94         return 0;
  95 }
  96
  97 static int close_rio(struct inode *inode, struct file *file)
  98 {
  99         struct rio_usb_data *rio = &rio_instance;
 100
 101         rio->isopen = 0;
 102
 103         info("Rio closed.");
 104         return 0;
 105 }
 106
 107 static int
 108 ioctl_rio(struct inode *inode, struct file *file, unsigned int cmd,
 109           unsigned long arg)
 110 {
 111         struct RioCommand rio_cmd;
 112         struct rio_usb_data *rio = &rio_instance;
 113         void __user *data;
 114         unsigned char *buffer;
 115         int result, requesttype;
 116         int retries;
 117         int retval=0;
 118
 119         mutex_lock(&(rio->lock));
 120         /* Sanity check to make sure rio is connected, powered, etc */
 121         if ( rio == NULL ||
 122              rio->present == 0 ||
 123              rio->rio_dev == NULL )
 124         {
 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                 dbg
 156                     ("sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
 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                                 err("Error executing ioctrl. code = %d", result);
 174                                 retries = 0;
 175                         } else {
 176                                 dbg("Executed ioctl. Result = %d (data=%02x)",
 177                                      result, buffer[0]);
 178                                 if (copy_to_user(rio_cmd.buffer, buffer,
 179                                                  rio_cmd.length)) {
 180                                         free_page((unsigned long) buffer);
 181                                         retval = -EFAULT;
 182                                         goto err_out;
 183                                 }
 184                                 retries = 0;
 185                         }
 186
 187                         /* rio_cmd.buffer contains a raw stream of single byte
 188                            data which has been returned from rio.  Data is
 189                            interpreted at application level.  For data that
 190                            will be cast to data types longer than 1 byte, data
 191                            will be little_endian and will potentially need to
 192                            be swapped at the app level */
 193
 194                 }
 195                 free_page((unsigned long) buffer);
 196                 break;
 197
 198         case RIO_SEND_COMMAND:
 199                 data = (void __user *) arg;
 200                 if (data == NULL)
 201                         break;
 202                 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
 203                         retval = -EFAULT;
 204                         goto err_out;
 205                 }
 206                 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
 207                         retval = -EINVAL;
 208                         goto err_out;
 209                 }
 210                 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
 211                 if (buffer == NULL) {
 212                         retval = -ENOMEM;
 213                         goto err_out;
 214                 }
 215                 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
 216                         free_page((unsigned long)buffer);
 217                         retval = -EFAULT;
 218                         goto err_out;
 219                 }
 220
 221                 requesttype = rio_cmd.requesttype | USB_DIR_OUT |
 222                     USB_TYPE_VENDOR | USB_RECIP_DEVICE;
 223                 dbg("sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
 224                      requesttype, rio_cmd.request, rio_cmd.value,
 225                      rio_cmd.index, rio_cmd.length);
 226                 /* Send rio control message */
 227                 retries = 3;
 228                 while (retries) {
 229                         result = usb_control_msg(rio->rio_dev,
 230                                                  usb_sndctrlpipe(rio-> rio_dev, 0),
 231                                                  rio_cmd.request,
 232                                                  requesttype,
 233                                                  rio_cmd.value,
 234                                                  rio_cmd.index, buffer,
 235                                                  rio_cmd.length,
 236                                                  jiffies_to_msecs(rio_cmd.timeout));
 237                         if (result == -ETIMEDOUT)
 238                                 retries--;
 239                         else if (result < 0) {
 240                                 err("Error executing ioctrl. code = %d", result);
 241                                 retries = 0;
 242                         } else {
 243                                 dbg("Executed ioctl. Result = %d", result);
 244                                 retries = 0;
 245
 246                         }
 247
 248                 }
 249                 free_page((unsigned long) buffer);
 250                 break;
 251
 252         default:
 253                 retval = -ENOTTY;
 254                 break;
 255         }
 256
 257
 258 err_out:
 259         mutex_unlock(&(rio->lock));
 260         return retval;
 261 }
 262
 263 static ssize_t
 264 write_rio(struct file *file, const char __user *buffer,
 265           size_t count, loff_t * ppos)
 266 {
 267         DEFINE_WAIT(wait);
 268         struct rio_usb_data *rio = &rio_instance;
 269
 270         unsigned long copy_size;
 271         unsigned long bytes_written = 0;
 272         unsigned int partial;
 273
 274         int result = 0;
 275         int maxretry;
 276         int errn = 0;
 277         int intr;
 278
 279         intr = mutex_lock_interruptible(&(rio->lock));
 280         if (intr)
 281                 return -EINTR;
 282         /* Sanity check to make sure rio is connected, powered, etc */
 283         if ( rio == NULL ||
 284              rio->present == 0 ||
 285              rio->rio_dev == NULL )
 286         {
 287                 mutex_unlock(&(rio->lock));
 288                 return -ENODEV;
 289         }
 290
 291
 292
 293         do {
 294                 unsigned long thistime;
 295                 char *obuf = rio->obuf;
 296
 297                 thistime = copy_size =
 298                     (count >= OBUF_SIZE) ? OBUF_SIZE : count;
 299                 if (copy_from_user(rio->obuf, buffer, copy_size)) {
 300                         errn = -EFAULT;
 301                         goto error;
 302                 }
 303                 maxretry = 5;
 304                 while (thistime) {
 305                         if (!rio->rio_dev) {
 306                                 errn = -ENODEV;
 307                                 goto error;
 308                         }
 309                         if (signal_pending(current)) {
 310                                 mutex_unlock(&(rio->lock));
 311                                 return bytes_written ? bytes_written : -EINTR;
 312                         }
 313
 314                         result = usb_bulk_msg(rio->rio_dev,
 315                                          usb_sndbulkpipe(rio->rio_dev, 2),
 316                                          obuf, thistime, &partial, 5000);
 317
 318                         dbg("write stats: result:%d thistime:%lu partial:%u",
 319                              result, thistime, partial);
 320
 321                         if (result == -ETIMEDOUT) {     /* NAK - so hold for a while */
 322                                 if (!maxretry--) {
 323                                         errn = -ETIME;
 324                                         goto error;
 325                                 }
 326                                 prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
 327                                 schedule_timeout(NAK_TIMEOUT);
 328                                 finish_wait(&rio->wait_q, &wait);
 329                                 continue;
 330                         } else if (!result && partial) {
 331                                 obuf += partial;
 332                                 thistime -= partial;
 333                         } else
 334                                 break;
 335                 };
 336                 if (result) {
 337                         err("Write Whoops - %x", result);
 338                         errn = -EIO;
 339                         goto error;
 340                 }
 341                 bytes_written += copy_size;
 342                 count -= copy_size;
 343                 buffer += copy_size;
 344         } while (count > 0);
 345
 346         mutex_unlock(&(rio->lock));
 347
 348         return bytes_written ? bytes_written : -EIO;
 349
 350 error:
 351         mutex_unlock(&(rio->lock));
 352         return errn;
 353 }
 354
 355 static ssize_t
 356 read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
 357 {
 358         DEFINE_WAIT(wait);
 359         struct rio_usb_data *rio = &rio_instance;
 360         ssize_t read_count;
 361         unsigned int partial;
 362         int this_read;
 363         int result;
 364         int maxretry = 10;
 365         char *ibuf;
 366         int intr;
 367
 368         intr = mutex_lock_interruptible(&(rio->lock));
 369         if (intr)
 370                 return -EINTR;
 371         /* Sanity check to make sure rio is connected, powered, etc */
 372         if ( rio == NULL ||
 373              rio->present == 0 ||
 374              rio->rio_dev == NULL )
 375         {
 376                 mutex_unlock(&(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                         mutex_unlock(&(rio->lock));
 388                         return read_count ? read_count : -EINTR;
 389                 }
 390                 if (!rio->rio_dev) {
 391                         mutex_unlock(&(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                                       8000);
 400
 401                 dbg("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 == -ETIMEDOUT || result == 15) {      /* FIXME: 15 ??? */
 407                         if (!maxretry--) {
 408                                 mutex_unlock(&(rio->lock));
 409                                 err("read_rio: maxretry timeout");
 410                                 return -ETIME;
 411                         }
 412                         prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
 413                         schedule_timeout(NAK_TIMEOUT);
 414                         finish_wait(&rio->wait_q, &wait);
 415                         continue;
 416                 } else if (result != -EREMOTEIO) {
 417                         mutex_unlock(&(rio->lock));
 418                         err("Read Whoops - result:%u partial:%u this_read:%u",
 419                              result, partial, this_read);
 420                         return -EIO;
 421                 } else {
 422                         mutex_unlock(&(rio->lock));
 423                         return (0);
 424                 }
 425
 426                 if (this_read) {
 427                         if (copy_to_user(buffer, ibuf, this_read)) {
 428                                 mutex_unlock(&(rio->lock));
 429                                 return -EFAULT;
 430                         }
 431                         count -= this_read;
 432                         read_count += this_read;
 433                         buffer += this_read;
 434                 }
 435         }
 436         mutex_unlock(&(rio->lock));
 437         return read_count;
 438 }
 439
 440 static struct
 441 file_operations usb_rio_fops = {
 442         .owner =        THIS_MODULE,
 443         .read =         read_rio,
 444         .write =        write_rio,
 445         .ioctl =        ioctl_rio,
 446         .open =         open_rio,
 447         .release =      close_rio,
 448 };
 449
 450 static struct usb_class_driver usb_rio_class = {
 451         .name =         "rio500%d",
 452         .fops =         &usb_rio_fops,
 453         .minor_base =   RIO_MINOR,
 454 };
 455
 456 static int probe_rio(struct usb_interface *intf,
 457                      const struct usb_device_id *id)
 458 {
 459         struct usb_device *dev = interface_to_usbdev(intf);
 460         struct rio_usb_data *rio = &rio_instance;
 461         int retval;
 462
 463         info("USB Rio found at address %d", dev->devnum);
 464
 465         retval = usb_register_dev(intf, &usb_rio_class);
 466         if (retval) {
 467                 err("Not able to get a minor for this device.");
 468                 return -ENOMEM;
 469         }
 470
 471         rio->rio_dev = dev;
 472
 473         if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
 474                 err("probe_rio: Not enough memory for the output buffer");
 475                 usb_deregister_dev(intf, &usb_rio_class);
 476                 return -ENOMEM;
 477         }
 478         dbg("probe_rio: obuf address:%p", rio->obuf);
 479
 480         if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
 481                 err("probe_rio: Not enough memory for the input buffer");
 482                 usb_deregister_dev(intf, &usb_rio_class);
 483                 kfree(rio->obuf);
 484                 return -ENOMEM;
 485         }
 486         dbg("probe_rio: ibuf address:%p", rio->ibuf);
 487
 488         mutex_init(&(rio->lock));
 489
 490         usb_set_intfdata (intf, rio);
 491         rio->present = 1;
 492
 493         return 0;
 494 }
 495
 496 static void disconnect_rio(struct usb_interface *intf)
 497 {
 498         struct rio_usb_data *rio = usb_get_intfdata (intf);
 499
 500         usb_set_intfdata (intf, NULL);
 501         if (rio) {
 502                 usb_deregister_dev(intf, &usb_rio_class);
 503
 504                 mutex_lock(&(rio->lock));
 505                 if (rio->isopen) {
 506                         rio->isopen = 0;
 507                         /* better let it finish - the release will do whats needed */
 508                         rio->rio_dev = NULL;
 509                         mutex_unlock(&(rio->lock));
 510                         return;
 511                 }
 512                 kfree(rio->ibuf);
 513                 kfree(rio->obuf);
 514
 515                 info("USB Rio disconnected.");
 516
 517                 rio->present = 0;
 518                 mutex_unlock(&(rio->lock));
 519         }
 520 }
 521
 522 static struct usb_device_id rio_table [] = {
 523         { USB_DEVICE(0x0841, 1) },              /* Rio 500 */
 524         { }                                     /* Terminating entry */
 525 };
 526
 527 MODULE_DEVICE_TABLE (usb, rio_table);
 528
 529 static struct usb_driver rio_driver = {
 530         .name =         "rio500",
 531         .probe =        probe_rio,
 532         .disconnect =   disconnect_rio,
 533         .id_table =     rio_table,
 534 };
 535
 536 static int __init usb_rio_init(void)
 537 {
 538         int retval;
 539         retval = usb_register(&rio_driver);
 540         if (retval)
 541                 goto out;
 542
 543         info(DRIVER_VERSION ":" DRIVER_DESC);
 544
 545 out:
 546         return retval;
 547 }
 548
 549
 550 static void __exit usb_rio_cleanup(void)
 551 {
 552         struct rio_usb_data *rio = &rio_instance;
 553
 554         rio->present = 0;
 555         usb_deregister(&rio_driver);
 556
 557
 558 }
 559
 560 module_init(usb_rio_init);
 561 module_exit(usb_rio_cleanup);
 562
 563 MODULE_AUTHOR( DRIVER_AUTHOR );
 564 MODULE_DESCRIPTION( DRIVER_DESC );
 565 MODULE_LICENSE("GPL");
 566