4 * Copyright (C) 2005, 2006 Princeton Instruments
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
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.
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.
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>
31 #include <linux/pagemap.h>
32 #include <linux/ioctl.h>
35 #ifdef CONFIG_USB_DEBUG
40 /* Use our own dbg macro */
42 #define dbg(format, arg...) \
45 printk(KERN_DEBUG __FILE__ ": " format "\n" , ##arg); \
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"
53 /* Define these values to match your devices */
54 #define VENDOR_ID 0x0BD7
55 #define ST133_PID 0xA010
56 #define PIXIS_PID 0xA026
58 /* Get a minor range for your devices from the usb maintainer */
59 #ifdef CONFIG_USB_DYNAMIC_MINORS
60 #define PIUSB_MINOR_BASE 0
62 #define PIUSB_MINOR_BASE 192
65 /* prevent races between open() and disconnect() */
66 static DECLARE_MUTEX(disconnect_sem);
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
75 size_t bulk_in_size_returned;
77 struct urb ***PixelUrb;
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;
89 char **pendedPixelUrbs;
90 int iama; /* PIXIS or ST133 */
91 int num_frames; /* the number of frames that will fit
95 unsigned long frameSize;
97 unsigned int hEP[8]; /* FX2 specific endpoints */
100 #define to_pi_dev(d) container_of(d, struct device_extension, kref)
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,
107 static int piusb_output(struct ioctl_struct *, unsigned char *, int,
108 struct device_extension *);
109 static struct usb_driver piusb_driver;
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 */
118 MODULE_DEVICE_TABLE(usb, pi_device_table);
123 static void piusb_delete(struct kref *kref)
125 struct device_extension *pdx = to_pi_dev(kref);
127 dev_dbg(&pdx->udev->dev, "%s\n", __func__);
128 usb_put_dev(pdx->udev);
132 static int piusb_open(struct inode *inode, struct file *file)
134 struct device_extension *pdx = NULL;
135 struct usb_interface *interface;
140 subminor = iminor(inode);
141 interface = usb_find_interface(&piusb_driver, subminor);
143 printk(KERN_ERR "%s - error, can't find device for minor %d\n",
149 pdx = usb_get_intfdata(interface);
154 dbg("Alternate Setting = %d", interface->num_altsetting);
156 pdx->bulk_in_size_returned = 0;
157 pdx->bulk_in_byte_trk = 0;
158 pdx->PixelUrb = NULL;
161 pdx->maplist_numPagesMapped = NULL;
162 pdx->userBufMapped = 0;
164 pdx->sgEntries = NULL;
165 pdx->gotPixelData = 0;
166 pdx->pendingWrite = 0;
167 pdx->pendedPixelUrbs = NULL;
169 pdx->active_frame = 0;
172 /* increment our usage count for the device */
173 kref_get(&pdx->kref);
175 /* save our object in the file's private structure */
176 file->private_data = pdx;
182 static int piusb_release(struct inode *inode, struct file *file)
184 struct device_extension *pdx;
187 dbg("Piusb_Release()");
188 pdx = (struct device_extension *)file->private_data;
190 dbg("%s - object is NULL", __func__);
194 /* decrement the count on our device */
195 kref_put(&pdx->kref, piusb_delete);
201 static int pixis_io(struct ioctl_struct *ctrl, struct device_extension *pdx,
202 struct ioctl_struct *arg)
204 unsigned int numToRead = 0;
205 unsigned int totalRead = 0;
210 uBuf = kmalloc(ctrl->numbytes, GFP_KERNEL);
212 dbg("Alloc for uBuf failed");
215 numbytes = (int) ctrl->numbytes;
216 numToRead = (unsigned int) ctrl->numbytes;
217 dbg("numbytes to read = %d", numbytes);
218 dbg("endpoint # %d", ctrl->endpoint);
220 if (copy_from_user(uBuf, ctrl->pData, numbytes))
221 dbg("copying ctrl->pData to dummyBuf failed");
224 i = usb_bulk_msg(pdx->udev, pdx->hEP[ctrl->endpoint],
226 /* EP0 can only handle 64 bytes at a time */
227 (numToRead > 64) ? 64 : numToRead,
230 dbg("CMD = %s, Address = 0x%02X",
231 ((uBuf[3] == 0x02) ? "WRITE" : "READ"),
233 dbg("Number of bytes Attempted to read = %d",
234 (int)ctrl->numbytes);
235 dbg("Blocking ReadI/O Failed with status %d", i);
239 dbg("Pixis EP0 Read %d bytes", numbytes);
240 totalRead += numbytes;
241 numToRead -= numbytes;
244 memcpy(ctrl->pData, uBuf, totalRead);
245 dbg("Total Bytes Read from PIXIS EP0 = %d", totalRead);
246 ctrl->numbytes = totalRead;
248 if (copy_to_user(arg, ctrl, sizeof(struct ioctl_struct)))
249 dbg("copy_to_user failed in IORB");
252 return ctrl->numbytes;
255 static int pixel_data(struct ioctl_struct *ctrl, struct device_extension *pdx)
259 if (!pdx->gotPixelData)
262 pdx->gotPixelData = 0;
263 ctrl->numbytes = pdx->bulk_in_size_returned;
264 pdx->bulk_in_size_returned -= pdx->frameSize;
266 for (i = 0; i < pdx->maplist_numPagesMapped[pdx->active_frame]; i++)
267 SetPageDirty(sg_page(&pdx->sgl[pdx->active_frame][i]));
269 pdx->active_frame = ((pdx->active_frame + 1) % pdx->num_frames);
271 return ctrl->numbytes;
277 static int piusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
280 struct device_extension *pdx;
281 char dummyCtlBuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
282 unsigned long devRB = 0;
285 struct ioctl_struct ctrl;
286 unsigned short controlData = 0;
288 pdx = (struct device_extension *)file->private_data;
289 /* verify that the device wasn't unplugged */
291 dbg("No Device Present\n");
294 /* fill in your device specific stuff here */
295 if (_IOC_DIR(cmd) & _IOC_READ)
296 err = !access_ok(VERIFY_WRITE, (void __user *)arg,
298 else if (_IOC_DIR(cmd) & _IOC_WRITE)
299 err = !access_ok(VERIFY_READ, (void __user *)arg,
302 dev_err(&pdx->udev->dev, "return with error = %d\n", err);
306 case PIUSB_GETVNDCMD:
308 (&ctrl, (void __user *)arg, sizeof(struct ioctl_struct)))
309 dev_err(&pdx->udev->dev, "copy_from_user failed\n");
310 dbg("%s %x\n", "Get Vendor Command = ", ctrl.cmd);
312 usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0),
313 ctrl.cmd, USB_DIR_IN, 0, 0, &devRB,
314 ctrl.numbytes, HZ * 10);
315 if (ctrl.cmd == 0xF1) {
316 dbg("FW Version returned from HW = %ld.%ld",
317 (devRB >> 8), (devRB & 0xFF));
323 case PIUSB_SETVNDCMD:
325 (&ctrl, (void __user *)arg, sizeof(struct ioctl_struct)))
326 dev_err(&pdx->udev->dev, "copy_from_user failed\n");
327 /* dbg( "%s %x", "Set Vendor Command = ",ctrl.cmd ); */
328 controlData = ctrl.pData[0];
329 controlData |= (ctrl.pData[1] << 8);
330 /* dbg( "%s %d", "Vendor Data =",controlData ); */
331 retval = usb_control_msg(pdx->udev,
332 usb_sndctrlpipe(pdx->udev, 0),
334 (USB_DIR_OUT | USB_TYPE_VENDOR
335 /* | USB_RECIP_ENDPOINT */),
337 &dummyCtlBuf, ctrl.numbytes, HZ * 10);
340 case PIUSB_ISHIGHSPEED:
341 return ((pdx->udev->speed == USB_SPEED_HIGH) ? 1 : 0);
343 case PIUSB_WRITEPIPE:
344 if (copy_from_user(&ctrl, (void __user *)arg, _IOC_SIZE(cmd)))
345 dev_err(&pdx->udev->dev,
346 "copy_from_user WRITE_DUMMY failed\n");
347 if (!access_ok(VERIFY_READ, ctrl.pData, ctrl.numbytes)) {
348 dbg("can't access pData");
351 piusb_output(&ctrl, ctrl.pData /* uBuf */, ctrl.numbytes, pdx);
352 return ctrl.numbytes;
354 case PIUSB_USERBUFFER:
356 (&ctrl, (void __user *)arg, sizeof(struct ioctl_struct)))
357 dev_err(&pdx->udev->dev, "copy_from_user failed\n");
358 return MapUserBuffer((struct ioctl_struct *) &ctrl, pdx);
360 case PIUSB_UNMAP_USERBUFFER:
361 retval = UnMapUserBuffer(pdx);
365 if (copy_from_user(&ctrl, (void __user *)arg,
366 sizeof(struct ioctl_struct)))
367 dev_err(&pdx->udev->dev, "copy_from_user failed\n");
369 if (((0 == ctrl.endpoint) && (PIXIS_PID == pdx->iama)) ||
370 (1 == ctrl.endpoint) || /* ST133IO */
371 (4 == ctrl.endpoint)) /* PIXIS IO */
372 return pixis_io(&ctrl, pdx,
373 (struct ioctl_struct *)arg);
374 else if ((0 == ctrl.endpoint) || /* ST133 Pixel Data */
375 (2 == ctrl.endpoint) || /* PIXIS Ping */
376 (3 == ctrl.endpoint)) /* PIXIS Pong */
377 return pixel_data(&ctrl, pdx);
381 case PIUSB_WHATCAMERA:
384 case PIUSB_SETFRAMESIZE:
385 dbg("PIUSB_SETFRAMESIZE");
387 (&ctrl, (void __user *)arg, sizeof(struct ioctl_struct)))
388 dev_err(&pdx->udev->dev, "copy_from_user failed\n");
389 pdx->frameSize = ctrl.numbytes;
390 pdx->num_frames = ctrl.numFrames;
393 kmalloc(sizeof(struct scatterlist *) *
394 pdx->num_frames, GFP_KERNEL);
397 kmalloc(sizeof(unsigned int) * pdx->num_frames,
401 kmalloc(sizeof(struct urb **) * pdx->num_frames,
403 if (!pdx->maplist_numPagesMapped)
404 pdx->maplist_numPagesMapped =
405 vmalloc(sizeof(unsigned int) * pdx->num_frames);
406 if (!pdx->pendedPixelUrbs)
407 pdx->pendedPixelUrbs =
408 kmalloc(sizeof(char *) * pdx->num_frames,
413 dbg("%s\n", "No IOCTL found");
417 /* return that we did not understand this ioctl call */
418 dbg("Returning -ENOTTY");
422 static void piusb_write_bulk_callback(struct urb *urb)
424 struct device_extension *pdx = urb->context;
425 int status = urb->status;
427 /* sync/async unlink faults aren't errors */
428 if (status && !(status == -ENOENT || status == -ECONNRESET))
429 dev_dbg(&urb->dev->dev,
430 "%s - nonzero write bulk status received: %d",
433 pdx->pendingWrite = 0;
434 usb_buffer_free(urb->dev, urb->transfer_buffer_length,
435 urb->transfer_buffer, urb->transfer_dma);
438 int piusb_output(struct ioctl_struct *io, unsigned char *uBuf, int len,
439 struct device_extension *pdx)
441 struct urb *urb = NULL;
443 unsigned char *kbuf = NULL;
445 urb = usb_alloc_urb(0, GFP_KERNEL);
448 usb_buffer_alloc(pdx->udev, len, GFP_KERNEL,
451 dev_err(&pdx->udev->dev, "buffer_alloc failed\n");
454 memcpy(kbuf, uBuf, len);
455 usb_fill_bulk_urb(urb, pdx->udev, pdx->hEP[io->endpoint], kbuf,
456 len, piusb_write_bulk_callback, pdx);
457 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
458 err = usb_submit_urb(urb, GFP_KERNEL);
460 dev_err(&pdx->udev->dev,
461 "WRITE ERROR:submit urb error = %d\n", err);
463 pdx->pendingWrite = 1;
469 static int UnMapUserBuffer(struct device_extension *pdx)
475 for (k = 0; k < pdx->num_frames; k++) {
476 dbg("Killing Urbs for Frame %d", k);
477 for (i = 0; i < pdx->sgEntries[k]; i++) {
478 usb_kill_urb(pdx->PixelUrb[k][i]);
479 usb_free_urb(pdx->PixelUrb[k][i]);
480 pdx->pendedPixelUrbs[k][i] = 0;
482 dbg("Urb error count = %d", errCnt);
484 dbg("Urbs free'd and Killed for Frame %d", k);
487 for (k = 0; k < pdx->num_frames; k++) {
488 if (pdx->iama == PIXIS_PID)
489 /* which EP should we map this frame to ? */
490 /* PONG, odd frames: hEP[3] */
491 /* PING, even frames and zero hEP[2] */
492 epAddr = (k % 2) ? pdx->hEP[3] : pdx->hEP[2];
494 /* ST133 only has 1 endpoint for Pixel data transfer */
495 epAddr = pdx->hEP[0];
497 usb_buffer_unmap_sg(pdx->udev, epAddr, pdx->sgl[k],
498 pdx->maplist_numPagesMapped[k]);
499 for (i = 0; i < pdx->maplist_numPagesMapped[k]; i++)
500 page_cache_release(sg_page(&pdx->sgl[k][i]));
502 kfree(pdx->PixelUrb[k]);
503 kfree(pdx->pendedPixelUrbs[k]);
505 pdx->PixelUrb[k] = NULL;
506 pdx->pendedPixelUrbs[k] = NULL;
509 kfree(pdx->sgEntries);
510 vfree(pdx->maplist_numPagesMapped);
511 pdx->sgEntries = NULL;
512 pdx->maplist_numPagesMapped = NULL;
514 kfree(pdx->pendedPixelUrbs);
515 kfree(pdx->PixelUrb);
517 pdx->pendedPixelUrbs = NULL;
518 pdx->PixelUrb = NULL;
523 static void piusb_readPIXEL_callback(struct urb *urb)
526 struct device_extension *pdx = urb->context;
527 int status = urb->status;
529 if (status && !(status == -ENOENT || status == -ECONNRESET)) {
530 dbg("%s - nonzero read bulk status received: %d", __func__,
532 dbg("Error in read EP2 callback");
533 dbg("FrameIndex = %d", pdx->frameIdx);
534 dbg("Bytes received before problem occurred = %d",
535 pdx->bulk_in_byte_trk);
536 dbg("Urb Idx = %d", pdx->urbIdx);
537 pdx->pendedPixelUrbs[pdx->frameIdx][pdx->urbIdx] = 0;
539 pdx->bulk_in_byte_trk += urb->actual_length;
540 i = usb_submit_urb(urb, GFP_ATOMIC); /* resubmit the URB */
544 dbg("submit urb in callback failed "
545 "with error code %d", i);
549 pdx->urbIdx++; /* point to next URB when we callback */
550 if (pdx->bulk_in_byte_trk >= pdx->frameSize) {
551 pdx->bulk_in_size_returned =
552 pdx->bulk_in_byte_trk;
553 pdx->bulk_in_byte_trk = 0;
554 pdx->gotPixelData = 1;
557 1) % pdx->num_frames);
566 struct ioctl_struct *io - structure containing user address,
568 struct device_extension *pdx - the PIUSB device extension
571 int - status of the task
574 MapUserBuffer maps a buffer passed down through an ioctl.
575 The user buffer is Page Aligned by the app and then passed down.
576 The function get_free_pages(...) does the actual mapping of the buffer
577 from user space to kernel space.
578 From there a scatterlist is created from all the pages.
579 The next function called is to usb_buffer_map_sg which allocated
580 DMA addresses for each page, even coalescing them if possible.
581 The DMA address is placed in the scatterlist structure.
582 The function returns the number of DMA addresses.
583 This may or may not be equal to the number of pages that
584 the user buffer uses.
585 We then build an URB for each DMA address and then submit them.
589 int MapUserBuffer(unsigned long uaddr, unsigned long numbytes,
590 unsigned long frameInfo, struct device_extension *pdx)
592 static int MapUserBuffer(struct ioctl_struct *io, struct device_extension *pdx)
595 unsigned long numbytes;
596 int frameInfo; /* which frame we're mapping */
597 unsigned int epAddr = 0;
598 unsigned long count = 0;
602 struct page **maplist_p;
603 int numPagesRequired;
605 frameInfo = io->numFrames;
606 uaddr = (unsigned long)io->pData;
607 numbytes = io->numbytes;
609 if (pdx->iama == PIXIS_PID) {
610 /* which EP should we map this frame to ? */
611 /* PONG, odd frames: hEP[3] */
612 /* PING, even frames and zero hEP[2] */
613 epAddr = (frameInfo % 2) ? pdx->hEP[3] : pdx->hEP[2];
614 dbg("Pixis Frame #%d: EP=%d", frameInfo,
615 (epAddr == pdx->hEP[2]) ? 2 : 4);
616 } else { /* ST133 only has 1 endpoint for Pixel data transfer */
617 epAddr = pdx->hEP[0];
618 dbg("ST133 Frame #%d: EP=2", frameInfo);
621 dbg("UserAddress = 0x%08lX", uaddr);
622 dbg("numbytes = %d", (int)numbytes);
624 /* number of pages to map the entire user space DMA buffer */
626 ((uaddr & ~PAGE_MASK) + count + ~PAGE_MASK) >> PAGE_SHIFT;
627 dbg("Number of pages needed = %d", numPagesRequired);
628 maplist_p = vmalloc(numPagesRequired * sizeof(struct page));
630 dbg("Can't Allocate Memory for maplist_p");
634 /* map the user buffer to kernel memory */
635 down_write(¤t->mm->mmap_sem);
636 pdx->maplist_numPagesMapped[frameInfo] = get_user_pages(current,
637 current->mm, (uaddr & PAGE_MASK), numPagesRequired,
638 WRITE, 0 /* Don't Force*/, maplist_p, NULL);
639 up_write(¤t->mm->mmap_sem);
640 dbg("Number of pages mapped = %d",
641 pdx->maplist_numPagesMapped[frameInfo]);
643 for (i = 0; i < pdx->maplist_numPagesMapped[frameInfo]; i++)
644 flush_dcache_page(maplist_p[i]);
645 if (!pdx->maplist_numPagesMapped[frameInfo]) {
646 dbg("get_user_pages() failed");
651 /* need to create a scatterlist that spans each frame
652 * that can fit into the mapped buffer
654 pdx->sgl[frameInfo] =
655 kmalloc((pdx->maplist_numPagesMapped[frameInfo] *
656 sizeof(struct scatterlist)), GFP_ATOMIC);
657 if (!pdx->sgl[frameInfo]) {
659 dbg("can't allocate mem for sgl");
662 sg_assign_page(&pdx->sgl[frameInfo][0], maplist_p[0]);
663 pdx->sgl[frameInfo][0].offset = uaddr & ~PAGE_MASK;
664 if (pdx->maplist_numPagesMapped[frameInfo] > 1) {
665 pdx->sgl[frameInfo][0].length =
666 PAGE_SIZE - pdx->sgl[frameInfo][0].offset;
667 count -= pdx->sgl[frameInfo][0].length;
668 for (k = 1; k < pdx->maplist_numPagesMapped[frameInfo]; k++) {
669 pdx->sgl[frameInfo][k].offset = 0;
670 sg_assign_page(&pdx->sgl[frameInfo][k], maplist_p[k]);
671 pdx->sgl[frameInfo][k].length =
672 (count < PAGE_SIZE) ? count : PAGE_SIZE;
673 count -= PAGE_SIZE; /* example had PAGE_SIZE here */
676 pdx->sgl[frameInfo][0].length = count;
678 pdx->sgEntries[frameInfo] =
679 usb_buffer_map_sg(pdx->udev, epAddr, pdx->sgl[frameInfo],
680 pdx->maplist_numPagesMapped[frameInfo]);
681 dbg("number of sgEntries = %d", pdx->sgEntries[frameInfo]);
682 pdx->userBufMapped = 1;
685 /* Create and Send the URB's for each s/g entry */
686 pdx->PixelUrb[frameInfo] =
687 kmalloc(pdx->sgEntries[frameInfo] * sizeof(struct urb *),
689 if (!pdx->PixelUrb[frameInfo]) {
690 dbg("Can't Allocate Memory for Urb");
693 for (i = 0; i < pdx->sgEntries[frameInfo]; i++) {
694 /* 0 iso packets because we're using BULK transfers */
695 pdx->PixelUrb[frameInfo][i] = usb_alloc_urb(0, GFP_KERNEL);
696 usb_fill_bulk_urb(pdx->PixelUrb[frameInfo][i],
699 (dma_addr_t *) sg_dma_address(&pdx->
702 sg_dma_len(&pdx->sgl[frameInfo][i]),
703 piusb_readPIXEL_callback, (void *)pdx);
704 pdx->PixelUrb[frameInfo][i]->transfer_dma =
705 sg_dma_address(&pdx->sgl[frameInfo][i]);
706 pdx->PixelUrb[frameInfo][i]->transfer_flags =
707 URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT;
709 /* only interrupt when last URB completes */
710 pdx->PixelUrb[frameInfo][--i]->transfer_flags &= ~URB_NO_INTERRUPT;
711 pdx->pendedPixelUrbs[frameInfo] =
712 kmalloc((pdx->sgEntries[frameInfo] * sizeof(char)), GFP_KERNEL);
713 if (!pdx->pendedPixelUrbs[frameInfo])
714 dbg("Can't allocate Memory for pendedPixelUrbs");
715 for (i = 0; i < pdx->sgEntries[frameInfo]; i++) {
716 err = usb_submit_urb(pdx->PixelUrb[frameInfo][i], GFP_ATOMIC);
718 dbg("%s %d\n", "submit urb error =", err);
719 pdx->pendedPixelUrbs[frameInfo][i] = 0;
722 pdx->pendedPixelUrbs[frameInfo][i] = 1;
727 static const struct file_operations piusb_fops = {
728 .owner = THIS_MODULE,
729 .ioctl = piusb_ioctl,
731 .release = piusb_release,
734 static struct usb_class_driver piusb_class = {
735 .name = "usb/rspiusb%d",
737 .minor_base = PIUSB_MINOR_BASE,
743 * Called by the usb core when a new device is connected that it thinks
744 * this driver might be interested in.
746 static int piusb_probe(struct usb_interface *interface,
747 const struct usb_device_id *id)
749 struct device_extension *pdx = NULL;
750 struct usb_host_interface *iface_desc;
751 struct usb_endpoint_descriptor *endpoint;
753 int retval = -ENOMEM;
755 dev_dbg(&interface->dev, "%s - Looking for PI USB Hardware", __func__);
757 pdx = kzalloc(sizeof(struct device_extension), GFP_KERNEL);
759 dev_err(&interface->dev, "Out of memory\n");
762 kref_init(&pdx->kref);
763 pdx->udev = usb_get_dev(interface_to_usbdev(interface));
764 pdx->interface = interface;
765 iface_desc = interface->cur_altsetting;
767 /* See if the device offered us matches what we can accept */
768 if ((pdx->udev->descriptor.idVendor != VENDOR_ID)
769 || ((pdx->udev->descriptor.idProduct != PIXIS_PID)
770 && (pdx->udev->descriptor.idProduct != ST133_PID)))
773 pdx->iama = pdx->udev->descriptor.idProduct;
776 if (pdx->udev->descriptor.idProduct == PIXIS_PID)
777 dbg("PIUSB:Pixis Camera Found");
779 dbg("PIUSB:ST133 USB Controller Found");
780 if (pdx->udev->speed == USB_SPEED_HIGH)
781 dbg("Highspeed(USB2.0) Device Attached");
783 dbg("Lowspeed (USB1.1) Device Attached");
785 dbg("NumEndpoints in Configuration: %d",
786 iface_desc->desc.bNumEndpoints);
788 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
789 endpoint = &iface_desc->endpoint[i].desc;
791 dbg("Endpoint[%d]->bDescriptorType = %d", i,
792 endpoint->bDescriptorType);
793 dbg("Endpoint[%d]->bEndpointAddress = 0x%02X", i,
794 endpoint->bEndpointAddress);
795 dbg("Endpoint[%d]->bbmAttributes = %d", i,
796 endpoint->bmAttributes);
797 dbg("Endpoint[%d]->MaxPacketSize = %d\n", i,
798 endpoint->wMaxPacketSize);
800 if (usb_endpoint_xfer_bulk(endpoint)) {
801 if (usb_endpoint_dir_in(endpoint))
803 usb_rcvbulkpipe(pdx->udev,
804 endpoint->bEndpointAddress);
807 usb_sndbulkpipe(pdx->udev,
808 endpoint->bEndpointAddress);
811 usb_set_intfdata(interface, pdx);
812 retval = usb_register_dev(interface, &piusb_class);
814 err("Not able to get a minor for this device.");
815 usb_set_intfdata(interface, NULL);
820 /* we can register the device now, as it is ready */
821 pdx->minor = interface->minor;
822 /* let the user know what node this device is now attached to */
823 dbg("PI USB2.0 device now attached to piusb-%d", pdx->minor);
828 kref_put(&pdx->kref, piusb_delete);
835 * Called by the usb core when the device is removed from the system.
837 * This routine guarantees that the driver will not submit any more urbs
838 * by clearing pdx->udev. It is also supposed to terminate any currently
839 * active urbs. Unfortunately, usb_bulk_msg(), used in piusb_read(), does
840 * not provide any way to do this. But at least we can cancel an active
843 static void piusb_disconnect(struct usb_interface *interface)
845 struct device_extension *pdx;
846 int minor = interface->minor;
850 pdx = usb_get_intfdata(interface);
851 usb_set_intfdata(interface, NULL);
853 /* give back our minor */
854 usb_deregister_dev(interface, &piusb_class);
858 /* prevent device read, write and ioctl */
860 kref_put(&pdx->kref, piusb_delete);
861 dbg("PI USB2.0 device #%d now disconnected\n", minor);
864 static struct usb_driver piusb_driver = {
866 .probe = piusb_probe,
867 .disconnect = piusb_disconnect,
868 .id_table = pi_device_table,
874 static int __init piusb_init(void)
881 /* register this driver with the USB subsystem */
882 result = usb_register(&piusb_driver);
884 printk(KERN_ERR KBUILD_MODNAME
885 ": usb_register failed. Error number %d\n",
888 printk(KERN_INFO KBUILD_MODNAME ":%s: %s\n", DRIVER_DESC,
896 static void __exit piusb_exit(void)
898 /* deregister this driver with the USB subsystem */
899 usb_deregister(&piusb_driver);
902 module_init(piusb_init);
903 module_exit(piusb_exit);
905 /* Module parameters */
906 module_param(debug, int, 0);
907 MODULE_PARM_DESC(debug, "Debug enabled or not");
909 MODULE_AUTHOR(DRIVER_AUTHOR);
910 MODULE_DESCRIPTION(DRIVER_DESC);
911 MODULE_LICENSE("GPL v2");