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/smp_lock.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 semaphore 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         down(&(rio->lock));
  81
  82         if (rio->isopen || !rio->present) {
  83                 up(&(rio->lock));
  84                 return -EBUSY;
  85         }
  86         rio->isopen = 1;
  87
  88         init_waitqueue_head(&rio->wait_q);
  89
  90         up(&(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         down(&(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                                                  rio_cmd.timeout);
 170                         if (result == -ETIMEDOUT)
 171                                 retries--;
 172                         else if (result < 0) {
 173                                 err("Error executing ioctrl. code = %d",
 174                                      le32_to_cpu(result));
 175                                 retries = 0;
 176                         } else {
 177                                 dbg("Executed ioctl. Result = %d (data=%04x)",
 178                                      le32_to_cpu(result),
 179                                      le32_to_cpu(*((long *) buffer)));
 180                                 if (copy_to_user(rio_cmd.buffer, buffer,
 181                                                  rio_cmd.length)) {
 182                                         free_page((unsigned long) buffer);
 183                                         retval = -EFAULT;
 184                                         goto err_out;
 185                                 }
 186                                 retries = 0;
 187                         }
 188
 189                         /* rio_cmd.buffer contains a raw stream of single byte
 190                            data which has been returned from rio.  Data is
 191                            interpreted at application level.  For data that
 192                            will be cast to data types longer than 1 byte, data
 193                            will be little_endian and will potentially need to
 194                            be swapped at the app level */
 195
 196                 }
 197                 free_page((unsigned long) buffer);
 198                 break;
 199
 200         case RIO_SEND_COMMAND:
 201                 data = (void __user *) arg;
 202                 if (data == NULL)
 203                         break;
 204                 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
 205                         retval = -EFAULT;
 206                         goto err_out;
 207                 }
 208                 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
 209                         retval = -EINVAL;
 210                         goto err_out;
 211                 }
 212                 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
 213                 if (buffer == NULL) {
 214                         retval = -ENOMEM;
 215                         goto err_out;
 216                 }
 217                 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
 218                         free_page((unsigned long)buffer);
 219                         retval = -EFAULT;
 220                         goto err_out;
 221                 }
 222
 223                 requesttype = rio_cmd.requesttype | USB_DIR_OUT |
 224                     USB_TYPE_VENDOR | USB_RECIP_DEVICE;
 225                 dbg("sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
 226                      requesttype, rio_cmd.request, rio_cmd.value,
 227                      rio_cmd.index, rio_cmd.length);
 228                 /* Send rio control message */
 229                 retries = 3;
 230                 while (retries) {
 231                         result = usb_control_msg(rio->rio_dev,
 232                                                  usb_sndctrlpipe(rio-> rio_dev, 0),
 233                                                  rio_cmd.request,
 234                                                  requesttype,
 235                                                  rio_cmd.value,
 236                                                  rio_cmd.index, buffer,
 237                                                  rio_cmd.length,
 238                                                  rio_cmd.timeout);
 239                         if (result == -ETIMEDOUT)
 240                                 retries--;
 241                         else if (result < 0) {
 242                                 err("Error executing ioctrl. code = %d",
 243                                      le32_to_cpu(result));
 244                                 retries = 0;
 245                         } else {
 246                                 dbg("Executed ioctl. Result = %d",
 247                                        le32_to_cpu(result));
 248                                 retries = 0;
 249
 250                         }
 251
 252                 }
 253                 free_page((unsigned long) buffer);
 254                 break;
 255
 256         default:
 257                 retval = -ENOTTY;
 258                 break;
 259         }
 260
 261
 262 err_out:
 263         up(&(rio->lock));
 264         return retval;
 265 }
 266
 267 static ssize_t
 268 write_rio(struct file *file, const char __user *buffer,
 269           size_t count, loff_t * ppos)
 270 {
 271         struct rio_usb_data *rio = &rio_instance;
 272
 273         unsigned long copy_size;
 274         unsigned long bytes_written = 0;
 275         unsigned int partial;
 276
 277         int result = 0;
 278         int maxretry;
 279         int errn = 0;
 280
 281         down(&(rio->lock));
 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                 up(&(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                                 up(&(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, 5 * HZ);
 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                                 interruptible_sleep_on_timeout(&rio-> wait_q, NAK_TIMEOUT);
 327                                 continue;
 328                         } else if (!result && partial) {
 329                                 obuf += partial;
 330                                 thistime -= partial;
 331                         } else
 332                                 break;
 333                 };
 334                 if (result) {
 335                         err("Write Whoops - %x", result);
 336                         errn = -EIO;
 337                         goto error;
 338                 }
 339                 bytes_written += copy_size;
 340                 count -= copy_size;
 341                 buffer += copy_size;
 342         } while (count > 0);
 343
 344         up(&(rio->lock));
 345
 346         return bytes_written ? bytes_written : -EIO;
 347
 348 error:
 349         up(&(rio->lock));
 350         return errn;
 351 }
 352
 353 static ssize_t
 354 read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
 355 {
 356         struct rio_usb_data *rio = &rio_instance;
 357         ssize_t read_count;
 358         unsigned int partial;
 359         int this_read;
 360         int result;
 361         int maxretry = 10;
 362         char *ibuf;
 363
 364         down(&(rio->lock));
 365         /* Sanity check to make sure rio is connected, powered, etc */
 366         if ( rio == NULL ||
 367              rio->present == 0 ||
 368              rio->rio_dev == NULL )
 369         {
 370                 up(&(rio->lock));
 371                 return -ENODEV;
 372         }
 373
 374         ibuf = rio->ibuf;
 375
 376         read_count = 0;
 377
 378
 379         while (count > 0) {
 380                 if (signal_pending(current)) {
 381                         up(&(rio->lock));
 382                         return read_count ? read_count : -EINTR;
 383                 }
 384                 if (!rio->rio_dev) {
 385                         up(&(rio->lock));
 386                         return -ENODEV;
 387                 }
 388                 this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
 389
 390                 result = usb_bulk_msg(rio->rio_dev,
 391                                       usb_rcvbulkpipe(rio->rio_dev, 1),
 392                                       ibuf, this_read, &partial,
 393                                       (int) (HZ * 8));
 394
 395                 dbg(KERN_DEBUG "read stats: result:%d this_read:%u partial:%u",
 396                        result, this_read, partial);
 397
 398                 if (partial) {
 399                         count = this_read = partial;
 400                 } else if (result == -ETIMEDOUT || result == 15) {      /* FIXME: 15 ??? */
 401                         if (!maxretry--) {
 402                                 up(&(rio->lock));
 403                                 err("read_rio: maxretry timeout");
 404                                 return -ETIME;
 405                         }
 406                         interruptible_sleep_on_timeout(&rio->wait_q,
 407                                                        NAK_TIMEOUT);
 408                         continue;
 409                 } else if (result != -EREMOTEIO) {
 410                         up(&(rio->lock));
 411                         err("Read Whoops - result:%u partial:%u this_read:%u",
 412                              result, partial, this_read);
 413                         return -EIO;
 414                 } else {
 415                         up(&(rio->lock));
 416                         return (0);
 417                 }
 418
 419                 if (this_read) {
 420                         if (copy_to_user(buffer, ibuf, this_read)) {
 421                                 up(&(rio->lock));
 422                                 return -EFAULT;
 423                         }
 424                         count -= this_read;
 425                         read_count += this_read;
 426                         buffer += this_read;
 427                 }
 428         }
 429         up(&(rio->lock));
 430         return read_count;
 431 }
 432
 433 static struct
 434 file_operations usb_rio_fops = {
 435         .owner =        THIS_MODULE,
 436         .read =         read_rio,
 437         .write =        write_rio,
 438         .ioctl =        ioctl_rio,
 439         .open =         open_rio,
 440         .release =      close_rio,
 441 };
 442
 443 static struct usb_class_driver usb_rio_class = {
 444         .name =         "usb/rio500%d",
 445         .fops =         &usb_rio_fops,
 446         .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
 447         .minor_base =   RIO_MINOR,
 448 };
 449
 450 static int probe_rio(struct usb_interface *intf,
 451                      const struct usb_device_id *id)
 452 {
 453         struct usb_device *dev = interface_to_usbdev(intf);
 454         struct rio_usb_data *rio = &rio_instance;
 455         int retval;
 456
 457         info("USB Rio found at address %d", dev->devnum);
 458
 459         retval = usb_register_dev(intf, &usb_rio_class);
 460         if (retval) {
 461                 err("Not able to get a minor for this device.");
 462                 return -ENOMEM;
 463         }
 464
 465         rio->rio_dev = dev;
 466
 467         if (!(rio->obuf = (char *) kmalloc(OBUF_SIZE, GFP_KERNEL))) {
 468                 err("probe_rio: Not enough memory for the output buffer");
 469                 usb_deregister_dev(intf, &usb_rio_class);
 470                 return -ENOMEM;
 471         }
 472         dbg("probe_rio: obuf address:%p", rio->obuf);
 473
 474         if (!(rio->ibuf = (char *) kmalloc(IBUF_SIZE, GFP_KERNEL))) {
 475                 err("probe_rio: Not enough memory for the input buffer");
 476                 usb_deregister_dev(intf, &usb_rio_class);
 477                 kfree(rio->obuf);
 478                 return -ENOMEM;
 479         }
 480         dbg("probe_rio: ibuf address:%p", rio->ibuf);
 481
 482         init_MUTEX(&(rio->lock));
 483
 484         usb_set_intfdata (intf, rio);
 485         rio->present = 1;
 486
 487         return 0;
 488 }
 489
 490 static void disconnect_rio(struct usb_interface *intf)
 491 {
 492         struct rio_usb_data *rio = usb_get_intfdata (intf);
 493
 494         usb_set_intfdata (intf, NULL);
 495         if (rio) {
 496                 usb_deregister_dev(intf, &usb_rio_class);
 497
 498                 down(&(rio->lock));
 499                 if (rio->isopen) {
 500                         rio->isopen = 0;
 501                         /* better let it finish - the release will do whats needed */
 502                         rio->rio_dev = NULL;
 503                         up(&(rio->lock));
 504                         return;
 505                 }
 506                 kfree(rio->ibuf);
 507                 kfree(rio->obuf);
 508
 509                 info("USB Rio disconnected.");
 510
 511                 rio->present = 0;
 512                 up(&(rio->lock));
 513         }
 514 }
 515
 516 static struct usb_device_id rio_table [] = {
 517         { USB_DEVICE(0x0841, 1) },              /* Rio 500 */
 518         { }                                     /* Terminating entry */
 519 };
 520
 521 MODULE_DEVICE_TABLE (usb, rio_table);
 522
 523 static struct usb_driver rio_driver = {
 524         .owner =        THIS_MODULE,
 525         .name =         "rio500",
 526         .probe =        probe_rio,
 527         .disconnect =   disconnect_rio,
 528         .id_table =     rio_table,
 529 };
 530
 531 static int __init usb_rio_init(void)
 532 {
 533         int retval;
 534         retval = usb_register(&rio_driver);
 535         if (retval)
 536                 goto out;
 537
 538         info(DRIVER_VERSION ":" DRIVER_DESC);
 539
 540 out:
 541         return retval;
 542 }
 543
 544
 545 static void __exit usb_rio_cleanup(void)
 546 {
 547         struct rio_usb_data *rio = &rio_instance;
 548
 549         rio->present = 0;
 550         usb_deregister(&rio_driver);
 551
 552
 553 }
 554
 555 module_init(usb_rio_init);
 556 module_exit(usb_rio_cleanup);
 557
 558 MODULE_AUTHOR( DRIVER_AUTHOR );
 559 MODULE_DESCRIPTION( DRIVER_DESC );
 560 MODULE_LICENSE("GPL");
 561