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", 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                                                  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         up(&(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         struct rio_usb_data *rio = &rio_instance;
 268
 269         unsigned long copy_size;
 270         unsigned long bytes_written = 0;
 271         unsigned int partial;
 272
 273         int result = 0;
 274         int maxretry;
 275         int errn = 0;
 276
 277         down(&(rio->lock));
 278         /* Sanity check to make sure rio is connected, powered, etc */
 279         if ( rio == NULL ||
 280              rio->present == 0 ||
 281              rio->rio_dev == NULL )
 282         {
 283                 up(&(rio->lock));
 284                 return -ENODEV;
 285         }
 286
 287
 288
 289         do {
 290                 unsigned long thistime;
 291                 char *obuf = rio->obuf;
 292
 293                 thistime = copy_size =
 294                     (count >= OBUF_SIZE) ? OBUF_SIZE : count;
 295                 if (copy_from_user(rio->obuf, buffer, copy_size)) {
 296                         errn = -EFAULT;
 297                         goto error;
 298                 }
 299                 maxretry = 5;
 300                 while (thistime) {
 301                         if (!rio->rio_dev) {
 302                                 errn = -ENODEV;
 303                                 goto error;
 304                         }
 305                         if (signal_pending(current)) {
 306                                 up(&(rio->lock));
 307                                 return bytes_written ? bytes_written : -EINTR;
 308                         }
 309
 310                         result = usb_bulk_msg(rio->rio_dev,
 311                                          usb_sndbulkpipe(rio->rio_dev, 2),
 312                                          obuf, thistime, &partial, 5 * HZ);
 313
 314                         dbg("write stats: result:%d thistime:%lu partial:%u",
 315                              result, thistime, partial);
 316
 317                         if (result == -ETIMEDOUT) {     /* NAK - so hold for a while */
 318                                 if (!maxretry--) {
 319                                         errn = -ETIME;
 320                                         goto error;
 321                                 }
 322                                 interruptible_sleep_on_timeout(&rio-> wait_q, NAK_TIMEOUT);
 323                                 continue;
 324                         } else if (!result && partial) {
 325                                 obuf += partial;
 326                                 thistime -= partial;
 327                         } else
 328                                 break;
 329                 };
 330                 if (result) {
 331                         err("Write Whoops - %x", result);
 332                         errn = -EIO;
 333                         goto error;
 334                 }
 335                 bytes_written += copy_size;
 336                 count -= copy_size;
 337                 buffer += copy_size;
 338         } while (count > 0);
 339
 340         up(&(rio->lock));
 341
 342         return bytes_written ? bytes_written : -EIO;
 343
 344 error:
 345         up(&(rio->lock));
 346         return errn;
 347 }
 348
 349 static ssize_t
 350 read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
 351 {
 352         struct rio_usb_data *rio = &rio_instance;
 353         ssize_t read_count;
 354         unsigned int partial;
 355         int this_read;
 356         int result;
 357         int maxretry = 10;
 358         char *ibuf;
 359
 360         down(&(rio->lock));
 361         /* Sanity check to make sure rio is connected, powered, etc */
 362         if ( rio == NULL ||
 363              rio->present == 0 ||
 364              rio->rio_dev == NULL )
 365         {
 366                 up(&(rio->lock));
 367                 return -ENODEV;
 368         }
 369
 370         ibuf = rio->ibuf;
 371
 372         read_count = 0;
 373
 374
 375         while (count > 0) {
 376                 if (signal_pending(current)) {
 377                         up(&(rio->lock));
 378                         return read_count ? read_count : -EINTR;
 379                 }
 380                 if (!rio->rio_dev) {
 381                         up(&(rio->lock));
 382                         return -ENODEV;
 383                 }
 384                 this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
 385
 386                 result = usb_bulk_msg(rio->rio_dev,
 387                                       usb_rcvbulkpipe(rio->rio_dev, 1),
 388                                       ibuf, this_read, &partial,
 389                                       (int) (HZ * 8));
 390
 391                 dbg(KERN_DEBUG "read stats: result:%d this_read:%u partial:%u",
 392                        result, this_read, partial);
 393
 394                 if (partial) {
 395                         count = this_read = partial;
 396                 } else if (result == -ETIMEDOUT || result == 15) {      /* FIXME: 15 ??? */
 397                         if (!maxretry--) {
 398                                 up(&(rio->lock));
 399                                 err("read_rio: maxretry timeout");
 400                                 return -ETIME;
 401                         }
 402                         interruptible_sleep_on_timeout(&rio->wait_q,
 403                                                        NAK_TIMEOUT);
 404                         continue;
 405                 } else if (result != -EREMOTEIO) {
 406                         up(&(rio->lock));
 407                         err("Read Whoops - result:%u partial:%u this_read:%u",
 408                              result, partial, this_read);
 409                         return -EIO;
 410                 } else {
 411                         up(&(rio->lock));
 412                         return (0);
 413                 }
 414
 415                 if (this_read) {
 416                         if (copy_to_user(buffer, ibuf, this_read)) {
 417                                 up(&(rio->lock));
 418                                 return -EFAULT;
 419                         }
 420                         count -= this_read;
 421                         read_count += this_read;
 422                         buffer += this_read;
 423                 }
 424         }
 425         up(&(rio->lock));
 426         return read_count;
 427 }
 428
 429 static struct
 430 file_operations usb_rio_fops = {
 431         .owner =        THIS_MODULE,
 432         .read =         read_rio,
 433         .write =        write_rio,
 434         .ioctl =        ioctl_rio,
 435         .open =         open_rio,
 436         .release =      close_rio,
 437 };
 438
 439 static struct usb_class_driver usb_rio_class = {
 440         .name =         "usb/rio500%d",
 441         .fops =         &usb_rio_fops,
 442         .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
 443         .minor_base =   RIO_MINOR,
 444 };
 445
 446 static int probe_rio(struct usb_interface *intf,
 447                      const struct usb_device_id *id)
 448 {
 449         struct usb_device *dev = interface_to_usbdev(intf);
 450         struct rio_usb_data *rio = &rio_instance;
 451         int retval;
 452
 453         info("USB Rio found at address %d", dev->devnum);
 454
 455         retval = usb_register_dev(intf, &usb_rio_class);
 456         if (retval) {
 457                 err("Not able to get a minor for this device.");
 458                 return -ENOMEM;
 459         }
 460
 461         rio->rio_dev = dev;
 462
 463         if (!(rio->obuf = (char *) kmalloc(OBUF_SIZE, GFP_KERNEL))) {
 464                 err("probe_rio: Not enough memory for the output buffer");
 465                 usb_deregister_dev(intf, &usb_rio_class);
 466                 return -ENOMEM;
 467         }
 468         dbg("probe_rio: obuf address:%p", rio->obuf);
 469
 470         if (!(rio->ibuf = (char *) kmalloc(IBUF_SIZE, GFP_KERNEL))) {
 471                 err("probe_rio: Not enough memory for the input buffer");
 472                 usb_deregister_dev(intf, &usb_rio_class);
 473                 kfree(rio->obuf);
 474                 return -ENOMEM;
 475         }
 476         dbg("probe_rio: ibuf address:%p", rio->ibuf);
 477
 478         init_MUTEX(&(rio->lock));
 479
 480         usb_set_intfdata (intf, rio);
 481         rio->present = 1;
 482
 483         return 0;
 484 }
 485
 486 static void disconnect_rio(struct usb_interface *intf)
 487 {
 488         struct rio_usb_data *rio = usb_get_intfdata (intf);
 489
 490         usb_set_intfdata (intf, NULL);
 491         if (rio) {
 492                 usb_deregister_dev(intf, &usb_rio_class);
 493
 494                 down(&(rio->lock));
 495                 if (rio->isopen) {
 496                         rio->isopen = 0;
 497                         /* better let it finish - the release will do whats needed */
 498                         rio->rio_dev = NULL;
 499                         up(&(rio->lock));
 500                         return;
 501                 }
 502                 kfree(rio->ibuf);
 503                 kfree(rio->obuf);
 504
 505                 info("USB Rio disconnected.");
 506
 507                 rio->present = 0;
 508                 up(&(rio->lock));
 509         }
 510 }
 511
 512 static struct usb_device_id rio_table [] = {
 513         { USB_DEVICE(0x0841, 1) },              /* Rio 500 */
 514         { }                                     /* Terminating entry */
 515 };
 516
 517 MODULE_DEVICE_TABLE (usb, rio_table);
 518
 519 static struct usb_driver rio_driver = {
 520         .owner =        THIS_MODULE,
 521         .name =         "rio500",
 522         .probe =        probe_rio,
 523         .disconnect =   disconnect_rio,
 524         .id_table =     rio_table,
 525 };
 526
 527 static int __init usb_rio_init(void)
 528 {
 529         int retval;
 530         retval = usb_register(&rio_driver);
 531         if (retval)
 532                 goto out;
 533
 534         info(DRIVER_VERSION ":" DRIVER_DESC);
 535
 536 out:
 537         return retval;
 538 }
 539
 540
 541 static void __exit usb_rio_cleanup(void)
 542 {
 543         struct rio_usb_data *rio = &rio_instance;
 544
 545         rio->present = 0;
 546         usb_deregister(&rio_driver);
 547
 548
 549 }
 550
 551 module_init(usb_rio_init);
 552 module_exit(usb_rio_cleanup);
 553
 554 MODULE_AUTHOR( DRIVER_AUTHOR );
 555 MODULE_DESCRIPTION( DRIVER_DESC );
 556 MODULE_LICENSE("GPL");
 557