drivers/staging/rspiusb/rspiusb.c

   1 /*
   2  * rspiusb.c
   3  *
   4  * Copyright (C) 2005, 2006 Princeton Instruments
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation version 2 of the License
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #include <linux/vmalloc.h>
  21 #include <linux/kernel.h>
  22 #include <linux/errno.h>
  23 #include <linux/init.h>
  24 #include <linux/slab.h>
  25 #include <linux/module.h>
  26 #include <linux/smp_lock.h>
  27 #include <linux/completion.h>
  28 #include <linux/scatterlist.h>
  29 #include <linux/usb.h>
  30 #include <linux/mm.h>
  31 #include <linux/pagemap.h>
  32 #include <linux/ioctl.h>
  33 #include "rspiusb.h"
  34
  35 #ifdef CONFIG_USB_DEBUG
  36 static int debug = 1;
  37 #else
  38 static int debug;
  39 #endif
  40 /* Use our own dbg macro */
  41 #undef dbg
  42 #define dbg(format, arg...) \
  43         do { \
  44                 if (debug) \
  45                         printk(KERN_DEBUG __FILE__ ": " format "\n" , ##arg); \
  46         } while (0)
  47
  48 /* Version Information */
  49 #define DRIVER_VERSION "V1.0.1"
  50 #define DRIVER_AUTHOR  "Princeton Instruments"
  51 #define DRIVER_DESC    "PI USB2.0 Device Driver for Linux"
  52
  53 /* Define these values to match your devices */
  54 #define VENDOR_ID   0x0BD7
  55 #define ST133_PID   0xA010
  56 #define PIXIS_PID   0xA026
  57
  58 /* Get a minor range for your devices from the usb maintainer */
  59 #ifdef CONFIG_USB_DYNAMIC_MINORS
  60 #define PIUSB_MINOR_BASE    0
  61 #else
  62 #define PIUSB_MINOR_BASE    192
  63 #endif
  64
  65 /* prevent races between open() and disconnect() */
  66 static DECLARE_MUTEX(disconnect_sem);
  67
  68 /* Structure to hold all of our device specific stuff */
  69 struct device_extension {
  70         struct usb_device *udev;         /* save off the usb device pointer */
  71         struct usb_interface *interface; /* the interface for this device */
  72         unsigned char minor;             /* the starting minor number
  73                                           * for this device
  74                                           */
  75         size_t bulk_in_size_returned;
  76         int bulk_in_byte_trk;
  77         struct urb ***PixelUrb;
  78         int frameIdx;
  79         int urbIdx;
  80         unsigned int *maplist_numPagesMapped;
  81         int open;                 /* if the port is open or not */
  82         int present;              /* if the device is not disconnected */
  83         int userBufMapped;        /* has the user buffer been mapped ? */
  84         struct scatterlist **sgl; /* scatter-gather list for user buffer */
  85         unsigned int *sgEntries;
  86         struct kref kref;
  87         int gotPixelData;
  88         int pendingWrite;
  89         char **pendedPixelUrbs;
  90         int iama;                /* PIXIS or ST133 */
  91         int num_frames;          /* the number of frames that will fit
  92                                   * in the user buffer
  93                                   */
  94         int active_frame;
  95         unsigned long frameSize;
  96         struct semaphore sem;
  97         unsigned int hEP[8];     /* FX2 specific endpoints */
  98 };
  99
 100 #define to_pi_dev(d) container_of(d, struct device_extension, kref)
 101
 102 /* Prototypes */
 103 static int MapUserBuffer(struct ioctl_struct *, struct device_extension *);
 104 static int UnMapUserBuffer(struct device_extension *);
 105 static int piusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 106                        unsigned long arg);
 107 static int piusb_output(struct ioctl_struct *, unsigned char *, int,
 108                 struct device_extension *);
 109 static struct usb_driver piusb_driver;
 110
 111 /* table of devices that work with this driver */
 112 static struct usb_device_id pi_device_table[] = {
 113         {USB_DEVICE(VENDOR_ID, ST133_PID)},
 114         {USB_DEVICE(VENDOR_ID, PIXIS_PID)},
 115         {0, } /* Terminating entry */
 116 };
 117
 118 MODULE_DEVICE_TABLE(usb, pi_device_table);
 119
 120 static int lastErr;
 121 static int errCnt;
 122
 123 static void piusb_delete(struct kref *kref)
 124 {
 125         struct device_extension *pdx = to_pi_dev(kref);
 126
 127         dev_dbg(&pdx->udev->dev, "%s\n", __func__);
 128         usb_put_dev(pdx->udev);
 129         kfree(pdx);
 130 }
 131
 132 static int piusb_open(struct inode *inode, struct file *file)
 133 {
 134         struct device_extension *pdx = NULL;
 135         struct usb_interface *interface;
 136         int subminor;
 137         int retval = 0;
 138
 139         dbg("Piusb_Open()");
 140         subminor = iminor(inode);
 141         interface = usb_find_interface(&piusb_driver, subminor);
 142         if (!interface) {
 143                 printk(KERN_ERR "%s - error, can't find device for minor %d\n",
 144                        __func__, subminor);
 145                 retval = -ENODEV;
 146                 goto exit_no_device;
 147         }
 148
 149         pdx = usb_get_intfdata(interface);
 150         if (!pdx) {
 151                 retval = -ENODEV;
 152                 goto exit_no_device;
 153         }
 154         dbg("Alternate Setting = %d", interface->num_altsetting);
 155
 156         pdx->bulk_in_size_returned = 0;
 157         pdx->bulk_in_byte_trk = 0;
 158         pdx->PixelUrb = NULL;
 159         pdx->frameIdx = 0;
 160         pdx->urbIdx = 0;
 161         pdx->maplist_numPagesMapped = NULL;
 162         pdx->userBufMapped = 0;
 163         pdx->sgl = NULL;
 164         pdx->sgEntries = NULL;
 165         pdx->gotPixelData = 0;
 166         pdx->pendingWrite = 0;
 167         pdx->pendedPixelUrbs = NULL;
 168         pdx->num_frames = 0;
 169         pdx->active_frame = 0;
 170         pdx->frameSize = 0;
 171
 172         /* increment our usage count for the device */
 173         kref_get(&pdx->kref);
 174
 175         /* save our object in the file's private structure */
 176         file->private_data = pdx;
 177
 178 exit_no_device:
 179         return retval;
 180 }
 181
 182 static int piusb_release(struct inode *inode, struct file *file)
 183 {
 184         struct device_extension *pdx;
 185         int retval = 0;
 186
 187         dbg("Piusb_Release()");
 188         pdx = (struct device_extension *)file->private_data;
 189         if (pdx == NULL) {
 190                 dbg("%s - object is NULL", __func__);
 191                 retval = -ENODEV;
 192                 goto object_null;
 193         }
 194         /* decrement the count on our device */
 195         kref_put(&pdx->kref, piusb_delete);
 196
 197 object_null:
 198         return retval;
 199 }
 200
 201 static int pixis_io(struct ioctl_struct *ctrl, struct device_extension *pdx,
 202                 struct ioctl_struct *arg)
 203 {
 204         unsigned int numToRead = 0;
 205         unsigned int totalRead = 0;
 206         unsigned char *uBuf;
 207         int numbytes;
 208         int i;
 209
 210         uBuf = kmalloc(ctrl->numbytes, GFP_KERNEL);
 211         if (!uBuf) {
 212                 dbg("Alloc for uBuf failed");
 213                 return 0;
 214         }
 215         numbytes = (int) ctrl->numbytes;
 216         numToRead = (unsigned int) ctrl->numbytes;
 217         dbg("numbytes to read = %d", numbytes);
 218         dbg("endpoint # %d", ctrl->endpoint);
 219
 220         if (copy_from_user(uBuf, ctrl->pData, numbytes)) {
 221                 dbg("copying ctrl->pData to dummyBuf failed");
 222                 return -EFAULT;
 223         }
 224
 225         do {
 226                 i = usb_bulk_msg(pdx->udev, pdx->hEP[ctrl->endpoint],
 227                                 (uBuf + totalRead),
 228                                 /* EP0 can only handle 64 bytes at a time */
 229                                 (numToRead > 64) ? 64 : numToRead,
 230                                 &numbytes, HZ * 10);
 231                 if (i) {
 232                         dbg("CMD = %s, Address = 0x%02X",
 233                                         ((uBuf[3] == 0x02) ? "WRITE" : "READ"),
 234                                         uBuf[1]);
 235                         dbg("Number of bytes Attempted to read = %d",
 236                                         (int)ctrl->numbytes);
 237                         dbg("Blocking ReadI/O Failed with status %d", i);
 238                         kfree(uBuf);
 239                         return -1;
 240                 }
 241                 dbg("Pixis EP0 Read %d bytes", numbytes);
 242                 totalRead += numbytes;
 243                 numToRead -= numbytes;
 244         } while (numToRead);
 245
 246         memcpy(ctrl->pData, uBuf, totalRead);
 247         dbg("Total Bytes Read from PIXIS EP0 = %d", totalRead);
 248         ctrl->numbytes = totalRead;
 249
 250         if (copy_to_user(arg, ctrl, sizeof(struct ioctl_struct)))
 251                 dbg("copy_to_user failed in IORB");
 252
 253         kfree(uBuf);
 254         return ctrl->numbytes;
 255 }
 256
 257 static int pixel_data(struct ioctl_struct *ctrl, struct device_extension *pdx)
 258 {
 259         int i;
 260
 261         if (!pdx->gotPixelData)
 262                 return 0;
 263
 264         pdx->gotPixelData = 0;
 265         ctrl->numbytes = pdx->bulk_in_size_returned;
 266         pdx->bulk_in_size_returned -= pdx->frameSize;
 267
 268         for (i = 0; i < pdx->maplist_numPagesMapped[pdx->active_frame]; i++)
 269                 SetPageDirty(sg_page(&pdx->sgl[pdx->active_frame][i]));
 270
 271         pdx->active_frame = ((pdx->active_frame + 1) % pdx->num_frames);
 272
 273         return ctrl->numbytes;
 274 }
 275
 276 /**
 277  *      piusb_ioctl
 278  */
 279 static int piusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 280                        unsigned long arg)
 281 {
 282         struct device_extension *pdx;
 283         char dummyCtlBuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 284         unsigned long devRB = 0;
 285         int err = 0;
 286         int retval = 0;
 287         struct ioctl_struct ctrl;
 288         unsigned short controlData = 0;
 289
 290         pdx = (struct device_extension *)file->private_data;
 291         /* verify that the device wasn't unplugged */
 292         if (!pdx->present) {
 293                 dbg("No Device Present\n");
 294                 return -ENODEV;
 295         }
 296         /* fill in your device specific stuff here */
 297         if (_IOC_DIR(cmd) & _IOC_READ)
 298                 err = !access_ok(VERIFY_WRITE, (void __user *)arg,
 299                                 _IOC_SIZE(cmd));
 300         else if (_IOC_DIR(cmd) & _IOC_WRITE)
 301                 err = !access_ok(VERIFY_READ, (void __user *)arg,
 302                                _IOC_SIZE(cmd));
 303         if (err) {
 304                 dev_err(&pdx->udev->dev, "return with error = %d\n", err);
 305                 return -EFAULT;
 306         }
 307         switch (cmd) {
 308         case PIUSB_GETVNDCMD:
 309                 if (__copy_from_user
 310                     (&ctrl, (void __user *)arg, sizeof(struct ioctl_struct))) {
 311                         dev_err(&pdx->udev->dev, "copy_from_user failed\n");
 312                         return -EFAULT;
 313                 }
 314                 dbg("%s %x\n", "Get Vendor Command = ", ctrl.cmd);
 315                 retval =
 316                     usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0),
 317                                     ctrl.cmd, USB_DIR_IN, 0, 0, &devRB,
 318                                     ctrl.numbytes, HZ * 10);
 319                 if (ctrl.cmd == 0xF1) {
 320                         dbg("FW Version returned from HW = %ld.%ld",
 321                             (devRB >> 8), (devRB & 0xFF));
 322                 }
 323                 if (retval >= 0)
 324                         retval = (int)devRB;
 325                 return retval;
 326
 327         case PIUSB_SETVNDCMD:
 328                 if (__copy_from_user
 329                     (&ctrl, (void __user *)arg, sizeof(struct ioctl_struct))) {
 330                         dev_err(&pdx->udev->dev, "copy_from_user failed\n");
 331                         return -EFAULT;
 332                 }
 333                 /* dbg( "%s %x", "Set Vendor Command = ",ctrl.cmd ); */
 334                 controlData = ctrl.pData[0];
 335                 controlData |= (ctrl.pData[1] << 8);
 336                 /* dbg( "%s %d", "Vendor Data =",controlData ); */
 337                 retval = usb_control_msg(pdx->udev,
 338                                 usb_sndctrlpipe(pdx->udev, 0),
 339                                 ctrl.cmd,
 340                                 (USB_DIR_OUT | USB_TYPE_VENDOR
 341                                  /* | USB_RECIP_ENDPOINT */),
 342                                 controlData, 0,
 343                                 &dummyCtlBuf, ctrl.numbytes, HZ * 10);
 344                 return retval;
 345
 346         case PIUSB_ISHIGHSPEED:
 347                 return ((pdx->udev->speed == USB_SPEED_HIGH) ? 1 : 0);
 348
 349         case PIUSB_WRITEPIPE:
 350                 if (__copy_from_user(&ctrl, (void __user *)arg, _IOC_SIZE(cmd))) {
 351                         dev_err(&pdx->udev->dev,
 352                                         "copy_from_user WRITE_DUMMY failed\n");
 353                         return -EFAULT;
 354                 }
 355                 if (!access_ok(VERIFY_READ, ctrl.pData, ctrl.numbytes)) {
 356                         dbg("can't access pData");
 357                         return 0;
 358                 }
 359                 piusb_output(&ctrl, ctrl.pData /* uBuf */, ctrl.numbytes, pdx);
 360                 return ctrl.numbytes;
 361
 362         case PIUSB_USERBUFFER:
 363                 if (__copy_from_user
 364                     (&ctrl, (void __user *)arg, sizeof(struct ioctl_struct))) {
 365                         dev_err(&pdx->udev->dev, "copy_from_user failed\n");
 366                         return -EFAULT;
 367                 }
 368                 return MapUserBuffer((struct ioctl_struct *) &ctrl, pdx);
 369
 370         case PIUSB_UNMAP_USERBUFFER:
 371                 retval = UnMapUserBuffer(pdx);
 372                 return retval;
 373
 374         case PIUSB_READPIPE:
 375                 if (__copy_from_user(&ctrl, (void __user *)arg,
 376                                         sizeof(struct ioctl_struct))) {
 377                         dev_err(&pdx->udev->dev, "copy_from_user failed\n");
 378                         return -EFAULT;
 379                 }
 380                 if (((0 == ctrl.endpoint) && (PIXIS_PID == pdx->iama)) ||
 381                                 (1 == ctrl.endpoint) || /* ST133IO */
 382                                 (4 == ctrl.endpoint))   /* PIXIS IO */
 383                         return pixis_io(&ctrl, pdx,
 384                                         (struct ioctl_struct *)arg);
 385                 else if ((0 == ctrl.endpoint) || /* ST133 Pixel Data */
 386                                 (2 == ctrl.endpoint) || /* PIXIS Ping */
 387                                 (3 == ctrl.endpoint))   /* PIXIS Pong */
 388                         return pixel_data(&ctrl, pdx);
 389
 390                 break;
 391
 392         case PIUSB_WHATCAMERA:
 393                 return pdx->iama;
 394
 395         case PIUSB_SETFRAMESIZE:
 396                 dbg("PIUSB_SETFRAMESIZE");
 397                 if (__copy_from_user
 398                     (&ctrl, (void __user *)arg, sizeof(struct ioctl_struct))) {
 399                         dev_err(&pdx->udev->dev, "copy_from_user failed\n");
 400                         return -EFAULT;
 401                 }
 402                 pdx->frameSize = ctrl.numbytes;
 403                 pdx->num_frames = ctrl.numFrames;
 404                 if (!pdx->sgl)
 405                         pdx->sgl =
 406                             kmalloc(sizeof(struct scatterlist *) *
 407                                     pdx->num_frames, GFP_KERNEL);
 408                 if (!pdx->sgEntries)
 409                         pdx->sgEntries =
 410                             kmalloc(sizeof(unsigned int) * pdx->num_frames,
 411                                     GFP_KERNEL);
 412                 if (!pdx->PixelUrb)
 413                         pdx->PixelUrb =
 414                             kmalloc(sizeof(struct urb **) * pdx->num_frames,
 415                                     GFP_KERNEL);
 416                 if (!pdx->maplist_numPagesMapped)
 417                         pdx->maplist_numPagesMapped =
 418                             vmalloc(sizeof(unsigned int) * pdx->num_frames);
 419                 if (!pdx->pendedPixelUrbs)
 420                         pdx->pendedPixelUrbs =
 421                             kmalloc(sizeof(char *) * pdx->num_frames,
 422                                     GFP_KERNEL);
 423                 return 0;
 424
 425         default:
 426                 dbg("%s\n", "No IOCTL found");
 427                 break;
 428
 429         }
 430         /* return that we did not understand this ioctl call */
 431         dbg("Returning -ENOTTY");
 432         return -ENOTTY;
 433 }
 434
 435 static void piusb_write_bulk_callback(struct urb *urb)
 436 {
 437         struct device_extension *pdx = urb->context;
 438         int status = urb->status;
 439
 440         /* sync/async unlink faults aren't errors */
 441         if (status && !(status == -ENOENT || status == -ECONNRESET))
 442                 dev_dbg(&urb->dev->dev,
 443                         "%s - nonzero write bulk status received: %d",
 444                         __func__, status);
 445
 446         pdx->pendingWrite = 0;
 447         kfree(urb->transfer_buffer);
 448 }
 449
 450 int piusb_output(struct ioctl_struct *io, unsigned char *uBuf, int len,
 451                  struct device_extension *pdx)
 452 {
 453         struct urb *urb = NULL;
 454         int err = 0;
 455         unsigned char *kbuf = NULL;
 456
 457         urb = usb_alloc_urb(0, GFP_KERNEL);
 458         if (urb != NULL) {
 459                 kbuf = kmalloc(len, GFP_KERNEL);
 460                 if (!kbuf) {
 461                         dev_err(&pdx->udev->dev, "buffer_alloc failed\n");
 462                         return -ENOMEM;
 463                 }
 464                 if(__copy_from_user(kbuf, uBuf, len)) {
 465                         dev_err(&pdx->udev->dev, "__copy_from_user failed\n");
 466                         return -EFAULT;
 467                 }
 468                 usb_fill_bulk_urb(urb, pdx->udev, pdx->hEP[io->endpoint], kbuf,
 469                                   len, piusb_write_bulk_callback, pdx);
 470                 err = usb_submit_urb(urb, GFP_KERNEL);
 471                 if (err) {
 472                         dev_err(&pdx->udev->dev,
 473                                 "WRITE ERROR:submit urb error = %d\n", err);
 474                 }
 475                 pdx->pendingWrite = 1;
 476                 usb_free_urb(urb);
 477         }
 478         return -EINPROGRESS;
 479 }
 480
 481 static int UnMapUserBuffer(struct device_extension *pdx)
 482 {
 483         int i = 0;
 484         int k = 0;
 485         unsigned int epAddr;
 486
 487         for (k = 0; k < pdx->num_frames; k++) {
 488                 dbg("Killing Urbs for Frame %d", k);
 489                 for (i = 0; i < pdx->sgEntries[k]; i++) {
 490                         usb_kill_urb(pdx->PixelUrb[k][i]);
 491                         usb_free_urb(pdx->PixelUrb[k][i]);
 492                         pdx->pendedPixelUrbs[k][i] = 0;
 493                 }
 494                 dbg("Urb error count = %d", errCnt);
 495                 errCnt = 0;
 496                 dbg("Urbs free'd and Killed for Frame %d", k);
 497         }
 498
 499         for (k = 0; k < pdx->num_frames; k++) {
 500                 if (pdx->iama == PIXIS_PID)
 501                         /* which EP should we map this frame to ? */
 502                         /* PONG, odd frames: hEP[3] */
 503                         /* PING, even frames and zero hEP[2] */
 504                         epAddr = (k % 2) ? pdx->hEP[3] : pdx->hEP[2];
 505                 else
 506                         /* ST133 only has 1 endpoint for Pixel data transfer */
 507                         epAddr = pdx->hEP[0];
 508
 509                 usb_buffer_unmap_sg(pdx->udev, epAddr, pdx->sgl[k],
 510                                     pdx->maplist_numPagesMapped[k]);
 511                 for (i = 0; i < pdx->maplist_numPagesMapped[k]; i++)
 512                         page_cache_release(sg_page(&pdx->sgl[k][i]));
 513                 kfree(pdx->sgl[k]);
 514                 kfree(pdx->PixelUrb[k]);
 515                 kfree(pdx->pendedPixelUrbs[k]);
 516                 pdx->sgl[k] = NULL;
 517                 pdx->PixelUrb[k] = NULL;
 518                 pdx->pendedPixelUrbs[k] = NULL;
 519         }
 520
 521         kfree(pdx->sgEntries);
 522         vfree(pdx->maplist_numPagesMapped);
 523         pdx->sgEntries = NULL;
 524         pdx->maplist_numPagesMapped = NULL;
 525         kfree(pdx->sgl);
 526         kfree(pdx->pendedPixelUrbs);
 527         kfree(pdx->PixelUrb);
 528         pdx->sgl = NULL;
 529         pdx->pendedPixelUrbs = NULL;
 530         pdx->PixelUrb = NULL;
 531
 532         return 0;
 533 }
 534
 535 static void piusb_readPIXEL_callback(struct urb *urb)
 536 {
 537         int i = 0;
 538         struct device_extension *pdx = urb->context;
 539         int status = urb->status;
 540
 541         if (status && !(status == -ENOENT || status == -ECONNRESET)) {
 542                 dbg("%s - nonzero read bulk status received: %d", __func__,
 543                     status);
 544                 dbg("Error in read EP2 callback");
 545                 dbg("FrameIndex = %d", pdx->frameIdx);
 546                 dbg("Bytes received before problem occurred = %d",
 547                     pdx->bulk_in_byte_trk);
 548                 dbg("Urb Idx = %d", pdx->urbIdx);
 549                 pdx->pendedPixelUrbs[pdx->frameIdx][pdx->urbIdx] = 0;
 550         } else {
 551                 pdx->bulk_in_byte_trk += urb->actual_length;
 552                 i = usb_submit_urb(urb, GFP_ATOMIC);    /* resubmit the URB */
 553                 if (i) {
 554                         errCnt++;
 555                         if (i != lastErr) {
 556                                 dbg("submit urb in callback failed "
 557                                                 "with error code %d", i);
 558                                 lastErr = i;
 559                         }
 560                 } else {
 561                         pdx->urbIdx++; /* point to next URB when we callback */
 562                         if (pdx->bulk_in_byte_trk >= pdx->frameSize) {
 563                                 pdx->bulk_in_size_returned =
 564                                         pdx->bulk_in_byte_trk;
 565                                 pdx->bulk_in_byte_trk = 0;
 566                                 pdx->gotPixelData = 1;
 567                                 pdx->frameIdx =
 568                                         ((pdx->frameIdx +
 569                                           1) % pdx->num_frames);
 570                                 pdx->urbIdx = 0;
 571                         }
 572                 }
 573         }
 574 }
 575
 576 /* MapUserBuffer(
 577         inputs:
 578         struct ioctl_struct *io - structure containing user address,
 579                                 frame #, and size
 580         struct device_extension *pdx - the PIUSB device extension
 581
 582         returns:
 583         int - status of the task
 584
 585         Notes:
 586         MapUserBuffer maps a buffer passed down through an ioctl.
 587         The user buffer is Page Aligned by the app and then passed down.
 588         The function get_free_pages(...) does the actual mapping of the buffer
 589         from user space to kernel space.
 590         From there a scatterlist is created from all the pages.
 591         The next function called is to usb_buffer_map_sg which allocated
 592         DMA addresses for each page, even coalescing them if possible.
 593         The DMA address is placed in the scatterlist structure.
 594         The function returns the number of DMA addresses.
 595         This may or may not be equal to the number of pages that
 596         the user buffer uses.
 597         We then build an URB for each DMA address and then submit them.
 598 */
 599
 600 /*
 601 int MapUserBuffer(unsigned long uaddr, unsigned long numbytes,
 602                 unsigned long frameInfo, struct device_extension *pdx)
 603 */
 604 static int MapUserBuffer(struct ioctl_struct *io, struct device_extension *pdx)
 605 {
 606         unsigned long uaddr;
 607         unsigned long numbytes;
 608         int frameInfo;  /* which frame we're mapping */
 609         unsigned int epAddr = 0;
 610         unsigned long count = 0;
 611         int i = 0;
 612         int k = 0;
 613         int err = 0;
 614         struct page **maplist_p;
 615         int numPagesRequired;
 616
 617         frameInfo = io->numFrames;
 618         uaddr = (unsigned long)io->pData;
 619         numbytes = io->numbytes;
 620
 621         if (pdx->iama == PIXIS_PID) {
 622                 /* which EP should we map this frame to ? */
 623                 /* PONG, odd frames: hEP[3] */
 624                 /* PING, even frames and zero hEP[2] */
 625                 epAddr = (frameInfo % 2) ? pdx->hEP[3] : pdx->hEP[2];
 626                 dbg("Pixis Frame #%d: EP=%d", frameInfo,
 627                     (epAddr == pdx->hEP[2]) ? 2 : 4);
 628         } else { /* ST133 only has 1 endpoint for Pixel data transfer */
 629                 epAddr = pdx->hEP[0];
 630                 dbg("ST133 Frame #%d: EP=2", frameInfo);
 631         }
 632         count = numbytes;
 633         dbg("UserAddress = 0x%08lX", uaddr);
 634         dbg("numbytes = %d", (int)numbytes);
 635
 636         /* number of pages to map the entire user space DMA buffer */
 637         numPagesRequired =
 638             ((uaddr & ~PAGE_MASK) + count + ~PAGE_MASK) >> PAGE_SHIFT;
 639         dbg("Number of pages needed = %d", numPagesRequired);
 640         maplist_p = vmalloc(numPagesRequired * sizeof(struct page *));
 641         if (!maplist_p) {
 642                 dbg("Can't Allocate Memory for maplist_p");
 643                 return -ENOMEM;
 644         }
 645
 646         /* map the user buffer to kernel memory */
 647         down_write(&current->mm->mmap_sem);
 648         pdx->maplist_numPagesMapped[frameInfo] = get_user_pages(current,
 649                         current->mm, (uaddr & PAGE_MASK), numPagesRequired,
 650                         WRITE, 0 /* Don't Force*/, maplist_p, NULL);
 651         up_write(&current->mm->mmap_sem);
 652         dbg("Number of pages mapped = %d",
 653             pdx->maplist_numPagesMapped[frameInfo]);
 654
 655         for (i = 0; i < pdx->maplist_numPagesMapped[frameInfo]; i++)
 656                 flush_dcache_page(maplist_p[i]);
 657         if (!pdx->maplist_numPagesMapped[frameInfo]) {
 658                 dbg("get_user_pages() failed");
 659                 vfree(maplist_p);
 660                 return -ENOMEM;
 661         }
 662
 663         /* need to create a scatterlist that spans each frame
 664          * that can fit into the mapped buffer
 665          */
 666         pdx->sgl[frameInfo] =
 667             kmalloc((pdx->maplist_numPagesMapped[frameInfo] *
 668                      sizeof(struct scatterlist)), GFP_ATOMIC);
 669         if (!pdx->sgl[frameInfo]) {
 670                 vfree(maplist_p);
 671                 dbg("can't allocate mem for sgl");
 672                 return -ENOMEM;
 673         }
 674         sg_assign_page(&pdx->sgl[frameInfo][0], maplist_p[0]);
 675         pdx->sgl[frameInfo][0].offset = uaddr & ~PAGE_MASK;
 676         if (pdx->maplist_numPagesMapped[frameInfo] > 1) {
 677                 pdx->sgl[frameInfo][0].length =
 678                     PAGE_SIZE - pdx->sgl[frameInfo][0].offset;
 679                 count -= pdx->sgl[frameInfo][0].length;
 680                 for (k = 1; k < pdx->maplist_numPagesMapped[frameInfo]; k++) {
 681                         pdx->sgl[frameInfo][k].offset = 0;
 682                         sg_assign_page(&pdx->sgl[frameInfo][k], maplist_p[k]);
 683                         pdx->sgl[frameInfo][k].length =
 684                             (count < PAGE_SIZE) ? count : PAGE_SIZE;
 685                         count -= PAGE_SIZE; /* example had PAGE_SIZE here */
 686                 }
 687         } else {
 688                 pdx->sgl[frameInfo][0].length = count;
 689         }
 690         pdx->sgEntries[frameInfo] =
 691             usb_buffer_map_sg(pdx->udev, epAddr, pdx->sgl[frameInfo],
 692                               pdx->maplist_numPagesMapped[frameInfo]);
 693         dbg("number of sgEntries = %d", pdx->sgEntries[frameInfo]);
 694         pdx->userBufMapped = 1;
 695         vfree(maplist_p);
 696
 697         /* Create and Send the URB's for each s/g entry */
 698         pdx->PixelUrb[frameInfo] =
 699             kmalloc(pdx->sgEntries[frameInfo] * sizeof(struct urb *),
 700                     GFP_KERNEL);
 701         if (!pdx->PixelUrb[frameInfo]) {
 702                 dbg("Can't Allocate Memory for Urb");
 703                 return -ENOMEM;
 704         }
 705         for (i = 0; i < pdx->sgEntries[frameInfo]; i++) {
 706                 /* 0 iso packets because we're using BULK transfers */
 707                 pdx->PixelUrb[frameInfo][i] = usb_alloc_urb(0, GFP_KERNEL);
 708                 usb_fill_bulk_urb(pdx->PixelUrb[frameInfo][i],
 709                                   pdx->udev,
 710                                   epAddr,
 711                                   NULL, // non-DMA HC? buy a better hardware
 712                                   sg_dma_len(&pdx->sgl[frameInfo][i]),
 713                                   piusb_readPIXEL_callback, (void *)pdx);
 714                 pdx->PixelUrb[frameInfo][i]->transfer_dma =
 715                     sg_dma_address(&pdx->sgl[frameInfo][i]);
 716                 pdx->PixelUrb[frameInfo][i]->transfer_flags =
 717                     URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT;
 718         }
 719         if (i == 0)
 720                 return -EINVAL;
 721         /* only interrupt when last URB completes */
 722         pdx->PixelUrb[frameInfo][--i]->transfer_flags &= ~URB_NO_INTERRUPT;
 723         pdx->pendedPixelUrbs[frameInfo] =
 724             kmalloc((pdx->sgEntries[frameInfo] * sizeof(char)), GFP_KERNEL);
 725         if (!pdx->pendedPixelUrbs[frameInfo])
 726                 dbg("Can't allocate Memory for pendedPixelUrbs");
 727         for (i = 0; i < pdx->sgEntries[frameInfo]; i++) {
 728                 err = usb_submit_urb(pdx->PixelUrb[frameInfo][i], GFP_ATOMIC);
 729                 if (err) {
 730                         dbg("%s %d\n", "submit urb error =", err);
 731                         pdx->pendedPixelUrbs[frameInfo][i] = 0;
 732                         return err;
 733                 }
 734                 pdx->pendedPixelUrbs[frameInfo][i] = 1;
 735         }
 736         return 0;
 737 }
 738
 739 static const struct file_operations piusb_fops = {
 740         .owner = THIS_MODULE,
 741         .ioctl = piusb_ioctl,
 742         .open = piusb_open,
 743         .release = piusb_release,
 744 };
 745
 746 static struct usb_class_driver piusb_class = {
 747         .name = "usb/rspiusb%d",
 748         .fops = &piusb_fops,
 749         .minor_base = PIUSB_MINOR_BASE,
 750 };
 751
 752 /**
 753  *      piusb_probe
 754  *
 755  *      Called by the usb core when a new device is connected that it thinks
 756  *      this driver might be interested in.
 757  */
 758 static int piusb_probe(struct usb_interface *interface,
 759                        const struct usb_device_id *id)
 760 {
 761         struct device_extension *pdx = NULL;
 762         struct usb_host_interface *iface_desc;
 763         struct usb_endpoint_descriptor *endpoint;
 764         int i;
 765         int retval = -ENOMEM;
 766
 767         dev_dbg(&interface->dev, "%s - Looking for PI USB Hardware", __func__);
 768
 769         pdx = kzalloc(sizeof(struct device_extension), GFP_KERNEL);
 770         if (pdx == NULL) {
 771                 dev_err(&interface->dev, "Out of memory\n");
 772                 goto error;
 773         }
 774         kref_init(&pdx->kref);
 775         pdx->udev = usb_get_dev(interface_to_usbdev(interface));
 776         pdx->interface = interface;
 777         iface_desc = interface->cur_altsetting;
 778
 779         /* See if the device offered us matches what we can accept */
 780         if ((pdx->udev->descriptor.idVendor != VENDOR_ID)
 781             || ((pdx->udev->descriptor.idProduct != PIXIS_PID)
 782                 && (pdx->udev->descriptor.idProduct != ST133_PID)))
 783                 return -ENODEV;
 784
 785         pdx->iama = pdx->udev->descriptor.idProduct;
 786
 787         if (debug) {
 788                 if (pdx->udev->descriptor.idProduct == PIXIS_PID)
 789                         dbg("PIUSB:Pixis Camera Found");
 790                 else
 791                         dbg("PIUSB:ST133 USB Controller Found");
 792                 if (pdx->udev->speed == USB_SPEED_HIGH)
 793                         dbg("Highspeed(USB2.0) Device Attached");
 794                 else
 795                         dbg("Lowspeed (USB1.1) Device Attached");
 796
 797                 dbg("NumEndpoints in Configuration: %d",
 798                     iface_desc->desc.bNumEndpoints);
 799         }
 800         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 801                 endpoint = &iface_desc->endpoint[i].desc;
 802                 if (debug) {
 803                         dbg("Endpoint[%d]->bDescriptorType = %d", i,
 804                             endpoint->bDescriptorType);
 805                         dbg("Endpoint[%d]->bEndpointAddress = 0x%02X", i,
 806                             endpoint->bEndpointAddress);
 807                         dbg("Endpoint[%d]->bbmAttributes = %d", i,
 808                             endpoint->bmAttributes);
 809                         dbg("Endpoint[%d]->MaxPacketSize = %d\n", i,
 810                             endpoint->wMaxPacketSize);
 811                 }
 812                 if (usb_endpoint_xfer_bulk(endpoint)) {
 813                         if (usb_endpoint_dir_in(endpoint))
 814                                 pdx->hEP[i] =
 815                                     usb_rcvbulkpipe(pdx->udev,
 816                                                     endpoint->bEndpointAddress);
 817                         else
 818                                 pdx->hEP[i] =
 819                                     usb_sndbulkpipe(pdx->udev,
 820                                                     endpoint->bEndpointAddress);
 821                 }
 822         }
 823         usb_set_intfdata(interface, pdx);
 824         retval = usb_register_dev(interface, &piusb_class);
 825         if (retval) {
 826                 err("Not able to get a minor for this device.");
 827                 usb_set_intfdata(interface, NULL);
 828                 goto error;
 829         }
 830         pdx->present = 1;
 831
 832         /* we can register the device now, as it is ready */
 833         pdx->minor = interface->minor;
 834         /* let the user know what node this device is now attached to */
 835         dbg("PI USB2.0 device now attached to piusb-%d", pdx->minor);
 836         return 0;
 837
 838 error:
 839         if (pdx)
 840                 kref_put(&pdx->kref, piusb_delete);
 841         return retval;
 842 }
 843
 844 /**
 845  *      piusb_disconnect
 846  *
 847  *      Called by the usb core when the device is removed from the system.
 848  *
 849  *      This routine guarantees that the driver will not submit any more urbs
 850  *      by clearing pdx->udev.  It is also supposed to terminate any currently
 851  *      active urbs.  Unfortunately, usb_bulk_msg(), used in piusb_read(), does
 852  *      not provide any way to do this.  But at least we can cancel an active
 853  *      write.
 854  */
 855 static void piusb_disconnect(struct usb_interface *interface)
 856 {
 857         struct device_extension *pdx;
 858         int minor = interface->minor;
 859
 860         lock_kernel();
 861
 862         pdx = usb_get_intfdata(interface);
 863         usb_set_intfdata(interface, NULL);
 864
 865         /* give back our minor */
 866         usb_deregister_dev(interface, &piusb_class);
 867
 868         unlock_kernel();
 869
 870         /* prevent device read, write and ioctl */
 871         pdx->present = 0;
 872         kref_put(&pdx->kref, piusb_delete);
 873         dbg("PI USB2.0 device #%d now disconnected\n", minor);
 874 }
 875
 876 static struct usb_driver piusb_driver = {
 877         .name = "sub",
 878         .probe = piusb_probe,
 879         .disconnect = piusb_disconnect,
 880         .id_table = pi_device_table,
 881 };
 882
 883 /**
 884  *      piusb_init
 885  */
 886 static int __init piusb_init(void)
 887 {
 888         int result;
 889
 890         lastErr = 0;
 891         errCnt = 0;
 892
 893         /* register this driver with the USB subsystem */
 894         result = usb_register(&piusb_driver);
 895         if (result)
 896                 printk(KERN_ERR KBUILD_MODNAME
 897                                 ": usb_register failed. Error number %d\n",
 898                                 result);
 899         else
 900                 printk(KERN_INFO KBUILD_MODNAME ":%s: %s\n", DRIVER_DESC,
 901                                 DRIVER_VERSION);
 902         return result;
 903 }
 904
 905 /**
 906  *      piusb_exit
 907  */
 908 static void __exit piusb_exit(void)
 909 {
 910         /* deregister this driver with the USB subsystem */
 911         usb_deregister(&piusb_driver);
 912 }
 913
 914 module_init(piusb_init);
 915 module_exit(piusb_exit);
 916
 917 /* Module parameters */
 918 module_param(debug, int, 0);
 919 MODULE_PARM_DESC(debug, "Debug enabled or not");
 920
 921 MODULE_AUTHOR(DRIVER_AUTHOR);
 922 MODULE_DESCRIPTION(DRIVER_DESC);
 923 MODULE_LICENSE("GPL v2");