aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/staging
diff options
context:
space:
mode:
authorGreg Kroah-Hartman <gregkh@suse.de>2009-09-03 00:33:06 -0400
committerGreg Kroah-Hartman <gregkh@suse.de>2009-09-15 15:02:35 -0400
commitffac040c05f7887896fbd5e1139e7fc59c30fa21 (patch)
treec21e65ac98ca7ae33528ca11b29f909f7d8d6e94 /drivers/staging
parenta8fcffbde4cedf319f7009cec21baddf9422685e (diff)
Staging: rspiusb: remove the driver
No one cares, it's a custom userspace interface, and the code hasn't built in a long time. So remove it. Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/staging')
-rw-r--r--drivers/staging/Kconfig2
-rw-r--r--drivers/staging/Makefile1
-rw-r--r--drivers/staging/rspiusb/Kconfig6
-rw-r--r--drivers/staging/rspiusb/Makefile1
-rw-r--r--drivers/staging/rspiusb/TODO22
-rw-r--r--drivers/staging/rspiusb/rspiusb.c929
-rw-r--r--drivers/staging/rspiusb/rspiusb.h33
7 files changed, 0 insertions, 994 deletions
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index 982e9445606..f7f9051a00e 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -85,8 +85,6 @@ source "drivers/staging/rtl8192su/Kconfig"
85 85
86source "drivers/staging/rtl8192e/Kconfig" 86source "drivers/staging/rtl8192e/Kconfig"
87 87
88source "drivers/staging/rspiusb/Kconfig"
89
90source "drivers/staging/mimio/Kconfig" 88source "drivers/staging/mimio/Kconfig"
91 89
92source "drivers/staging/frontier/Kconfig" 90source "drivers/staging/frontier/Kconfig"
diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile
index 4eabb440a18..3b388edd4f7 100644
--- a/drivers/staging/Makefile
+++ b/drivers/staging/Makefile
@@ -25,7 +25,6 @@ obj-$(CONFIG_ALTERA_PCIE_CHDMA) += altpciechdma/
25obj-$(CONFIG_RTL8187SE) += rtl8187se/ 25obj-$(CONFIG_RTL8187SE) += rtl8187se/
26obj-$(CONFIG_RTL8192SU) += rtl8192su/ 26obj-$(CONFIG_RTL8192SU) += rtl8192su/
27obj-$(CONFIG_RTL8192E) += rtl8192e/ 27obj-$(CONFIG_RTL8192E) += rtl8192e/
28obj-$(CONFIG_USB_RSPI) += rspiusb/
29obj-$(CONFIG_INPUT_MIMIO) += mimio/ 28obj-$(CONFIG_INPUT_MIMIO) += mimio/
30obj-$(CONFIG_TRANZPORT) += frontier/ 29obj-$(CONFIG_TRANZPORT) += frontier/
31obj-$(CONFIG_ANDROID) += android/ 30obj-$(CONFIG_ANDROID) += android/
diff --git a/drivers/staging/rspiusb/Kconfig b/drivers/staging/rspiusb/Kconfig
deleted file mode 100644
index d225f6794d0..00000000000
--- a/drivers/staging/rspiusb/Kconfig
+++ /dev/null
@@ -1,6 +0,0 @@
1config USB_RSPI
2 tristate "Princeton Instruments USB camera support"
3 default n
4 depends on USB && BROKEN
5 help
6 This driver is for the Princeton Instruments USB camera device.
diff --git a/drivers/staging/rspiusb/Makefile b/drivers/staging/rspiusb/Makefile
deleted file mode 100644
index cc7aed92b0e..00000000000
--- a/drivers/staging/rspiusb/Makefile
+++ /dev/null
@@ -1 +0,0 @@
1obj-$(CONFIG_USB_RSPI) += rspiusb.o
diff --git a/drivers/staging/rspiusb/TODO b/drivers/staging/rspiusb/TODO
deleted file mode 100644
index cd6336a9254..00000000000
--- a/drivers/staging/rspiusb/TODO
+++ /dev/null
@@ -1,22 +0,0 @@
1This driver is for the Princeton Instruments USB camera.
2
3It needs lots of work to get it into the main drivers/usb/ subdirectory:
4
5Any patches to do any of the following changes are greatly appreciated:
6
7 - make checkpatch.pl clean
8 - coding style fixups (typedefs, etc.)
9 - get it to build properly
10 - audit ioctls
11 - remove ioctls if possible
12 - assign proper minor number
13 - remove dbg() macro
14 - lots of general cleanups
15 - review locking
16
17Please send patches to:
18 Greg Kroah-Hartman <gregkh@suse.de>
19and CC:
20 Judd Montgomery <judd@jpilot.org>
21 Jeff Frontz <jeff.frontz@gmail.com>
22as they have this device and can test any needed changes.
diff --git a/drivers/staging/rspiusb/rspiusb.c b/drivers/staging/rspiusb/rspiusb.c
deleted file mode 100644
index 0495fbfe59d..00000000000
--- a/drivers/staging/rspiusb/rspiusb.c
+++ /dev/null
@@ -1,929 +0,0 @@
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
36static int debug = 1;
37#else
38static 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() */
66static DECLARE_MUTEX(disconnect_sem);
67
68/* Structure to hold all of our device specific stuff */
69struct 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 */
103static int MapUserBuffer(struct ioctl_struct *, struct device_extension *);
104static int UnMapUserBuffer(struct device_extension *);
105static int piusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
106 unsigned long arg);
107static int piusb_output(struct ioctl_struct *, unsigned char *, int,
108 struct device_extension *);
109static struct usb_driver piusb_driver;
110
111/* table of devices that work with this driver */
112static 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
118MODULE_DEVICE_TABLE(usb, pi_device_table);
119
120static int lastErr;
121static int errCnt;
122
123static 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
132static 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
178exit_no_device:
179 return retval;
180}
181
182static 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
197object_null:
198 return retval;
199}
200
201static 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
257static 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 */
279static 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
435static 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
450int 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
481static 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
535static 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/*
601int MapUserBuffer(unsigned long uaddr, unsigned long numbytes,
602 unsigned long frameInfo, struct device_extension *pdx)
603*/
604static 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 int ret;
615 struct page **maplist_p;
616 int numPagesRequired;
617
618 frameInfo = io->numFrames;
619 uaddr = (unsigned long)io->pData;
620 numbytes = io->numbytes;
621
622 if (pdx->iama == PIXIS_PID) {
623 /* which EP should we map this frame to ? */
624 /* PONG, odd frames: hEP[3] */
625 /* PING, even frames and zero hEP[2] */
626 epAddr = (frameInfo % 2) ? pdx->hEP[3] : pdx->hEP[2];
627 dbg("Pixis Frame #%d: EP=%d", frameInfo,
628 (epAddr == pdx->hEP[2]) ? 2 : 4);
629 } else { /* ST133 only has 1 endpoint for Pixel data transfer */
630 epAddr = pdx->hEP[0];
631 dbg("ST133 Frame #%d: EP=2", frameInfo);
632 }
633 count = numbytes;
634 dbg("UserAddress = 0x%08lX", uaddr);
635 dbg("numbytes = %d", (int)numbytes);
636
637 /* number of pages to map the entire user space DMA buffer */
638 numPagesRequired =
639 ((uaddr & ~PAGE_MASK) + count + ~PAGE_MASK) >> PAGE_SHIFT;
640 dbg("Number of pages needed = %d", numPagesRequired);
641 maplist_p = vmalloc(numPagesRequired * sizeof(struct page *));
642 if (!maplist_p) {
643 dbg("Can't Allocate Memory for maplist_p");
644 return -ENOMEM;
645 }
646
647 /* map the user buffer to kernel memory */
648 down_write(&current->mm->mmap_sem);
649 pdx->maplist_numPagesMapped[frameInfo] = get_user_pages(current,
650 current->mm, (uaddr & PAGE_MASK), numPagesRequired,
651 WRITE, 0 /* Don't Force*/, maplist_p, NULL);
652 up_write(&current->mm->mmap_sem);
653 dbg("Number of pages mapped = %d",
654 pdx->maplist_numPagesMapped[frameInfo]);
655
656 for (i = 0; i < pdx->maplist_numPagesMapped[frameInfo]; i++)
657 flush_dcache_page(maplist_p[i]);
658 if (!pdx->maplist_numPagesMapped[frameInfo]) {
659 dbg("get_user_pages() failed");
660 vfree(maplist_p);
661 return -ENOMEM;
662 }
663
664 /* need to create a scatterlist that spans each frame
665 * that can fit into the mapped buffer
666 */
667 pdx->sgl[frameInfo] =
668 kmalloc((pdx->maplist_numPagesMapped[frameInfo] *
669 sizeof(struct scatterlist)), GFP_ATOMIC);
670 if (!pdx->sgl[frameInfo]) {
671 vfree(maplist_p);
672 dbg("can't allocate mem for sgl");
673 return -ENOMEM;
674 }
675 sg_assign_page(&pdx->sgl[frameInfo][0], maplist_p[0]);
676 pdx->sgl[frameInfo][0].offset = uaddr & ~PAGE_MASK;
677 if (pdx->maplist_numPagesMapped[frameInfo] > 1) {
678 pdx->sgl[frameInfo][0].length =
679 PAGE_SIZE - pdx->sgl[frameInfo][0].offset;
680 count -= pdx->sgl[frameInfo][0].length;
681 for (k = 1; k < pdx->maplist_numPagesMapped[frameInfo]; k++) {
682 pdx->sgl[frameInfo][k].offset = 0;
683 sg_assign_page(&pdx->sgl[frameInfo][k], maplist_p[k]);
684 pdx->sgl[frameInfo][k].length =
685 (count < PAGE_SIZE) ? count : PAGE_SIZE;
686 count -= PAGE_SIZE; /* example had PAGE_SIZE here */
687 }
688 } else {
689 pdx->sgl[frameInfo][0].length = count;
690 }
691 ret = usb_buffer_map_sg(pdx->udev, epAddr, pdx->sgl[frameInfo],
692 pdx->maplist_numPagesMapped[frameInfo]);
693 if (ret < 0) {
694 vfree(maplist_p);
695 dbg("usb_buffer_map_sg() failed");
696 return -EINVAL;
697 }
698
699 pdx->sgEntries[frameInfo] = ret;
700
701 dbg("number of sgEntries = %d", pdx->sgEntries[frameInfo]);
702 pdx->userBufMapped = 1;
703 vfree(maplist_p);
704
705 /* Create and Send the URB's for each s/g entry */
706 pdx->PixelUrb[frameInfo] =
707 kmalloc(pdx->sgEntries[frameInfo] * sizeof(struct urb *),
708 GFP_KERNEL);
709 if (!pdx->PixelUrb[frameInfo]) {
710 dbg("Can't Allocate Memory for Urb");
711 return -ENOMEM;
712 }
713 for (i = 0; i < pdx->sgEntries[frameInfo]; i++) {
714 /* 0 iso packets because we're using BULK transfers */
715 pdx->PixelUrb[frameInfo][i] = usb_alloc_urb(0, GFP_KERNEL);
716 usb_fill_bulk_urb(pdx->PixelUrb[frameInfo][i],
717 pdx->udev,
718 epAddr,
719 NULL, // non-DMA HC? buy a better hardware
720 sg_dma_len(&pdx->sgl[frameInfo][i]),
721 piusb_readPIXEL_callback, (void *)pdx);
722 pdx->PixelUrb[frameInfo][i]->transfer_dma =
723 sg_dma_address(&pdx->sgl[frameInfo][i]);
724 pdx->PixelUrb[frameInfo][i]->transfer_flags =
725 URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT;
726 }
727 /* only interrupt when last URB completes */
728 pdx->PixelUrb[frameInfo][--i]->transfer_flags &= ~URB_NO_INTERRUPT;
729 pdx->pendedPixelUrbs[frameInfo] =
730 kmalloc((pdx->sgEntries[frameInfo] * sizeof(char)), GFP_KERNEL);
731 if (!pdx->pendedPixelUrbs[frameInfo])
732 dbg("Can't allocate Memory for pendedPixelUrbs");
733 for (i = 0; i < pdx->sgEntries[frameInfo]; i++) {
734 err = usb_submit_urb(pdx->PixelUrb[frameInfo][i], GFP_ATOMIC);
735 if (err) {
736 dbg("%s %d\n", "submit urb error =", err);
737 pdx->pendedPixelUrbs[frameInfo][i] = 0;
738 return err;
739 }
740 pdx->pendedPixelUrbs[frameInfo][i] = 1;
741 }
742 return 0;
743}
744
745static const struct file_operations piusb_fops = {
746 .owner = THIS_MODULE,
747 .ioctl = piusb_ioctl,
748 .open = piusb_open,
749 .release = piusb_release,
750};
751
752static struct usb_class_driver piusb_class = {
753 .name = "usb/rspiusb%d",
754 .fops = &piusb_fops,
755 .minor_base = PIUSB_MINOR_BASE,
756};
757
758/**
759 * piusb_probe
760 *
761 * Called by the usb core when a new device is connected that it thinks
762 * this driver might be interested in.
763 */
764static int piusb_probe(struct usb_interface *interface,
765 const struct usb_device_id *id)
766{
767 struct device_extension *pdx = NULL;
768 struct usb_host_interface *iface_desc;
769 struct usb_endpoint_descriptor *endpoint;
770 int i;
771 int retval = -ENOMEM;
772
773 dev_dbg(&interface->dev, "%s - Looking for PI USB Hardware", __func__);
774
775 pdx = kzalloc(sizeof(struct device_extension), GFP_KERNEL);
776 if (pdx == NULL) {
777 dev_err(&interface->dev, "Out of memory\n");
778 goto error;
779 }
780 kref_init(&pdx->kref);
781 pdx->udev = usb_get_dev(interface_to_usbdev(interface));
782 pdx->interface = interface;
783 iface_desc = interface->cur_altsetting;
784
785 /* See if the device offered us matches what we can accept */
786 if ((pdx->udev->descriptor.idVendor != VENDOR_ID)
787 || ((pdx->udev->descriptor.idProduct != PIXIS_PID)
788 && (pdx->udev->descriptor.idProduct != ST133_PID)))
789 return -ENODEV;
790
791 pdx->iama = pdx->udev->descriptor.idProduct;
792
793 if (debug) {
794 if (pdx->udev->descriptor.idProduct == PIXIS_PID)
795 dbg("PIUSB:Pixis Camera Found");
796 else
797 dbg("PIUSB:ST133 USB Controller Found");
798 if (pdx->udev->speed == USB_SPEED_HIGH)
799 dbg("Highspeed(USB2.0) Device Attached");
800 else
801 dbg("Lowspeed (USB1.1) Device Attached");
802
803 dbg("NumEndpoints in Configuration: %d",
804 iface_desc->desc.bNumEndpoints);
805 }
806 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
807 endpoint = &iface_desc->endpoint[i].desc;
808 if (debug) {
809 dbg("Endpoint[%d]->bDescriptorType = %d", i,
810 endpoint->bDescriptorType);
811 dbg("Endpoint[%d]->bEndpointAddress = 0x%02X", i,
812 endpoint->bEndpointAddress);
813 dbg("Endpoint[%d]->bbmAttributes = %d", i,
814 endpoint->bmAttributes);
815 dbg("Endpoint[%d]->MaxPacketSize = %d\n", i,
816 endpoint->wMaxPacketSize);
817 }
818 if (usb_endpoint_xfer_bulk(endpoint)) {
819 if (usb_endpoint_dir_in(endpoint))
820 pdx->hEP[i] =
821 usb_rcvbulkpipe(pdx->udev,
822 endpoint->bEndpointAddress);
823 else
824 pdx->hEP[i] =
825 usb_sndbulkpipe(pdx->udev,
826 endpoint->bEndpointAddress);
827 }
828 }
829 usb_set_intfdata(interface, pdx);
830 retval = usb_register_dev(interface, &piusb_class);
831 if (retval) {
832 err("Not able to get a minor for this device.");
833 usb_set_intfdata(interface, NULL);
834 goto error;
835 }
836 pdx->present = 1;
837
838 /* we can register the device now, as it is ready */
839 pdx->minor = interface->minor;
840 /* let the user know what node this device is now attached to */
841 dbg("PI USB2.0 device now attached to piusb-%d", pdx->minor);
842 return 0;
843
844error:
845 if (pdx)
846 kref_put(&pdx->kref, piusb_delete);
847 return retval;
848}
849
850/**
851 * piusb_disconnect
852 *
853 * Called by the usb core when the device is removed from the system.
854 *
855 * This routine guarantees that the driver will not submit any more urbs
856 * by clearing pdx->udev. It is also supposed to terminate any currently
857 * active urbs. Unfortunately, usb_bulk_msg(), used in piusb_read(), does
858 * not provide any way to do this. But at least we can cancel an active
859 * write.
860 */
861static void piusb_disconnect(struct usb_interface *interface)
862{
863 struct device_extension *pdx;
864 int minor = interface->minor;
865
866 lock_kernel();
867
868 pdx = usb_get_intfdata(interface);
869 usb_set_intfdata(interface, NULL);
870
871 /* give back our minor */
872 usb_deregister_dev(interface, &piusb_class);
873
874 unlock_kernel();
875
876 /* prevent device read, write and ioctl */
877 pdx->present = 0;
878 kref_put(&pdx->kref, piusb_delete);
879 dbg("PI USB2.0 device #%d now disconnected\n", minor);
880}
881
882static struct usb_driver piusb_driver = {
883 .name = "sub",
884 .probe = piusb_probe,
885 .disconnect = piusb_disconnect,
886 .id_table = pi_device_table,
887};
888
889/**
890 * piusb_init
891 */
892static int __init piusb_init(void)
893{
894 int result;
895
896 lastErr = 0;
897 errCnt = 0;
898
899 /* register this driver with the USB subsystem */
900 result = usb_register(&piusb_driver);
901 if (result)
902 printk(KERN_ERR KBUILD_MODNAME
903 ": usb_register failed. Error number %d\n",
904 result);
905 else
906 printk(KERN_INFO KBUILD_MODNAME ":%s: %s\n", DRIVER_DESC,
907 DRIVER_VERSION);
908 return result;
909}
910
911/**
912 * piusb_exit
913 */
914static void __exit piusb_exit(void)
915{
916 /* deregister this driver with the USB subsystem */
917 usb_deregister(&piusb_driver);
918}
919
920module_init(piusb_init);
921module_exit(piusb_exit);
922
923/* Module parameters */
924module_param(debug, int, 0);
925MODULE_PARM_DESC(debug, "Debug enabled or not");
926
927MODULE_AUTHOR(DRIVER_AUTHOR);
928MODULE_DESCRIPTION(DRIVER_DESC);
929MODULE_LICENSE("GPL v2");
diff --git a/drivers/staging/rspiusb/rspiusb.h b/drivers/staging/rspiusb/rspiusb.h
deleted file mode 100644
index 3fc1db7b1c4..00000000000
--- a/drivers/staging/rspiusb/rspiusb.h
+++ /dev/null
@@ -1,33 +0,0 @@
1#ifndef __RSPIUSB_H
2#define __RSPIUSB_H
3
4#define PIUSB_MAGIC 'm'
5#define PIUSB_IOCTL_BASE 192
6
7#define PIUSB_IOR(offset) \
8 _IOR(PIUSB_MAGIC, PIUSB_IOCTL_BASE + offset, struct ioctl_struct)
9#define PIUSB_IOW(offset) \
10 _IOW(PIUSB_MAGIC, PIUSB_IOCTL_BASE + offset, struct ioctl_struct)
11#define PIUSB_IO(offset) \
12 _IO(PIUSB_MAGIC, PIUSB_IOCTL_BASE + offset)
13
14#define PIUSB_GETVNDCMD PIUSB_IOR(1)
15#define PIUSB_SETVNDCMD PIUSB_IOW(2)
16#define PIUSB_WRITEPIPE PIUSB_IOW(3)
17#define PIUSB_READPIPE PIUSB_IOR(4)
18#define PIUSB_SETFRAMESIZE PIUSB_IOW(5)
19#define PIUSB_WHATCAMERA PIUSB_IO(6)
20#define PIUSB_USERBUFFER PIUSB_IOW(7)
21#define PIUSB_ISHIGHSPEED PIUSB_IO(8)
22#define PIUSB_UNMAP_USERBUFFER PIUSB_IOW(9)
23
24struct ioctl_struct {
25 unsigned char cmd;
26 unsigned long numbytes;
27 unsigned char dir; /* 1=out; 0=in */
28 int endpoint;
29 int numFrames;
30 unsigned char *pData;
31};
32
33#endif
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-30 13:52:11 -0500