1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#include <linux/kernel.h>
32#include <linux/slab.h>
33#include <linux/usb.h>
34
35#include "cpia2.h"
36
37static int frame_sizes[] = {
38 0,
39 0,
40 128,
41 384,
42 640,
43 768,
44 896,
45 1023,
46};
47
48#define FRAMES_PER_DESC 10
49#define FRAME_SIZE_PER_DESC frame_sizes[cam->cur_alt]
50
51static void process_frame(struct camera_data *cam);
52static void cpia2_usb_complete(struct urb *urb);
53static int cpia2_usb_probe(struct usb_interface *intf,
54 const struct usb_device_id *id);
55static void cpia2_usb_disconnect(struct usb_interface *intf);
56
57static void free_sbufs(struct camera_data *cam);
58static void add_APPn(struct camera_data *cam);
59static void add_COM(struct camera_data *cam);
60static int submit_urbs(struct camera_data *cam);
61static int set_alternate(struct camera_data *cam, unsigned int alt);
62static int configure_transfer_mode(struct camera_data *cam, unsigned int alt);
63
64static struct usb_device_id cpia2_id_table[] = {
65 {USB_DEVICE(0x0553, 0x0100)},
66 {USB_DEVICE(0x0553, 0x0140)},
67 {USB_DEVICE(0x0553, 0x0151)},
68 {}
69};
70MODULE_DEVICE_TABLE(usb, cpia2_id_table);
71
72static struct usb_driver cpia2_driver = {
73 .name = "cpia2",
74 .probe = cpia2_usb_probe,
75 .disconnect = cpia2_usb_disconnect,
76 .id_table = cpia2_id_table
77};
78
79
80
81
82
83
84
85static void process_frame(struct camera_data *cam)
86{
87 static int frame_count;
88
89 unsigned char *inbuff = cam->workbuff->data;
90
91 DBG("Processing frame #%d, current:%d\n",
92 cam->workbuff->num, cam->curbuff->num);
93
94 if(cam->workbuff->length > cam->workbuff->max_length)
95 cam->workbuff->max_length = cam->workbuff->length;
96
97 if ((inbuff[0] == 0xFF) && (inbuff[1] == 0xD8)) {
98 frame_count++;
99 } else {
100 cam->workbuff->status = FRAME_ERROR;
101 DBG("Start of frame not found\n");
102 return;
103 }
104
105
106
107
108 if(!cam->first_image_seen) {
109
110
111 cam->first_image_seen = 1;
112 cam->workbuff->status = FRAME_EMPTY;
113 return;
114 }
115 if (cam->workbuff->length > 3) {
116 if(cam->mmapped &&
117 cam->workbuff->length < cam->workbuff->max_length) {
118
119 memset(cam->workbuff->data+cam->workbuff->length,
120 0, cam->workbuff->max_length-
121 cam->workbuff->length);
122 }
123 cam->workbuff->max_length = cam->workbuff->length;
124 cam->workbuff->status = FRAME_READY;
125
126 if(!cam->mmapped && cam->num_frames > 2) {
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143 cam->curbuff->status = FRAME_EMPTY;
144 }
145 cam->curbuff = cam->workbuff;
146 cam->workbuff = cam->workbuff->next;
147 DBG("Changed buffers, work:%d, current:%d\n",
148 cam->workbuff->num, cam->curbuff->num);
149 return;
150 } else {
151 DBG("Not enough data for an image.\n");
152 }
153
154 cam->workbuff->status = FRAME_ERROR;
155 return;
156}
157
158
159
160
161
162
163
164static void add_APPn(struct camera_data *cam)
165{
166 if(cam->APP_len > 0) {
167 cam->workbuff->data[cam->workbuff->length++] = 0xFF;
168 cam->workbuff->data[cam->workbuff->length++] = 0xE0+cam->APPn;
169 cam->workbuff->data[cam->workbuff->length++] = 0;
170 cam->workbuff->data[cam->workbuff->length++] = cam->APP_len+2;
171 memcpy(cam->workbuff->data+cam->workbuff->length,
172 cam->APP_data, cam->APP_len);
173 cam->workbuff->length += cam->APP_len;
174 }
175}
176
177
178
179
180
181
182
183static void add_COM(struct camera_data *cam)
184{
185 if(cam->COM_len > 0) {
186 cam->workbuff->data[cam->workbuff->length++] = 0xFF;
187 cam->workbuff->data[cam->workbuff->length++] = 0xFE;
188 cam->workbuff->data[cam->workbuff->length++] = 0;
189 cam->workbuff->data[cam->workbuff->length++] = cam->COM_len+2;
190 memcpy(cam->workbuff->data+cam->workbuff->length,
191 cam->COM_data, cam->COM_len);
192 cam->workbuff->length += cam->COM_len;
193 }
194}
195
196
197
198
199
200
201
202static void cpia2_usb_complete(struct urb *urb)
203{
204 int i;
205 unsigned char *cdata;
206 static int frame_ready = false;
207 struct camera_data *cam = (struct camera_data *) urb->context;
208
209 if (urb->status!=0) {
210 if (!(urb->status == -ENOENT ||
211 urb->status == -ECONNRESET ||
212 urb->status == -ESHUTDOWN))
213 {
214 DBG("urb->status = %d!\n", urb->status);
215 }
216 DBG("Stopping streaming\n");
217 return;
218 }
219
220 if (!cam->streaming || !cam->present || cam->open_count == 0) {
221 LOG("Will now stop the streaming: streaming = %d, "
222 "present=%d, open_count=%d\n",
223 cam->streaming, cam->present, cam->open_count);
224 return;
225 }
226
227
228
229
230
231 for (i = 0; i < urb->number_of_packets; i++) {
232 u16 checksum, iso_checksum;
233 int j;
234 int n = urb->iso_frame_desc[i].actual_length;
235 int st = urb->iso_frame_desc[i].status;
236
237 if(cam->workbuff->status == FRAME_READY) {
238 struct framebuf *ptr;
239
240 DBG("workbuff full, searching\n");
241 for (ptr = cam->workbuff->next;
242 ptr != cam->workbuff;
243 ptr = ptr->next)
244 {
245 if (ptr->status == FRAME_EMPTY) {
246 ptr->status = FRAME_READING;
247 ptr->length = 0;
248 break;
249 }
250 }
251 if (ptr == cam->workbuff)
252 break;
253
254 cam->workbuff = ptr;
255 }
256
257 if (cam->workbuff->status == FRAME_EMPTY ||
258 cam->workbuff->status == FRAME_ERROR) {
259 cam->workbuff->status = FRAME_READING;
260 cam->workbuff->length = 0;
261 }
262
263
264 cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
265
266 if (st) {
267 LOG("cpia2 data error: [%d] len=%d, status = %d\n",
268 i, n, st);
269 if(!ALLOW_CORRUPT)
270 cam->workbuff->status = FRAME_ERROR;
271 continue;
272 }
273
274 if(n<=2)
275 continue;
276
277 checksum = 0;
278 for(j=0; j<n-2; ++j)
279 checksum += cdata[j];
280 iso_checksum = cdata[j] + cdata[j+1]*256;
281 if(checksum != iso_checksum) {
282 LOG("checksum mismatch: [%d] len=%d, calculated = %x, checksum = %x\n",
283 i, n, (int)checksum, (int)iso_checksum);
284 if(!ALLOW_CORRUPT) {
285 cam->workbuff->status = FRAME_ERROR;
286 continue;
287 }
288 }
289 n -= 2;
290
291 if(cam->workbuff->status != FRAME_READING) {
292 if((0xFF == cdata[0] && 0xD8 == cdata[1]) ||
293 (0xD8 == cdata[0] && 0xFF == cdata[1] &&
294 0 != cdata[2])) {
295
296
297 cam->frame_count++;
298 }
299 DBG("workbuff not reading, status=%d\n",
300 cam->workbuff->status);
301 continue;
302 }
303
304 if (cam->frame_size < cam->workbuff->length + n) {
305 ERR("buffer overflow! length: %d, n: %d\n",
306 cam->workbuff->length, n);
307 cam->workbuff->status = FRAME_ERROR;
308 if(cam->workbuff->length > cam->workbuff->max_length)
309 cam->workbuff->max_length =
310 cam->workbuff->length;
311 continue;
312 }
313
314 if (cam->workbuff->length == 0) {
315 int data_offset;
316 if ((0xD8 == cdata[0]) && (0xFF == cdata[1])) {
317 data_offset = 1;
318 } else if((0xFF == cdata[0]) && (0xD8 == cdata[1])
319 && (0xFF == cdata[2])) {
320 data_offset = 2;
321 } else {
322 DBG("Ignoring packet, not beginning!\n");
323 continue;
324 }
325 DBG("Start of frame pattern found\n");
326 do_gettimeofday(&cam->workbuff->timestamp);
327 cam->workbuff->seq = cam->frame_count++;
328 cam->workbuff->data[0] = 0xFF;
329 cam->workbuff->data[1] = 0xD8;
330 cam->workbuff->length = 2;
331 add_APPn(cam);
332 add_COM(cam);
333 memcpy(cam->workbuff->data+cam->workbuff->length,
334 cdata+data_offset, n-data_offset);
335 cam->workbuff->length += n-data_offset;
336 } else if (cam->workbuff->length > 0) {
337 memcpy(cam->workbuff->data + cam->workbuff->length,
338 cdata, n);
339 cam->workbuff->length += n;
340 }
341
342 if ((cam->workbuff->length >= 3) &&
343 (cam->workbuff->data[cam->workbuff->length - 3] == 0xFF) &&
344 (cam->workbuff->data[cam->workbuff->length - 2] == 0xD9) &&
345 (cam->workbuff->data[cam->workbuff->length - 1] == 0xFF)) {
346 frame_ready = true;
347 cam->workbuff->data[cam->workbuff->length - 1] = 0;
348 cam->workbuff->length -= 1;
349 } else if ((cam->workbuff->length >= 2) &&
350 (cam->workbuff->data[cam->workbuff->length - 2] == 0xFF) &&
351 (cam->workbuff->data[cam->workbuff->length - 1] == 0xD9)) {
352 frame_ready = true;
353 }
354
355 if (frame_ready) {
356 DBG("Workbuff image size = %d\n",cam->workbuff->length);
357 process_frame(cam);
358
359 frame_ready = false;
360
361 if (waitqueue_active(&cam->wq_stream))
362 wake_up_interruptible(&cam->wq_stream);
363 }
364 }
365
366 if(cam->streaming) {
367
368 urb->dev = cam->dev;
369 if ((i = usb_submit_urb(urb, GFP_ATOMIC)) != 0)
370 ERR("%s: usb_submit_urb ret %d!\n", __func__, i);
371 }
372}
373
374
375
376
377
378
379static int configure_transfer_mode(struct camera_data *cam, unsigned int alt)
380{
381 static unsigned char iso_regs[8][4] = {
382 {0x00, 0x00, 0x00, 0x00},
383 {0x00, 0x00, 0x00, 0x00},
384 {0xB9, 0x00, 0x00, 0x7E},
385 {0xB9, 0x00, 0x01, 0x7E},
386 {0xB9, 0x00, 0x02, 0x7E},
387 {0xB9, 0x00, 0x02, 0xFE},
388 {0xB9, 0x00, 0x03, 0x7E},
389 {0xB9, 0x00, 0x03, 0xFD}
390 };
391 struct cpia2_command cmd;
392 unsigned char reg;
393
394 if(!cam->present)
395 return -ENODEV;
396
397
398
399
400 cmd.direction = TRANSFER_WRITE;
401 cmd.buffer.block_data[0] = iso_regs[alt][0];
402 cmd.buffer.block_data[1] = iso_regs[alt][1];
403 cmd.buffer.block_data[2] = iso_regs[alt][2];
404 cmd.buffer.block_data[3] = iso_regs[alt][3];
405 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
406 cmd.start = CPIA2_VC_USB_ISOLIM;
407 cmd.reg_count = 4;
408 cpia2_send_command(cam, &cmd);
409
410
411
412
413
414 cmd.direction = TRANSFER_READ;
415 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
416 cmd.start = CPIA2_VC_USB_STRM;
417 cmd.reg_count = 1;
418 cpia2_send_command(cam, &cmd);
419 reg = cmd.buffer.block_data[0];
420
421
422 reg &= ~(CPIA2_VC_USB_STRM_BLK_ENABLE |
423 CPIA2_VC_USB_STRM_ISO_ENABLE |
424 CPIA2_VC_USB_STRM_INT_ENABLE);
425
426 if (alt == USBIF_BULK) {
427 DBG("Enabling bulk xfer\n");
428 reg |= CPIA2_VC_USB_STRM_BLK_ENABLE;
429 cam->xfer_mode = XFER_BULK;
430 } else if (alt >= USBIF_ISO_1) {
431 DBG("Enabling ISOC xfer\n");
432 reg |= CPIA2_VC_USB_STRM_ISO_ENABLE;
433 cam->xfer_mode = XFER_ISOC;
434 }
435
436 cmd.buffer.block_data[0] = reg;
437 cmd.direction = TRANSFER_WRITE;
438 cmd.start = CPIA2_VC_USB_STRM;
439 cmd.reg_count = 1;
440 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
441 cpia2_send_command(cam, &cmd);
442
443 return 0;
444}
445
446
447
448
449
450
451int cpia2_usb_change_streaming_alternate(struct camera_data *cam,
452 unsigned int alt)
453{
454 int ret = 0;
455
456 if(alt < USBIF_ISO_1 || alt > USBIF_ISO_6)
457 return -EINVAL;
458
459 if(alt == cam->params.camera_state.stream_mode)
460 return 0;
461
462 cpia2_usb_stream_pause(cam);
463
464 configure_transfer_mode(cam, alt);
465
466 cam->params.camera_state.stream_mode = alt;
467
468
469 cpia2_reset_camera(cam);
470
471 cpia2_usb_stream_resume(cam);
472
473 return ret;
474}
475
476
477
478
479
480
481static int set_alternate(struct camera_data *cam, unsigned int alt)
482{
483 int ret = 0;
484
485 if(alt == cam->cur_alt)
486 return 0;
487
488 if (cam->cur_alt != USBIF_CMDONLY) {
489 DBG("Changing from alt %d to %d\n", cam->cur_alt, USBIF_CMDONLY);
490 ret = usb_set_interface(cam->dev, cam->iface, USBIF_CMDONLY);
491 if (ret != 0)
492 return ret;
493 }
494 if (alt != USBIF_CMDONLY) {
495 DBG("Changing from alt %d to %d\n", USBIF_CMDONLY, alt);
496 ret = usb_set_interface(cam->dev, cam->iface, alt);
497 if (ret != 0)
498 return ret;
499 }
500
501 cam->old_alt = cam->cur_alt;
502 cam->cur_alt = alt;
503
504 return ret;
505}
506
507
508
509
510
511
512
513
514
515static void free_sbufs(struct camera_data *cam)
516{
517 int i;
518
519 for (i = 0; i < NUM_SBUF; i++) {
520 if(cam->sbuf[i].urb) {
521 usb_kill_urb(cam->sbuf[i].urb);
522 usb_free_urb(cam->sbuf[i].urb);
523 cam->sbuf[i].urb = NULL;
524 }
525 if(cam->sbuf[i].data) {
526 kfree(cam->sbuf[i].data);
527 cam->sbuf[i].data = NULL;
528 }
529 }
530}
531
532
533
534
535
536
537
538
539
540static int write_packet(struct usb_device *udev,
541 u8 request, u8 * registers, u16 start, size_t size)
542{
543 if (!registers || size <= 0)
544 return -EINVAL;
545
546 return usb_control_msg(udev,
547 usb_sndctrlpipe(udev, 0),
548 request,
549 USB_TYPE_VENDOR | USB_RECIP_DEVICE,
550 start,
551 0,
552 registers,
553 size,
554 HZ);
555}
556
557
558
559
560
561
562static int read_packet(struct usb_device *udev,
563 u8 request, u8 * registers, u16 start, size_t size)
564{
565 if (!registers || size <= 0)
566 return -EINVAL;
567
568 return usb_control_msg(udev,
569 usb_rcvctrlpipe(udev, 0),
570 request,
571 USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_DEVICE,
572 start,
573 0,
574 registers,
575 size,
576 HZ);
577}
578
579
580
581
582
583
584int cpia2_usb_transfer_cmd(struct camera_data *cam,
585 void *registers,
586 u8 request, u8 start, u8 count, u8 direction)
587{
588 int err = 0;
589 struct usb_device *udev = cam->dev;
590
591 if (!udev) {
592 ERR("%s: Internal driver error: udev is NULL\n", __func__);
593 return -EINVAL;
594 }
595
596 if (!registers) {
597 ERR("%s: Internal driver error: register array is NULL\n", __func__);
598 return -EINVAL;
599 }
600
601 if (direction == TRANSFER_READ) {
602 err = read_packet(udev, request, (u8 *)registers, start, count);
603 if (err > 0)
604 err = 0;
605 } else if (direction == TRANSFER_WRITE) {
606 err =write_packet(udev, request, (u8 *)registers, start, count);
607 if (err < 0) {
608 LOG("Control message failed, err val = %d\n", err);
609 LOG("Message: request = 0x%0X, start = 0x%0X\n",
610 request, start);
611 LOG("Message: count = %d, register[0] = 0x%0X\n",
612 count, ((unsigned char *) registers)[0]);
613 } else
614 err=0;
615 } else {
616 LOG("Unexpected first byte of direction: %d\n",
617 direction);
618 return -EINVAL;
619 }
620
621 if(err != 0)
622 LOG("Unexpected error: %d\n", err);
623 return err;
624}
625
626
627
628
629
630
631
632static int submit_urbs(struct camera_data *cam)
633{
634 struct urb *urb;
635 int fx, err, i, j;
636
637 for(i=0; i<NUM_SBUF; ++i) {
638 if (cam->sbuf[i].data)
639 continue;
640 cam->sbuf[i].data =
641 kmalloc(FRAMES_PER_DESC * FRAME_SIZE_PER_DESC, GFP_KERNEL);
642 if (!cam->sbuf[i].data) {
643 while (--i >= 0) {
644 kfree(cam->sbuf[i].data);
645 cam->sbuf[i].data = NULL;
646 }
647 return -ENOMEM;
648 }
649 }
650
651
652
653
654 for(i=0; i<NUM_SBUF; ++i) {
655 if(cam->sbuf[i].urb) {
656 continue;
657 }
658 urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);
659 if (!urb) {
660 ERR("%s: usb_alloc_urb error!\n", __func__);
661 for (j = 0; j < i; j++)
662 usb_free_urb(cam->sbuf[j].urb);
663 return -ENOMEM;
664 }
665
666 cam->sbuf[i].urb = urb;
667 urb->dev = cam->dev;
668 urb->context = cam;
669 urb->pipe = usb_rcvisocpipe(cam->dev, 1 );
670 urb->transfer_flags = URB_ISO_ASAP;
671 urb->transfer_buffer = cam->sbuf[i].data;
672 urb->complete = cpia2_usb_complete;
673 urb->number_of_packets = FRAMES_PER_DESC;
674 urb->interval = 1;
675 urb->transfer_buffer_length =
676 FRAME_SIZE_PER_DESC * FRAMES_PER_DESC;
677
678 for (fx = 0; fx < FRAMES_PER_DESC; fx++) {
679 urb->iso_frame_desc[fx].offset =
680 FRAME_SIZE_PER_DESC * fx;
681 urb->iso_frame_desc[fx].length = FRAME_SIZE_PER_DESC;
682 }
683 }
684
685
686
687 for(i=0; i<NUM_SBUF; ++i) {
688 err = usb_submit_urb(cam->sbuf[i].urb, GFP_KERNEL);
689 if (err) {
690 ERR("usb_submit_urb[%d]() = %d\n", i, err);
691 return err;
692 }
693 }
694
695 return 0;
696}
697
698
699
700
701
702
703int cpia2_usb_stream_start(struct camera_data *cam, unsigned int alternate)
704{
705 int ret;
706 int old_alt;
707
708 if(cam->streaming)
709 return 0;
710
711 if (cam->flush) {
712 int i;
713 DBG("Flushing buffers\n");
714 for(i=0; i<cam->num_frames; ++i) {
715 cam->buffers[i].status = FRAME_EMPTY;
716 cam->buffers[i].length = 0;
717 }
718 cam->curbuff = &cam->buffers[0];
719 cam->workbuff = cam->curbuff->next;
720 cam->flush = false;
721 }
722
723 old_alt = cam->params.camera_state.stream_mode;
724 cam->params.camera_state.stream_mode = 0;
725 ret = cpia2_usb_change_streaming_alternate(cam, alternate);
726 if (ret < 0) {
727 int ret2;
728 ERR("cpia2_usb_change_streaming_alternate() = %d!\n", ret);
729 cam->params.camera_state.stream_mode = old_alt;
730 ret2 = set_alternate(cam, USBIF_CMDONLY);
731 if (ret2 < 0) {
732 ERR("cpia2_usb_change_streaming_alternate(%d) =%d has already "
733 "failed. Then tried to call "
734 "set_alternate(USBIF_CMDONLY) = %d.\n",
735 alternate, ret, ret2);
736 }
737 } else {
738 cam->frame_count = 0;
739 cam->streaming = 1;
740 ret = cpia2_usb_stream_resume(cam);
741 }
742 return ret;
743}
744
745
746
747
748
749
750int cpia2_usb_stream_pause(struct camera_data *cam)
751{
752 int ret = 0;
753 if(cam->streaming) {
754 ret = set_alternate(cam, USBIF_CMDONLY);
755 free_sbufs(cam);
756 }
757 return ret;
758}
759
760
761
762
763
764
765int cpia2_usb_stream_resume(struct camera_data *cam)
766{
767 int ret = 0;
768 if(cam->streaming) {
769 cam->first_image_seen = 0;
770 ret = set_alternate(cam, cam->params.camera_state.stream_mode);
771 if(ret == 0) {
772 ret = submit_urbs(cam);
773 }
774 }
775 return ret;
776}
777
778
779
780
781
782
783int cpia2_usb_stream_stop(struct camera_data *cam)
784{
785 int ret;
786 ret = cpia2_usb_stream_pause(cam);
787 cam->streaming = 0;
788 configure_transfer_mode(cam, 0);
789 return ret;
790}
791
792
793
794
795
796
797
798static int cpia2_usb_probe(struct usb_interface *intf,
799 const struct usb_device_id *id)
800{
801 struct usb_device *udev = interface_to_usbdev(intf);
802 struct usb_interface_descriptor *interface;
803 struct camera_data *cam;
804 int ret;
805
806
807 if (udev->descriptor.bNumConfigurations != 1)
808 return -ENODEV;
809 interface = &intf->cur_altsetting->desc;
810
811
812 LOG("CPiA2 USB camera found\n");
813
814 if((cam = cpia2_init_camera_struct()) == NULL)
815 return -ENOMEM;
816
817 cam->dev = udev;
818 cam->iface = interface->bInterfaceNumber;
819
820 ret = set_alternate(cam, USBIF_CMDONLY);
821 if (ret < 0) {
822 ERR("%s: usb_set_interface error (ret = %d)\n", __func__, ret);
823 kfree(cam);
824 return ret;
825 }
826
827 if ((ret = cpia2_register_camera(cam)) < 0) {
828 ERR("%s: Failed to register cpia2 camera (ret = %d)\n", __func__, ret);
829 kfree(cam);
830 return ret;
831 }
832
833
834 if((ret = cpia2_init_camera(cam)) < 0) {
835 ERR("%s: failed to initialize cpia2 camera (ret = %d)\n", __func__, ret);
836 cpia2_unregister_camera(cam);
837 kfree(cam);
838 return ret;
839 }
840 LOG(" CPiA Version: %d.%02d (%d.%d)\n",
841 cam->params.version.firmware_revision_hi,
842 cam->params.version.firmware_revision_lo,
843 cam->params.version.asic_id,
844 cam->params.version.asic_rev);
845 LOG(" CPiA PnP-ID: %04x:%04x:%04x\n",
846 cam->params.pnp_id.vendor,
847 cam->params.pnp_id.product,
848 cam->params.pnp_id.device_revision);
849 LOG(" SensorID: %d.(version %d)\n",
850 cam->params.version.sensor_flags,
851 cam->params.version.sensor_rev);
852
853 usb_set_intfdata(intf, cam);
854
855 return 0;
856}
857
858
859
860
861
862
863static void cpia2_usb_disconnect(struct usb_interface *intf)
864{
865 struct camera_data *cam = usb_get_intfdata(intf);
866 usb_set_intfdata(intf, NULL);
867 cam->present = 0;
868
869 DBG("Stopping stream\n");
870 cpia2_usb_stream_stop(cam);
871
872 DBG("Unregistering camera\n");
873 cpia2_unregister_camera(cam);
874
875 if(cam->buffers) {
876 DBG("Wakeup waiting processes\n");
877 cam->curbuff->status = FRAME_READY;
878 cam->curbuff->length = 0;
879 if (waitqueue_active(&cam->wq_stream))
880 wake_up_interruptible(&cam->wq_stream);
881 }
882
883 DBG("Releasing interface\n");
884 usb_driver_release_interface(&cpia2_driver, intf);
885
886 if (cam->open_count == 0) {
887 DBG("Freeing camera structure\n");
888 kfree(cam);
889 }
890
891 LOG("CPiA2 camera disconnected.\n");
892}
893
894
895
896
897
898
899
900int cpia2_usb_init(void)
901{
902 return usb_register(&cpia2_driver);
903}
904
905
906
907
908
909
910void cpia2_usb_cleanup(void)
911{
912 schedule_timeout(2 * HZ);
913 usb_deregister(&cpia2_driver);
914}
915