?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.18pre1
[davej-history.git] / drivers / usb / cpia.c
blob6a466c5a7f373242ee761932e02bc65d6143c3f0
1 /*
2 * USB CPiA Video Camera driver
3 *
4 * Supports CPiA based Video Cameras. Many manufacturers use this chipset.
5 * There's a good chance, if you have a USB video camera, it's a CPiA based
6 * one.
7 *
8 * (C) Copyright 1999 Johannes Erdfelt
9 * (C) Copyright 1999 Randy Dunlap
10 */
11
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <linux/list.h>
15 #include <linux/malloc.h>
16 #include <linux/mm.h>
17 #include <linux/smp_lock.h>
18 #include <linux/videodev.h>
19 #include <linux/vmalloc.h>
20 #include <linux/wrapper.h>
21 #include <linux/module.h>
22 #include <linux/spinlock.h>
23
24 #include <asm/io.h>
25
26 #include "usb.h"
27 #include "cpia.h"
28
29 #define CPIA_DEBUG /* Gobs of debugging info */
30
31 #define MAX_FRAME_SIZE (384 * 288 * 3)
32
33 /*******************************/
34 /* Memory management functions */
35 /*******************************/
36
37 /* convert virtual user memory address to physical address */
38 /* (virt_to_phys only works for kmalloced kernel memory) */
39
40 static inline unsigned long uvirt_to_phys(unsigned long adr)
41 {
42 pgd_t *pgd;
43 pmd_t *pmd;
44 pte_t *ptep, pte;
45
46 pgd = pgd_offset(current->mm, adr);
47 if (pgd_none(*pgd))
48 return 0;
49 pmd = pmd_offset(pgd, adr);
50 if (pmd_none(*pmd))
51 return 0;
52 ptep = pte_offset(pmd, adr/*&(~PGDIR_MASK)*/);
53 pte = *ptep;
54 if(pte_present(pte))
55 return
56 virt_to_phys((void *)(pte_page(pte)|(adr&(PAGE_SIZE-1))));
57 return 0;
58 }
59
60 static inline unsigned long uvirt_to_bus(unsigned long adr)
61 {
62 return virt_to_bus(phys_to_virt(uvirt_to_phys(adr)));
63 }
64
65 /* convert virtual kernel memory address to physical address */
66 /* (virt_to_phys only works for kmalloced kernel memory) */
67
68 static inline unsigned long kvirt_to_phys(unsigned long adr)
69 {
70 return uvirt_to_phys(VMALLOC_VMADDR(adr));
71 }
72
73 static inline unsigned long kvirt_to_bus(unsigned long adr)
74 {
75 return uvirt_to_bus(VMALLOC_VMADDR(adr));
76 }
77
78
79 static void * rvmalloc(unsigned long size)
80 {
81 void * mem;
82 unsigned long adr, page;
83
84 size += (PAGE_SIZE - 1);
85 size &= ~(PAGE_SIZE - 1);
86
87 mem=vmalloc(size);
88 if (mem)
89 {
90 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
91 adr=(unsigned long) mem;
92 while (size > 0)
93 {
94 page = kvirt_to_phys(adr);
95 mem_map_reserve(MAP_NR(phys_to_virt(page)));
96 adr+=PAGE_SIZE;
97 if (size > PAGE_SIZE)
98 size-=PAGE_SIZE;
99 else
100 size=0;
101 }
102 }
103 return mem;
104 }
105
106 static void rvfree(void * mem, unsigned long size)
107 {
108 unsigned long adr, page;
109
110 size += (PAGE_SIZE - 1);
111 size &= ~(PAGE_SIZE - 1);
112
113 if (mem)
114 {
115 adr=(unsigned long) mem;
116 while (size > 0)
117 {
118 page = kvirt_to_phys(adr);
119 mem_map_unreserve(MAP_NR(phys_to_virt(page)));
120 adr+=PAGE_SIZE;
121 if (size > PAGE_SIZE)
122 size-=PAGE_SIZE;
123 else
124 size=0;
125 }
126 vfree(mem);
127 }
128 }
129
130 int usb_cpia_get_version(struct usb_device *dev, void *buf)
131 {
132 devrequest dr;
133
134 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE) | 0x80;
135 dr.request = USB_REQ_CPIA_GET_VERSION;
136 dr.value = 0;
137 dr.index = 0;
138 dr.length = 4;
139
140 return dev->bus->op->control_msg(dev, usb_rcvctrlpipe(dev,0), &dr, buf, 4);
141 }
142
143 int usb_cpia_get_pnp_id(struct usb_device *dev, void *buf)
144 {
145 devrequest dr;
146
147 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE) | 0x80;
148 dr.request = USB_REQ_CPIA_GET_PNP_ID;
149 dr.value = 0;
150 dr.index = 0;
151 dr.length = 6;
152
153 return dev->bus->op->control_msg(dev, usb_rcvctrlpipe(dev,0), &dr, buf, 6);
154 }
155
156 int usb_cpia_get_camera_status(struct usb_device *dev, void *buf)
157 {
158 devrequest dr;
159
160 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE) | 0x80;
161 dr.request = USB_REQ_CPIA_GET_CAMERA_STATUS;
162 dr.value = 0;
163 dr.index = 0;
164 dr.length = 8;
165
166 return dev->bus->op->control_msg(dev, usb_rcvctrlpipe(dev,0), &dr, buf, 8);
167 }
168
169 int usb_cpia_goto_hi_power(struct usb_device *dev)
170 {
171 devrequest dr;
172
173 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
174 dr.request = USB_REQ_CPIA_GOTO_HI_POWER;
175 dr.value = 0;
176 dr.index = 0;
177 dr.length = 0;
178
179 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
180 }
181
182 int usb_cpia_get_vp_version(struct usb_device *dev, void *buf)
183 {
184 devrequest dr;
185
186 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
187 dr.request = USB_REQ_CPIA_GET_VP_VERSION;
188 dr.value = 0;
189 dr.index = 0;
190 dr.length = 4;
191
192 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, buf, 4);
193 }
194
195 int usb_cpia_set_sensor_fps(struct usb_device *dev, int sensorbaserate, int sensorclkdivisor)
196 {
197 devrequest dr;
198
199 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
200 dr.request = USB_REQ_CPIA_SET_SENSOR_FPS;
201 dr.value = (sensorclkdivisor << 8) + sensorbaserate;
202 dr.index = 0;
203 dr.length = 0;
204
205 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
206 }
207
208 int usb_cpia_grab_frame(struct usb_device *dev, int streamstartline)
209 {
210 devrequest dr;
211
212 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
213 dr.request = USB_REQ_CPIA_GRAB_FRAME;
214 dr.value = streamstartline << 8;
215 dr.index = 0;
216 dr.length = 0;
217
218 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
219 }
220
221 int usb_cpia_upload_frame(struct usb_device *dev, int forceupload)
222 {
223 devrequest dr;
224
225 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
226 dr.request = USB_REQ_CPIA_UPLOAD_FRAME;
227 dr.value = forceupload;
228 dr.index = 0;
229 dr.length = 0;
230
231 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
232 }
233
234 int usb_cpia_set_grab_mode(struct usb_device *dev, int continuousgrab)
235 {
236 devrequest dr;
237
238 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
239 dr.request = USB_REQ_CPIA_SET_GRAB_MODE;
240 dr.value = continuousgrab;
241 dr.index = 0;
242 dr.length = 0;
243
244 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
245 }
246
247 int usb_cpia_set_format(struct usb_device *dev, int size, int subsample, int order)
248 {
249 devrequest dr;
250
251 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
252 dr.request = USB_REQ_CPIA_SET_FORMAT;
253 dr.value = (subsample << 8) + size;
254 dr.index = order;
255 dr.length = 0;
256
257 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
258 }
259
260 int usb_cpia_set_compression(struct usb_device *dev, int compmode, int decimation)
261 {
262 devrequest dr;
263
264 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
265 dr.request = USB_REQ_CPIA_SET_COMPRESSION;
266 dr.value = (decimation << 8) + compmode;
267 dr.index = 0;
268 dr.length = 0;
269
270 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
271 }
272
273 int usb_cpia_initstreamcap(struct usb_device *dev, int skipframes, int streamstartline)
274 {
275 devrequest dr;
276
277 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
278 dr.request = USB_REQ_CPIA_INIT_STREAM_CAP;
279 dr.value = (streamstartline << 8) + skipframes;
280 dr.index = 0;
281 dr.length = 0;
282
283 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
284 }
285
286 int usb_cpia_finistreamcap(struct usb_device *dev)
287 {
288 devrequest dr;
289
290 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
291 dr.request = USB_REQ_CPIA_FINI_STREAM_CAP;
292 dr.value = 0;
293 dr.index = 0;
294 dr.length = 0;
295
296 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
297 }
298
299 int usb_cpia_startstreamcap(struct usb_device *dev)
300 {
301 devrequest dr;
302
303 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
304 dr.request = USB_REQ_CPIA_START_STREAM_CAP;
305 dr.value = 0;
306 dr.index = 0;
307 dr.length = 0;
308
309 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
310 }
311
312 int usb_cpia_endstreamcap(struct usb_device *dev)
313 {
314 devrequest dr;
315
316 dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
317 dr.request = USB_REQ_CPIA_END_STREAM_CAP;
318 dr.value = 0;
319 dr.index = 0;
320 dr.length = 0;
321
322 return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
323 }
324
325 /* How much data is left in the scratch buf? */
326 #define scratch_left(x) (cpia->scratchlen - (int)((char *)x - (char *)cpia->scratch))
327
328 static void cpia_parse_data(struct usb_cpia *cpia)
329 {
330 unsigned char *data = cpia->scratch;
331 unsigned long l;
332 int done;
333
334 done = 0;
335 while (!done && scratch_left(data)) {
336 switch (cpia->state) {
337 case STATE_SCANNING:
338 {
339 unsigned char *begin = data;
340
341 /* We need atleast 2 bytes for the magic value */
342 if (scratch_left(data) < 2) {
343 done = 1;
344 break;
345 }
346
347 /* 0x1968 is magic */
348 printk("header: %X\n", (*data << 8) + *(data + 1));
349 if ((*data == 0x19) && (*(data + 1) == 0x68)) {
350 cpia->state = STATE_HEADER;
351 printk("moving to header\n");
352 break;
353 }
354
355 /* Woops, lost the header, find the end of the frame */
356 if (scratch_left(data) < 4) {
357 done = 1;
358 break;
359 }
360
361 printk("Scanning for end of frame\n");
362 while (scratch_left(data) >= 4) {
363 if ((*data == 0xFF) &&
364 (*(data + 1) == 0xFF) &&
365 (*(data + 2) == 0xFF) &&
366 (*(data + 3) == 0xFF)) {
367 data += 4;
368 break;
369 }
370 data++;
371 }
372 #ifdef CPIA_DEBUG
373 printk("scan: scanned %d bytes\n", data-begin);
374 #endif
375 break;
376 }
377 case STATE_HEADER:
378 /* We need atleast 64 bytes for the header */
379 if (scratch_left(data) < 64) {
380 done = 1;
381 break;
382 }
383
384 #ifdef CPIA_DEBUG
385 printk("header: framerate %d\n", data[41]);
386 #endif
387
388 data += 64;
389
390 cpia->state = STATE_LINES;
391
392 break;
393 case STATE_LINES:
394 {
395 unsigned char *begin = data;
396 int found = 0;
397
398 while (scratch_left(data)) {
399 if (*data == 0xFD) {
400 data++;
401 found = 1;
402 break;
403 } else if ((*data == 0xFF) &&
404 (scratch_left(data) >= 3) &&
405 (*(data + 1) == 0xFF) &&
406 (*(data + 2) == 0xFF) &&
407 (*(data + 3) == 0xFF)) {
408 data += 4;
409 cpia->curline = 144;
410 found = 1;
411 break;
412 }
413
414 data++;
415 }
416
417 if (data-begin == 355 && cpia->frame[cpia->curframe].width != 64) {
418 int i;
419 char *f = cpia->frame[cpia->curframe].data, *b = begin;
420
421 b += 2;
422 f += (cpia->frame[cpia->curframe].width * 3) * cpia->curline;
423
424 for (i = 0; i < 176; i++)
425 f[(i * 3) + 0] =
426 f[(i * 3) + 1] =
427 f[(i * 3) + 2] =
428 b[(i * 2)];
429 }
430
431 if (found) {
432 cpia->curline++;
433 if (cpia->curline >= 144) {
434 wake_up(&cpia->wq);
435 cpia->state = STATE_SCANNING;
436 cpia->curline = 0;
437 cpia->curframe = -1;
438 done = 1;
439 }
440 } else {
441 data = begin;
442 done = 1;
443 }
444
445 break;
446 }
447 }
448 }
449
450 /* Grab the remaining */
451 l = scratch_left(data);
452 memmove(cpia->scratch, data, l);
453
454 cpia->scratchlen = l;
455 }
456
457 /*
458 * For the moment there is no actual data compression (making blocks
459 * of data contiguous). This just checks the "frames" array for errors.
460 */
461 static int cpia_compress_isochronous(struct usb_isoc_desc *isodesc)
462 {
463 char *data = isodesc->data;
464 int i, totlen = 0;
465
466 for (i = 0; i < isodesc->frame_count; i++) {
467 int n = isodesc->frames [i].frame_length;
468 int st = isodesc->frames [i].frame_status;
469
470 #ifdef CPIA_DEBUG
471 /* Debugging */
472 if (st)
473 printk(KERN_DEBUG "cpia data error: [%d] len=%d, status=%X\n",
474 i, n, st);
475 #endif
476
477 }
478
479 return totlen;
480 }
481
482 static int cpia_isoc_irq(int status, void *__buffer, int len, void *dev_id)
483 {
484 struct usb_cpia *cpia = dev_id;
485 struct usb_device *dev = cpia->dev;
486 struct cpia_sbuf *sbuf;
487 int i;
488 char *p;
489
490 if (!cpia->streaming) {
491 printk("oops, not streaming, but interrupt\n");
492 return 0;
493 }
494
495 if (cpia->curframe < 0) {
496 if (cpia->frame[0].state == FRAME_READY) {
497 cpia->curframe = 0;
498 cpia->frame[0].state = FRAME_GRABBING;
499 #ifdef CPIA_DEBUG
500 printk("capturing to frame 0\n");
501 #endif
502 } else if (cpia->frame[1].state == FRAME_READY) {
503 cpia->curframe = 1;
504 cpia->frame[1].state = FRAME_GRABBING;
505 #ifdef CPIA_DEBUG
506 printk("capturing to frame 1\n");
507 #endif
508 #ifdef CPIA_DEBUG
509 } else
510 printk("no frame available\n");
511 #else
512 }
513 #endif
514 }
515
516 sbuf = &cpia->sbuf[cpia->receivesbuf];
517
518 usb_kill_isoc(sbuf->isodesc);
519
520 /* Do something to it now */
521 sbuf->len = cpia_compress_isochronous(sbuf->isodesc);
522
523 #ifdef CPIA_DEBUG
524 if (sbuf->len)
525 printk("%d bytes received\n", sbuf->len);
526 #endif
527
528 if (sbuf->len && cpia->curframe >= 0) {
529 if (sbuf->len > (SCRATCH_BUF_SIZE - cpia->scratchlen)) {
530 printk("overflow!\n");
531 return 0;
532 }
533 memcpy(cpia->scratch + cpia->scratchlen, sbuf->data, sbuf->len);
534 cpia->scratchlen += sbuf->len;
535
536 cpia_parse_data(cpia);
537 }
538
539 /* Reschedule this block of Isochronous desc */
540 /*
541 usb_run_isoc(sbuf->isodesc, NULL);
542 */
543 /*
544 usb_schedule_isochronous(dev, sbuf->isodesc, cpia->sbuf[(cpia->receivesbuf + 2) % 3].isodesc);
545 */
546
547 /* Move to the next one */
548 cpia->receivesbuf = (cpia->receivesbuf + 1) % 3;
549
550 return 1;
551 }
552
553 int cpia_init_isoc(struct usb_cpia *cpia)
554 {
555 struct usb_device *dev = cpia->dev;
556 struct usb_isoc_desc *id;
557 int fx, err;
558
559 cpia->receivesbuf = 0;
560
561 cpia->scratchlen = 0;
562 cpia->curline = 0;
563 cpia->state = STATE_SCANNING;
564
565 /* ALT_ISOC is only doing double-buffering, not triple. */
566 err = usb_init_isoc (dev, usb_rcvisocpipe (dev, 1), FRAMES_PER_DESC, cpia,
567 &cpia->sbuf[0].isodesc);
568 if (err)
569 printk ("cpia_init_isoc: usb_init_isoc() ret. %d\n", err);
570 err = usb_init_isoc (dev, usb_rcvisocpipe (dev, 1), FRAMES_PER_DESC, cpia,
571 &cpia->sbuf[1].isodesc);
572 if (err)
573 printk ("cpia_init_isoc: usb_init_isoc() ret. %d\n", err);
574
575 if (!cpia->sbuf[0].isodesc || !cpia->sbuf[1].isodesc) {
576 if (cpia->sbuf[0].isodesc)
577 usb_free_isoc (cpia->sbuf[0].isodesc);
578 if (cpia->sbuf[1].isodesc)
579 usb_free_isoc (cpia->sbuf[1].isodesc);
580 return -ENOMEM;
581 }
582 #if 0
583 cpia->sbuf[0].isodesc = usb_allocate_isochronous(dev, usb_rcvisocpipe(dev,1), cpia->sbuf[0].data, STREAM_BUF_SIZE, 960, cpia_isoc_irq, cpia);
584 cpia->sbuf[1].isodesc = usb_allocate_isochronous(dev, usb_rcvisocpipe(dev,1), cpia->sbuf[1].data, STREAM_BUF_SIZE, 960, cpia_isoc_irq, cpia);
585 cpia->sbuf[2].isodesc = usb_allocate_isochronous(dev, usb_rcvisocpipe(dev,1), cpia->sbuf[2].data, STREAM_BUF_SIZE, 960, cpia_isoc_irq, cpia);
586 #endif
587
588 #ifdef CPIA_DEBUG
589 printk("isodesc[0] @ %p\n", cpia->sbuf[0].isodesc);
590 printk("isodesc[1] @ %p\n", cpia->sbuf[1].isodesc);
591 #if 0
592 printk("isodesc[2] @ %p\n", cpia->sbuf[2].isodesc);
593 #endif
594 #endif
595
596 /* Set the Isoc. desc. parameters. */
597 /* First for desc. [0] */
598 id = cpia->sbuf [0].isodesc;
599 id->start_type = START_ASAP;
600 id->callback_frames = 10; /* on every 10th frame */
601 id->callback_fn = cpia_isoc_irq;
602 id->data = cpia->sbuf[0].data;
603 id->buf_size = FRAME_SIZE_PER_DESC * FRAMES_PER_DESC;
604 for (fx = 0; fx < FRAMES_PER_DESC; fx++)
605 id->frames [fx].frame_length = FRAME_SIZE_PER_DESC;
606
607 /* and the desc. [1] */
608 id = cpia->sbuf [1].isodesc;
609 id->start_type = 0; /* will follow the first desc. */
610 id->callback_frames = 10; /* on every 10th frame */
611 id->callback_fn = cpia_isoc_irq;
612 id->data = cpia->sbuf[1].data;
613 id->buf_size = FRAME_SIZE_PER_DESC * FRAMES_PER_DESC;
614 for (fx = 0; fx < FRAMES_PER_DESC; fx++)
615 id->frames [fx].frame_length = FRAME_SIZE_PER_DESC;
616
617 usb_run_isoc (cpia->sbuf[0].isodesc, NULL);
618 usb_run_isoc (cpia->sbuf[1].isodesc, cpia->sbuf[0].isodesc);
619
620 #if 0
621 usb_schedule_isochronous(dev, cpia->sbuf[0].isodesc, NULL);
622 usb_schedule_isochronous(dev, cpia->sbuf[1].isodesc, cpia->sbuf[0].isodesc);
623 usb_schedule_isochronous(dev, cpia->sbuf[2].isodesc, cpia->sbuf[1].isodesc);
624 #endif
625
626 #ifdef CPIA_DEBUG
627 printk("done scheduling\n");
628 #endif
629 if (usb_set_interface(cpia->dev, 1, 3)) {
630 printk("cpia_set_interface error\n");
631 return -EINVAL;
632 }
633
634 usb_cpia_startstreamcap(cpia->dev);
635
636 cpia->streaming = 1;
637 #ifdef CPIA_DEBUG
638 printk("now streaming\n");
639 #endif
640
641 return 0;
642 }
643
644 void cpia_stop_isoc(struct usb_cpia *cpia)
645 {
646 struct usb_device *dev = cpia->dev;
647
648 if (!cpia->streaming)
649 return;
650
651 cpia->streaming = 0;
652
653 /* Stop the streaming */
654 usb_cpia_endstreamcap(cpia->dev);
655
656 /* Set packet size to 0 */
657 if (usb_set_interface(cpia->dev, 1, 0)) {
658 printk("cpia_set_interface error\n");
659 return /* -EINVAL */;
660 }
661
662 /* Unschedule all of the iso td's */
663 usb_kill_isoc (cpia->sbuf[1].isodesc);
664 usb_kill_isoc (cpia->sbuf[0].isodesc);
665 #if 0
666 usb_unschedule_isochronous(dev, cpia->sbuf[2].isodesc);
667 usb_unschedule_isochronous(dev, cpia->sbuf[1].isodesc);
668 usb_unschedule_isochronous(dev, cpia->sbuf[0].isodesc);
669 #endif
670
671 /* Delete them all */
672 usb_free_isoc (cpia->sbuf[1].isodesc);
673 usb_free_isoc (cpia->sbuf[0].isodesc);
674 #if 0
675 usb_delete_isochronous(dev, cpia->sbuf[2].isodesc);
676 usb_delete_isochronous(dev, cpia->sbuf[1].isodesc);
677 usb_delete_isochronous(dev, cpia->sbuf[0].isodesc);
678 #endif
679 }
680
681 /* Video 4 Linux API */
682 static int cpia_open(struct video_device *dev, int flags)
683 {
684 int err = -ENOMEM;
685 struct usb_cpia *cpia = (struct usb_cpia *)dev;
686
687 #ifdef CPIA_DEBUG
688 printk("cpia_open\n");
689 #endif
690
691 cpia->fbuf = rvmalloc(2 * MAX_FRAME_SIZE);
692 if (!cpia->fbuf)
693 goto open_err_ret;
694
695 cpia->frame[0].state = FRAME_DONE;
696 cpia->frame[1].state = FRAME_DONE;
697
698 cpia->frame[0].data = cpia->fbuf;
699 cpia->frame[1].data = cpia->fbuf + MAX_FRAME_SIZE;
700 #ifdef CPIA_DEBUG
701 printk("frame [0] @ %p\n", cpia->frame[0].data);
702 printk("frame [1] @ %p\n", cpia->frame[1].data);
703 #endif
704
705 cpia->sbuf[0].data = kmalloc (FRAMES_PER_DESC * FRAME_SIZE_PER_DESC, GFP_KERNEL);
706 if (!cpia->sbuf[0].data)
707 goto open_err_on0;
708
709 cpia->sbuf[1].data = kmalloc (FRAMES_PER_DESC * FRAME_SIZE_PER_DESC, GFP_KERNEL);
710 if (!cpia->sbuf[1].data)
711 goto open_err_on1;
712
713 #if 0
714 cpia->sbuf[0].data = kmalloc(STREAM_BUF_SIZE, GFP_KERNEL);
715 if (!cpia->sbuf[0].data)
716 goto open_err_on0;
717
718 cpia->sbuf[1].data = kmalloc(STREAM_BUF_SIZE, GFP_KERNEL);
719 if (!cpia->sbuf[1].data)
720 goto open_err_on1;
721
722 cpia->sbuf[2].data = kmalloc(STREAM_BUF_SIZE, GFP_KERNEL);
723 if (!cpia->sbuf[2].data)
724 goto open_err_on2;
725 #endif
726
727 #ifdef CPIA_DEBUG
728 printk("sbuf[0] @ %p\n", cpia->sbuf[0].data);
729 printk("sbuf[1] @ %p\n", cpia->sbuf[1].data);
730 #if 0
731 printk("sbuf[2] @ %p\n", cpia->sbuf[2].data);
732 #endif
733 #endif
734
735 cpia->curframe = -1;
736 cpia->receivesbuf = 0;
737
738 usb_cpia_initstreamcap(cpia->dev, 0, 60);
739
740 err = cpia_init_isoc(cpia);
741 if (err)
742 goto open_err_on2;
743
744 return 0;
745
746 open_err_on2:
747 kfree (cpia->sbuf[1].data);
748 open_err_on1:
749 kfree (cpia->sbuf[0].data);
750 open_err_on0:
751 rvfree(cpia->fbuf, 2 * MAX_FRAME_SIZE);
752 open_err_ret:
753 return err;
754 }
755
756 static void cpia_close(struct video_device *dev)
757 {
758 struct usb_cpia *cpia = (struct usb_cpia *)dev;
759
760 #ifdef CPIA_DEBUG
761 printk("cpia_close\n");
762 #endif
763
764 cpia_stop_isoc(cpia);
765
766 usb_cpia_finistreamcap(cpia->dev);
767
768 rvfree(cpia->fbuf, 2 * MAX_FRAME_SIZE);
769
770 kfree(cpia->sbuf[2].data);
771 kfree(cpia->sbuf[1].data);
772 kfree(cpia->sbuf[0].data);
773 }
774
775 static int cpia_init_done(struct video_device *dev)
776 {
777 return 0;
778 }
779
780 static long cpia_write(struct video_device *dev, const char *buf, unsigned long count, int noblock)
781 {
782 return -EINVAL;
783 }
784
785 static int cpia_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
786 {
787 struct usb_cpia *cpia = (struct usb_cpia *)dev;
788
789 switch (cmd) {
790 case VIDIOCGCAP:
791 {
792 struct video_capability b;
793
794 strcpy(b.name, "CPiA USB Camera");
795 b.type = VID_TYPE_CAPTURE /* | VID_TYPE_SUBCAPTURE */;
796 b.channels = 1;
797 b.audios = 0;
798 b.maxwidth = 176 /* 352 */;
799 b.maxheight = 144 /* 240 */;
800 b.minwidth = 176 /* (Something small?) */;
801 b.minheight = 144 /* " " */;
802
803 if (copy_to_user(arg, &b, sizeof(b)))
804 return -EFAULT;
805 return 0;
806 }
807 case VIDIOCGCHAN:
808 {
809 struct video_channel v;
810
811 if (copy_from_user(&v, arg, sizeof(v)))
812 return -EFAULT;
813 if (v.channel != 0)
814 return -EINVAL;
815
816 v.flags = 0;
817 v.tuners = 0;
818 v.type = VIDEO_TYPE_CAMERA;
819 strcpy(v.name, "Camera");
820
821 if (copy_to_user(arg, &v, sizeof(v)))
822 return -EFAULT;
823 return 0;
824 }
825 case VIDIOCSCHAN:
826 {
827 int v;
828
829 if (copy_from_user(&v, arg, sizeof(v)))
830 return -EFAULT;
831
832 if (v != 0)
833 return -EINVAL;
834
835 return 0;
836 }
837 case VIDIOCGTUNER:
838 {
839 struct video_tuner v;
840
841 if (copy_from_user(&v, arg, sizeof(v)))
842 return -EFAULT;
843
844 if (v.tuner)
845 return -EINVAL;
846
847 strcpy(v.name, "Format");
848
849 v.rangelow = 0;
850 v.rangehigh = 0;
851 v.flags = 0;
852 v.mode = VIDEO_MODE_AUTO;
853
854 if (copy_to_user(arg, &v, sizeof(v)))
855 return -EFAULT;
856
857 return 0;
858 }
859 case VIDIOCSTUNER:
860 {
861 struct video_tuner v;
862
863 if (copy_from_user(&v, arg, sizeof(v)))
864 return -EFAULT;
865
866 if (v.tuner)
867 return -EINVAL;
868
869 if (v.mode != VIDEO_MODE_AUTO)
870 return -EINVAL;
871
872 return 0;
873 }
874 case VIDIOCGPICT:
875 {
876 struct video_picture p;
877
878 p.colour = 0x8000; /* Damn British people :) */
879 p.hue = 0x8000;
880 p.brightness = 180 << 8; /* XXX */
881 p.contrast = 192 << 8; /* XXX */
882 p.whiteness = 105 << 8; /* XXX */
883 #if 0
884 p.depth = 24;
885 #endif
886 p.depth = 16;
887 p.palette = VIDEO_PALETTE_YUYV;
888
889 if (copy_to_user(arg, &p, sizeof(p)))
890 return -EFAULT;
891
892 return 0;
893 }
894 case VIDIOCSPICT:
895 {
896 struct video_picture p;
897
898 if (copy_from_user(&p, arg, sizeof(p)))
899 return -EFAULT;
900
901 #ifdef CPIA_DEBUG
902 printk("Attempting to set palette %d, depth %d\n",
903 p.palette, p.depth);
904 #endif
905
906 return 0;
907 }
908 case VIDIOCSWIN:
909 {
910 struct video_window vw;
911
912 #ifdef CPIA_DEBUG
913 printk("VIDIOCSWIN\n");
914 #endif
915
916 if (copy_from_user(&vw, arg, sizeof(vw)))
917 return -EFAULT;
918 if (vw.flags)
919 return -EINVAL;
920 if (vw.clipcount)
921 return -EINVAL;
922 if (vw.height != 176)
923 return -EINVAL;
924 if (vw.width != 144)
925 return -EINVAL;
926
927 return 0;
928 }
929 case VIDIOCGWIN:
930 {
931 struct video_window vw;
932
933 #ifdef CPIA_DEBUG
934 printk("VIDIOCGWIN\n");
935 #endif
936
937 vw.x = 0;
938 vw.y = 0;
939 vw.width = 176;
940 vw.height = 144;
941 vw.chromakey = 0;
942 vw.flags = 0;
943
944 if (copy_to_user(arg, &vw, sizeof(vw)))
945 return -EFAULT;
946
947 return 0;
948 }
949 case VIDIOCGMBUF:
950 {
951 struct video_mbuf vm;
952
953 memset(&vm, 0, sizeof(vm));
954 vm.size = MAX_FRAME_SIZE * 2;
955 vm.frames = 2;
956 vm.offsets[0] = 0;
957 vm.offsets[1] = MAX_FRAME_SIZE;
958
959 if (copy_to_user((void *)arg, (void *)&vm, sizeof(vm)))
960 return -EFAULT;
961
962 return 0;
963 }
964 case VIDIOCMCAPTURE:
965 {
966 struct video_mmap vm;
967
968 if (copy_from_user((void *)&vm, (void *)arg, sizeof(vm)))
969 return -EFAULT;
970
971 #ifdef CPIA_DEBUG
972 printk("MCAPTURE\n");
973 printk("frame: %d, size: %dx%d, format: %d\n",
974 vm.frame, vm.width, vm.height, vm.format);
975 #endif
976
977 if (vm.format != VIDEO_PALETTE_RGB24)
978 return -EINVAL;
979
980 if ((vm.frame != 0) && (vm.frame != 1))
981 return -EINVAL;
982
983 cpia->frame[vm.frame].width = vm.width;
984 cpia->frame[vm.frame].height = vm.height;
985
986 /* Mark it as free */
987 cpia->frame[vm.frame].state = FRAME_READY;
988
989 return 0;
990 }
991 case VIDIOCSYNC:
992 {
993 int frame;
994
995 if (copy_from_user((void *)&frame, arg, sizeof(int)))
996 return -EFAULT;
997
998 #ifdef CPIA_DEBUG
999 printk("syncing to frame %d\n", frame);
1000 #endif
1001 switch (cpia->frame[frame].state) {
1002 case FRAME_UNUSED:
1003 return -EINVAL;
1004 case FRAME_READY:
1005 case FRAME_GRABBING:
1006 interruptible_sleep_on(&cpia->wq);
1007 case FRAME_DONE:
1008 cpia->frame[frame].state = FRAME_UNUSED;
1009 break;
1010 }
1011 #ifdef CPIA_DEBUG
1012 printk("synced to frame %d\n", frame);
1013 #endif
1014 return 0;
1015 }
1016 case VIDIOCCAPTURE:
1017 return -EINVAL;
1018 case VIDIOCGFBUF:
1019 return -EINVAL;
1020 case VIDIOCSFBUF:
1021 return -EINVAL;
1022 case VIDIOCKEY:
1023 return 0;
1024 case VIDIOCGFREQ:
1025 return -EINVAL;
1026 case VIDIOCSFREQ:
1027 return -EINVAL;
1028 case VIDIOCGAUDIO:
1029 return -EINVAL;
1030 case VIDIOCSAUDIO:
1031 return -EINVAL;
1032 default:
1033 return -ENOIOCTLCMD;
1034 }
1035 return 0;
1036 }
1037
1038 static long cpia_read(struct video_device *dev, char *buf, unsigned long count, int noblock)
1039 {
1040 struct usb_cpia *cpia = (struct usb_cpia *)dev;
1041 int len;
1042
1043 #ifdef CPIA_DEBUG
1044 printk("cpia_read: %ld bytes\n", count);
1045 #endif
1046 #if 0
1047 len = cpia_capture(cpia, buf, count);
1048
1049 return len;
1050 #endif
1051 return 0;
1052 }
1053
1054 static int cpia_mmap(struct video_device *dev, const char *adr, unsigned long size)
1055 {
1056 struct usb_cpia *cpia = (struct usb_cpia *)dev;
1057 unsigned long start = (unsigned long)adr;
1058 unsigned long page, pos;
1059
1060 #ifdef CPIA_DEBUG
1061 printk("mmap: %ld (%lX) bytes\n", size, size);
1062 #endif
1063 if (size > (((2 * MAX_FRAME_SIZE) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)))
1064 return -EINVAL;
1065
1066 pos = (unsigned long)cpia->fbuf;
1067 while (size > 0)
1068 {
1069 page = kvirt_to_phys(pos);
1070 if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED))
1071 return -EAGAIN;
1072 start+=PAGE_SIZE;
1073 pos+=PAGE_SIZE;
1074 if (size > PAGE_SIZE)
1075 size-=PAGE_SIZE;
1076 else
1077 size=0;
1078 }
1079
1080 return 0;
1081 }
1082
1083 static struct video_device cpia_template = {
1084 "CPiA USB Camera",
1085 VID_TYPE_CAPTURE,
1086 VID_HARDWARE_CPIA,
1087 cpia_open,
1088 cpia_close,
1089 cpia_read,
1090 cpia_write,
1091 NULL,
1092 cpia_ioctl,
1093 cpia_mmap,
1094 cpia_init_done,
1095 NULL,
1096 0,
1097 0
1098 };
1099
1100 static void usb_cpia_configure(struct usb_cpia *cpia)
1101 {
1102 struct usb_device *dev = cpia->dev;
1103 unsigned char version[4];
1104 unsigned char pnpid[6];
1105 unsigned char camerastat[8];
1106 unsigned char *buf;
1107
1108 if (usb_set_configuration(dev, dev->config[0].bConfigurationValue)) {
1109 printk (KERN_INFO " Failed usb_set_configuration: CPIA\n");
1110 return;
1111 }
1112
1113 if (usb_cpia_get_version(dev, version)) {
1114 printk("cpia_get_version error\n");
1115 return;
1116 }
1117
1118 printk("cpia: Firmware v%d.%d, VC Hardware v%d.%d\n",
1119 version[0], version[1], version[2], version[3]);
1120
1121 if (usb_cpia_get_pnp_id(dev, pnpid)) {
1122 printk("cpia_get_pnp_id error\n");
1123 return;
1124 }
1125
1126 printk("cpia: PnP Id: Vendor: %X, Product: %X, Revision: %X\n",
1127 (pnpid[1] << 8) + pnpid[0], (pnpid[3] << 8) + pnpid[2],
1128 (pnpid[5] << 8) + pnpid[4]);
1129
1130 memcpy(&cpia->vdev, &cpia_template, sizeof(cpia_template));
1131
1132 init_waitqueue_head(&cpia->wq);
1133
1134 if (video_register_device(&cpia->vdev, VFL_TYPE_GRABBER) == -1) {
1135 printk("video_register_device failed\n");
1136 return;
1137 }
1138
1139 if (usb_cpia_goto_hi_power(dev)) {
1140 printk("cpia_goto_hi_power error\n");
1141 return;
1142 }
1143
1144 if (usb_cpia_get_vp_version(dev, version)) {
1145 printk("cpia_get_vp_version error\n");
1146 return;
1147 }
1148
1149 printk("cpia: VP v%d rev %d\n", version[0], version[1]);
1150 printk("cpia: Camera Head ID %04X\n", (version[3] << 8) + version[2]);
1151
1152 /* Turn off continuous grab */
1153 if (usb_cpia_set_grab_mode(dev, 1)) {
1154 printk("cpia_set_grab_mode error\n");
1155 return;
1156 }
1157
1158 /* Set up the sensor to be 30fps */
1159 if (usb_cpia_set_sensor_fps(dev, 1, 0)) {
1160 printk("cpia_set_sensor_fps error\n");
1161 return;
1162 }
1163
1164 /* Set video into QCIF mode, and order into YUYV mode */
1165 if (usb_cpia_set_format(dev, CPIA_QCIF, 1, CPIA_YUYV)) {
1166 printk("cpia_set_format error\n");
1167 return;
1168 }
1169
1170 /* Turn off compression */
1171 if (usb_cpia_set_compression(dev, 0, 0)) {
1172 printk("cpia_set_compression error\n");
1173 return;
1174 }
1175 }
1176
1177 static int cpia_probe(struct usb_device *dev)
1178 {
1179 struct usb_interface_descriptor *interface;
1180 struct usb_endpoint_descriptor *endpoint;
1181 struct usb_cpia *cpia;
1182
1183 /* We don't handle multi-config cameras */
1184 if (dev->descriptor.bNumConfigurations != 1)
1185 return -1;
1186
1187 interface = &dev->config[0].interface[0].altsetting[0];
1188
1189 /* Is it a CPiA? */
1190 if (dev->descriptor.idVendor != 0x0553)
1191 return -1;
1192 if (dev->descriptor.idProduct != 0x0002)
1193 return -1;
1194 if (interface->bInterfaceClass != 0xFF)
1195 return -1;
1196 if (interface->bInterfaceSubClass != 0x00)
1197 return -1;
1198
1199 /* We found a CPiA */
1200 printk("USB CPiA camera found\n");
1201
1202 if ((cpia = kmalloc(sizeof(*cpia), GFP_KERNEL)) == NULL) {
1203 printk("couldn't kmalloc cpia struct\n");
1204 return -1;
1205 }
1206
1207 memset(cpia, 0, sizeof(*cpia));
1208
1209 dev->private = cpia;
1210 cpia->dev = dev;
1211
1212 usb_cpia_configure(cpia);
1213
1214 return 0;
1215 }
1216
1217 static void cpia_disconnect(struct usb_device *dev)
1218 {
1219 struct usb_cpia *cpia = dev->private;
1220
1221 video_unregister_device(&cpia->vdev);
1222
1223 /* Free the memory */
1224 kfree(cpia);
1225 }
1226
1227 static struct usb_driver cpia_driver = {
1228 "cpia",
1229 cpia_probe,
1230 cpia_disconnect,
1231 { NULL, NULL }
1232 };
1233
1234 /*
1235 * This should be a separate module.
1236 */
1237 int usb_cpia_init(void)
1238 {
1239 usb_register(&cpia_driver);
1240
1241 return 0;
1242 }
1243
1244 #ifdef MODULE
1245 int init_module(void)
1246 {
1247 return usb_cpia_init();
1248 }
1249
1250 void cleanup_module(void)
1251 {
1252 }
1253 #endif
1254
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux