Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/media/usb/cpia2/cpia2_usb.c

  1 /****************************************************************************
  2  *
  3  *  Filename: cpia2_usb.c
  4  *
  5  *  Copyright 2001, STMicrolectronics, Inc.
  6  *      Contact:  steve.miller@st.com
  7  *
  8  *  Description:
  9  *     This is a USB driver for CPia2 based video cameras.
 10  *     The infrastructure of this driver is based on the cpia usb driver by
 11  *     Jochen Scharrlach and Johannes Erdfeldt.
 12  *
 13  *  This program is free software; you can redistribute it and/or modify
 14  *  it under the terms of the GNU General Public License as published by
 15  *  the Free Software Foundation; either version 2 of the License, or
 16  *  (at your option) any later version.
 17  *
 18  *  This program is distributed in the hope that it will be useful,
 19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 21  *  GNU General Public License for more details.
 22  *
 23  *  You should have received a copy of the GNU General Public License
 24  *  along with this program; if not, write to the Free Software
 25  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 26  *
 27  *  Stripped of 2.4 stuff ready for main kernel submit by
 28  *              Alan Cox <alan@lxorguk.ukuu.org.uk>
 29  ****************************************************************************/
 30 
 31 #include <linux/kernel.h>
 32 #include <linux/slab.h>
 33 #include <linux/usb.h>
 34 #include <linux/module.h>
 35 
 36 #include "cpia2.h"
 37 
 38 static int frame_sizes[] = {
 39         0,      // USBIF_CMDONLY
 40         0,      // USBIF_BULK
 41         128,    // USBIF_ISO_1
 42         384,    // USBIF_ISO_2
 43         640,    // USBIF_ISO_3
 44         768,    // USBIF_ISO_4
 45         896,    // USBIF_ISO_5
 46         1023,   // USBIF_ISO_6
 47 };
 48 
 49 #define FRAMES_PER_DESC    10
 50 #define FRAME_SIZE_PER_DESC   frame_sizes[cam->cur_alt]
 51 
 52 static void process_frame(struct camera_data *cam);
 53 static void cpia2_usb_complete(struct urb *urb);
 54 static int cpia2_usb_probe(struct usb_interface *intf,
 55                            const struct usb_device_id *id);
 56 static void cpia2_usb_disconnect(struct usb_interface *intf);
 57 static int cpia2_usb_suspend(struct usb_interface *intf, pm_message_t message);
 58 static int cpia2_usb_resume(struct usb_interface *intf);
 59 
 60 static void free_sbufs(struct camera_data *cam);
 61 static void add_APPn(struct camera_data *cam);
 62 static void add_COM(struct camera_data *cam);
 63 static int submit_urbs(struct camera_data *cam);
 64 static int set_alternate(struct camera_data *cam, unsigned int alt);
 65 static int configure_transfer_mode(struct camera_data *cam, unsigned int alt);
 66 
 67 static struct usb_device_id cpia2_id_table[] = {
 68         {USB_DEVICE(0x0553, 0x0100)},
 69         {USB_DEVICE(0x0553, 0x0140)},
 70         {USB_DEVICE(0x0553, 0x0151)},  /* STV0676 */
 71         {}                      /* Terminating entry */
 72 };
 73 MODULE_DEVICE_TABLE(usb, cpia2_id_table);
 74 
 75 static struct usb_driver cpia2_driver = {
 76         .name           = "cpia2",
 77         .probe          = cpia2_usb_probe,
 78         .disconnect     = cpia2_usb_disconnect,
 79         .suspend        = cpia2_usb_suspend,
 80         .resume         = cpia2_usb_resume,
 81         .reset_resume   = cpia2_usb_resume,
 82         .id_table       = cpia2_id_table
 83 };
 84 
 85 
 86 /******************************************************************************
 87  *
 88  *  process_frame
 89  *
 90  *****************************************************************************/
 91 static void process_frame(struct camera_data *cam)
 92 {
 93         static int frame_count;
 94 
 95         unsigned char *inbuff = cam->workbuff->data;
 96 
 97         DBG("Processing frame #%d, current:%d\n",
 98             cam->workbuff->num, cam->curbuff->num);
 99 
100         if(cam->workbuff->length > cam->workbuff->max_length)
101                 cam->workbuff->max_length = cam->workbuff->length;
102 
103         if ((inbuff[0] == 0xFF) && (inbuff[1] == 0xD8)) {
104                 frame_count++;
105         } else {
106                 cam->workbuff->status = FRAME_ERROR;
107                 DBG("Start of frame not found\n");
108                 return;
109         }
110 
111         /***
112          * Now the output buffer should have a JPEG image in it.
113          ***/
114         if(!cam->first_image_seen) {
115                 /* Always skip the first image after streaming
116                  * starts. It is almost certainly corrupt. */
117                 cam->first_image_seen = 1;
118                 cam->workbuff->status = FRAME_EMPTY;
119                 return;
120         }
121         if (cam->workbuff->length > 3) {
122                 if(cam->mmapped &&
123                    cam->workbuff->length < cam->workbuff->max_length) {
124                         /* No junk in the buffers */
125                         memset(cam->workbuff->data+cam->workbuff->length,
126                                0, cam->workbuff->max_length-
127                                   cam->workbuff->length);
128                 }
129                 cam->workbuff->max_length = cam->workbuff->length;
130                 cam->workbuff->status = FRAME_READY;
131 
132                 if(!cam->mmapped && cam->num_frames > 2) {
133                         /* During normal reading, the most recent
134                          * frame will be read.  If the current frame
135                          * hasn't started reading yet, it will never
136                          * be read, so mark it empty.  If the buffer is
137                          * mmapped, or we have few buffers, we need to
138                          * wait for the user to free the buffer.
139                          *
140                          * NOTE: This is not entirely foolproof with 3
141                          * buffers, but it would take an EXTREMELY
142                          * overloaded system to cause problems (possible
143                          * image data corruption).  Basically, it would
144                          * need to take more time to execute cpia2_read
145                          * than it would for the camera to send
146                          * cam->num_frames-2 frames before problems
147                          * could occur.
148                          */
149                         cam->curbuff->status = FRAME_EMPTY;
150                 }
151                 cam->curbuff = cam->workbuff;
152                 cam->workbuff = cam->workbuff->next;
153                 DBG("Changed buffers, work:%d, current:%d\n",
154                     cam->workbuff->num, cam->curbuff->num);
155                 return;
156         } else {
157                 DBG("Not enough data for an image.\n");
158         }
159 
160         cam->workbuff->status = FRAME_ERROR;
161         return;
162 }
163 
164 /******************************************************************************
165  *
166  *  add_APPn
167  *
168  *  Adds a user specified APPn record
169  *****************************************************************************/
170 static void add_APPn(struct camera_data *cam)
171 {
172         if(cam->APP_len > 0) {
173                 cam->workbuff->data[cam->workbuff->length++] = 0xFF;
174                 cam->workbuff->data[cam->workbuff->length++] = 0xE0+cam->APPn;
175                 cam->workbuff->data[cam->workbuff->length++] = 0;
176                 cam->workbuff->data[cam->workbuff->length++] = cam->APP_len+2;
177                 memcpy(cam->workbuff->data+cam->workbuff->length,
178                        cam->APP_data, cam->APP_len);
179                 cam->workbuff->length += cam->APP_len;
180         }
181 }
182 
183 /******************************************************************************
184  *
185  *  add_COM
186  *
187  *  Adds a user specified COM record
188  *****************************************************************************/
189 static void add_COM(struct camera_data *cam)
190 {
191         if(cam->COM_len > 0) {
192                 cam->workbuff->data[cam->workbuff->length++] = 0xFF;
193                 cam->workbuff->data[cam->workbuff->length++] = 0xFE;
194                 cam->workbuff->data[cam->workbuff->length++] = 0;
195                 cam->workbuff->data[cam->workbuff->length++] = cam->COM_len+2;
196                 memcpy(cam->workbuff->data+cam->workbuff->length,
197                        cam->COM_data, cam->COM_len);
198                 cam->workbuff->length += cam->COM_len;
199         }
200 }
201 
202 /******************************************************************************
203  *
204  *  cpia2_usb_complete
205  *
206  *  callback when incoming packet is received
207  *****************************************************************************/
208 static void cpia2_usb_complete(struct urb *urb)
209 {
210         int i;
211         unsigned char *cdata;
212         static bool frame_ready = false;
213         struct camera_data *cam = (struct camera_data *) urb->context;
214 
215         if (urb->status!=0) {
216                 if (!(urb->status == -ENOENT ||
217                       urb->status == -ECONNRESET ||
218                       urb->status == -ESHUTDOWN))
219                 {
220                         DBG("urb->status = %d!\n", urb->status);
221                 }
222                 DBG("Stopping streaming\n");
223                 return;
224         }
225 
226         if (!cam->streaming || !video_is_registered(&cam->vdev)) {
227                 LOG("Will now stop the streaming: streaming = %d, present=%d\n",
228                     cam->streaming, video_is_registered(&cam->vdev));
229                 return;
230         }
231 
232         /***
233          * Packet collater
234          ***/
235         //DBG("Collating %d packets\n", urb->number_of_packets);
236         for (i = 0; i < urb->number_of_packets; i++) {
237                 u16 checksum, iso_checksum;
238                 int j;
239                 int n = urb->iso_frame_desc[i].actual_length;
240                 int st = urb->iso_frame_desc[i].status;
241 
242                 if(cam->workbuff->status == FRAME_READY) {
243                         struct framebuf *ptr;
244                         /* Try to find an available buffer */
245                         DBG("workbuff full, searching\n");
246                         for (ptr = cam->workbuff->next;
247                              ptr != cam->workbuff;
248                              ptr = ptr->next)
249                         {
250                                 if (ptr->status == FRAME_EMPTY) {
251                                         ptr->status = FRAME_READING;
252                                         ptr->length = 0;
253                                         break;
254                                 }
255                         }
256                         if (ptr == cam->workbuff)
257                                 break; /* No READING or EMPTY buffers left */
258 
259                         cam->workbuff = ptr;
260                 }
261 
262                 if (cam->workbuff->status == FRAME_EMPTY ||
263                     cam->workbuff->status == FRAME_ERROR) {
264                         cam->workbuff->status = FRAME_READING;
265                         cam->workbuff->length = 0;
266                 }
267 
268                 //DBG("   Packet %d length = %d, status = %d\n", i, n, st);
269                 cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
270 
271                 if (st) {
272                         LOG("cpia2 data error: [%d] len=%d, status = %d\n",
273                             i, n, st);
274                         if(!ALLOW_CORRUPT)
275                                 cam->workbuff->status = FRAME_ERROR;
276                         continue;
277                 }
278 
279                 if(n<=2)
280                         continue;
281 
282                 checksum = 0;
283                 for(j=0; j<n-2; ++j)
284                         checksum += cdata[j];
285                 iso_checksum = cdata[j] + cdata[j+1]*256;
286                 if(checksum != iso_checksum) {
287                         LOG("checksum mismatch: [%d] len=%d, calculated = %x, checksum = %x\n",
288                             i, n, (int)checksum, (int)iso_checksum);
289                         if(!ALLOW_CORRUPT) {
290                                 cam->workbuff->status = FRAME_ERROR;
291                                 continue;
292                         }
293                 }
294                 n -= 2;
295 
296                 if(cam->workbuff->status != FRAME_READING) {
297                         if((0xFF == cdata[0] && 0xD8 == cdata[1]) ||
298                            (0xD8 == cdata[0] && 0xFF == cdata[1] &&
299                             0 != cdata[2])) {
300                                 /* frame is skipped, but increment total
301                                  * frame count anyway */
302                                 cam->frame_count++;
303                         }
304                         DBG("workbuff not reading, status=%d\n",
305                             cam->workbuff->status);
306                         continue;
307                 }
308 
309                 if (cam->frame_size < cam->workbuff->length + n) {
310                         ERR("buffer overflow! length: %d, n: %d\n",
311                             cam->workbuff->length, n);
312                         cam->workbuff->status = FRAME_ERROR;
313                         if(cam->workbuff->length > cam->workbuff->max_length)
314                                 cam->workbuff->max_length =
315                                         cam->workbuff->length;
316                         continue;
317                 }
318 
319                 if (cam->workbuff->length == 0) {
320                         int data_offset;
321                         if ((0xD8 == cdata[0]) && (0xFF == cdata[1])) {
322                                 data_offset = 1;
323                         } else if((0xFF == cdata[0]) && (0xD8 == cdata[1])
324                                   && (0xFF == cdata[2])) {
325                                 data_offset = 2;
326                         } else {
327                                 DBG("Ignoring packet, not beginning!\n");
328                                 continue;
329                         }
330                         DBG("Start of frame pattern found\n");
331                         v4l2_get_timestamp(&cam->workbuff->timestamp);
332                         cam->workbuff->seq = cam->frame_count++;
333                         cam->workbuff->data[0] = 0xFF;
334                         cam->workbuff->data[1] = 0xD8;
335                         cam->workbuff->length = 2;
336                         add_APPn(cam);
337                         add_COM(cam);
338                         memcpy(cam->workbuff->data+cam->workbuff->length,
339                                cdata+data_offset, n-data_offset);
340                         cam->workbuff->length += n-data_offset;
341                 } else if (cam->workbuff->length > 0) {
342                         memcpy(cam->workbuff->data + cam->workbuff->length,
343                                cdata, n);
344                         cam->workbuff->length += n;
345                 }
346 
347                 if ((cam->workbuff->length >= 3) &&
348                     (cam->workbuff->data[cam->workbuff->length - 3] == 0xFF) &&
349                     (cam->workbuff->data[cam->workbuff->length - 2] == 0xD9) &&
350                     (cam->workbuff->data[cam->workbuff->length - 1] == 0xFF)) {
351                         frame_ready = true;
352                         cam->workbuff->data[cam->workbuff->length - 1] = 0;
353                         cam->workbuff->length -= 1;
354                 } else if ((cam->workbuff->length >= 2) &&
355                    (cam->workbuff->data[cam->workbuff->length - 2] == 0xFF) &&
356                    (cam->workbuff->data[cam->workbuff->length - 1] == 0xD9)) {
357                         frame_ready = true;
358                 }
359 
360                 if (frame_ready) {
361                         DBG("Workbuff image size = %d\n",cam->workbuff->length);
362                         process_frame(cam);
363 
364                         frame_ready = false;
365 
366                         if (waitqueue_active(&cam->wq_stream))
367                                 wake_up_interruptible(&cam->wq_stream);
368                 }
369         }
370 
371         if(cam->streaming) {
372                 /* resubmit */
373                 urb->dev = cam->dev;
374                 if ((i = usb_submit_urb(urb, GFP_ATOMIC)) != 0)
375                         ERR("%s: usb_submit_urb ret %d!\n", __func__, i);
376         }
377 }
378 
379 /******************************************************************************
380  *
381  * configure_transfer_mode
382  *
383  *****************************************************************************/
384 static int configure_transfer_mode(struct camera_data *cam, unsigned int alt)
385 {
386         static unsigned char iso_regs[8][4] = {
387                 {0x00, 0x00, 0x00, 0x00},
388                 {0x00, 0x00, 0x00, 0x00},
389                 {0xB9, 0x00, 0x00, 0x7E},
390                 {0xB9, 0x00, 0x01, 0x7E},
391                 {0xB9, 0x00, 0x02, 0x7E},
392                 {0xB9, 0x00, 0x02, 0xFE},
393                 {0xB9, 0x00, 0x03, 0x7E},
394                 {0xB9, 0x00, 0x03, 0xFD}
395         };
396         struct cpia2_command cmd;
397         unsigned char reg;
398 
399         if (!video_is_registered(&cam->vdev))
400                 return -ENODEV;
401 
402         /***
403          * Write the isoc registers according to the alternate selected
404          ***/
405         cmd.direction = TRANSFER_WRITE;
406         cmd.buffer.block_data[0] = iso_regs[alt][0];
407         cmd.buffer.block_data[1] = iso_regs[alt][1];
408         cmd.buffer.block_data[2] = iso_regs[alt][2];
409         cmd.buffer.block_data[3] = iso_regs[alt][3];
410         cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
411         cmd.start = CPIA2_VC_USB_ISOLIM;
412         cmd.reg_count = 4;
413         cpia2_send_command(cam, &cmd);
414 
415         /***
416          * Enable relevant streams before starting polling.
417          * First read USB Stream Config Register.
418          ***/
419         cmd.direction = TRANSFER_READ;
420         cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
421         cmd.start = CPIA2_VC_USB_STRM;
422         cmd.reg_count = 1;
423         cpia2_send_command(cam, &cmd);
424         reg = cmd.buffer.block_data[0];
425 
426         /* Clear iso, bulk, and int */
427         reg &= ~(CPIA2_VC_USB_STRM_BLK_ENABLE |
428                  CPIA2_VC_USB_STRM_ISO_ENABLE |
429                  CPIA2_VC_USB_STRM_INT_ENABLE);
430 
431         if (alt == USBIF_BULK) {
432                 DBG("Enabling bulk xfer\n");
433                 reg |= CPIA2_VC_USB_STRM_BLK_ENABLE;    /* Enable Bulk */
434                 cam->xfer_mode = XFER_BULK;
435         } else if (alt >= USBIF_ISO_1) {
436                 DBG("Enabling ISOC xfer\n");
437                 reg |= CPIA2_VC_USB_STRM_ISO_ENABLE;
438                 cam->xfer_mode = XFER_ISOC;
439         }
440 
441         cmd.buffer.block_data[0] = reg;
442         cmd.direction = TRANSFER_WRITE;
443         cmd.start = CPIA2_VC_USB_STRM;
444         cmd.reg_count = 1;
445         cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
446         cpia2_send_command(cam, &cmd);
447 
448         return 0;
449 }
450 
451 /******************************************************************************
452  *
453  * cpia2_usb_change_streaming_alternate
454  *
455  *****************************************************************************/
456 int cpia2_usb_change_streaming_alternate(struct camera_data *cam,
457                                          unsigned int alt)
458 {
459         int ret = 0;
460 
461         if(alt < USBIF_ISO_1 || alt > USBIF_ISO_6)
462                 return -EINVAL;
463 
464         if(alt == cam->params.camera_state.stream_mode)
465                 return 0;
466 
467         cpia2_usb_stream_pause(cam);
468 
469         configure_transfer_mode(cam, alt);
470 
471         cam->params.camera_state.stream_mode = alt;
472 
473         /* Reset the camera to prevent image quality degradation */
474         cpia2_reset_camera(cam);
475 
476         cpia2_usb_stream_resume(cam);
477 
478         return ret;
479 }
480 
481 /******************************************************************************
482  *
483  * set_alternate
484  *
485  *****************************************************************************/
486 static int set_alternate(struct camera_data *cam, unsigned int alt)
487 {
488         int ret = 0;
489 
490         if(alt == cam->cur_alt)
491                 return 0;
492 
493         if (cam->cur_alt != USBIF_CMDONLY) {
494                 DBG("Changing from alt %d to %d\n", cam->cur_alt, USBIF_CMDONLY);
495                 ret = usb_set_interface(cam->dev, cam->iface, USBIF_CMDONLY);
496                 if (ret != 0)
497                         return ret;
498         }
499         if (alt != USBIF_CMDONLY) {
500                 DBG("Changing from alt %d to %d\n", USBIF_CMDONLY, alt);
501                 ret = usb_set_interface(cam->dev, cam->iface, alt);
502                 if (ret != 0)
503                         return ret;
504         }
505 
506         cam->old_alt = cam->cur_alt;
507         cam->cur_alt = alt;
508 
509         return ret;
510 }
511 
512 /******************************************************************************
513  *
514  * free_sbufs
515  *
516  * Free all cam->sbuf[]. All non-NULL .data and .urb members that are non-NULL
517  * are assumed to be allocated. Non-NULL .urb members are also assumed to be
518  * submitted (and must therefore be killed before they are freed).
519  *****************************************************************************/
520 static void free_sbufs(struct camera_data *cam)
521 {
522         int i;
523 
524         for (i = 0; i < NUM_SBUF; i++) {
525                 if(cam->sbuf[i].urb) {
526                         usb_kill_urb(cam->sbuf[i].urb);
527                         usb_free_urb(cam->sbuf[i].urb);
528                         cam->sbuf[i].urb = NULL;
529                 }
530                 if(cam->sbuf[i].data) {
531                         kfree(cam->sbuf[i].data);
532                         cam->sbuf[i].data = NULL;
533                 }
534         }
535 }
536 
537 /*******
538 * Convenience functions
539 *******/
540 /****************************************************************************
541  *
542  *  write_packet
543  *
544  ***************************************************************************/
545 static int write_packet(struct usb_device *udev,
546                         u8 request, u8 * registers, u16 start, size_t size)
547 {
548         if (!registers || size <= 0)
549                 return -EINVAL;
550 
551         return usb_control_msg(udev,
552                                usb_sndctrlpipe(udev, 0),
553                                request,
554                                USB_TYPE_VENDOR | USB_RECIP_DEVICE,
555                                start,   /* value */
556                                0,       /* index */
557                                registers,       /* buffer */
558                                size,
559                                HZ);
560 }
561 
562 /****************************************************************************
563  *
564  *  read_packet
565  *
566  ***************************************************************************/
567 static int read_packet(struct usb_device *udev,
568                        u8 request, u8 * registers, u16 start, size_t size)
569 {
570         if (!registers || size <= 0)
571                 return -EINVAL;
572 
573         return usb_control_msg(udev,
574                                usb_rcvctrlpipe(udev, 0),
575                                request,
576                                USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_DEVICE,
577                                start,   /* value */
578                                0,       /* index */
579                                registers,       /* buffer */
580                                size,
581                                HZ);
582 }
583 
584 /******************************************************************************
585  *
586  *  cpia2_usb_transfer_cmd
587  *
588  *****************************************************************************/
589 int cpia2_usb_transfer_cmd(struct camera_data *cam,
590                            void *registers,
591                            u8 request, u8 start, u8 count, u8 direction)
592 {
593         int err = 0;
594         struct usb_device *udev = cam->dev;
595 
596         if (!udev) {
597                 ERR("%s: Internal driver error: udev is NULL\n", __func__);
598                 return -EINVAL;
599         }
600 
601         if (!registers) {
602                 ERR("%s: Internal driver error: register array is NULL\n", __func__);
603                 return -EINVAL;
604         }
605 
606         if (direction == TRANSFER_READ) {
607                 err = read_packet(udev, request, (u8 *)registers, start, count);
608                 if (err > 0)
609                         err = 0;
610         } else if (direction == TRANSFER_WRITE) {
611                 err =write_packet(udev, request, (u8 *)registers, start, count);
612                 if (err < 0) {
613                         LOG("Control message failed, err val = %d\n", err);
614                         LOG("Message: request = 0x%0X, start = 0x%0X\n",
615                             request, start);
616                         LOG("Message: count = %d, register[0] = 0x%0X\n",
617                             count, ((unsigned char *) registers)[0]);
618                 } else
619                         err=0;
620         } else {
621                 LOG("Unexpected first byte of direction: %d\n",
622                        direction);
623                 return -EINVAL;
624         }
625 
626         if(err != 0)
627                 LOG("Unexpected error: %d\n", err);
628         return err;
629 }
630 
631 
632 /******************************************************************************
633  *
634  *  submit_urbs
635  *
636  *****************************************************************************/
637 static int submit_urbs(struct camera_data *cam)
638 {
639         struct urb *urb;
640         int fx, err, i, j;
641 
642         for(i=0; i<NUM_SBUF; ++i) {
643                 if (cam->sbuf[i].data)
644                         continue;
645                 cam->sbuf[i].data =
646                     kmalloc(FRAMES_PER_DESC * FRAME_SIZE_PER_DESC, GFP_KERNEL);
647                 if (!cam->sbuf[i].data) {
648                         while (--i >= 0) {
649                                 kfree(cam->sbuf[i].data);
650                                 cam->sbuf[i].data = NULL;
651                         }
652                         return -ENOMEM;
653                 }
654         }
655 
656         /* We double buffer the Isoc lists, and also know the polling
657          * interval is every frame (1 == (1 << (bInterval -1))).
658          */
659         for(i=0; i<NUM_SBUF; ++i) {
660                 if(cam->sbuf[i].urb) {
661                         continue;
662                 }
663                 urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);
664                 if (!urb) {
665                         ERR("%s: usb_alloc_urb error!\n", __func__);
666                         for (j = 0; j < i; j++)
667                                 usb_free_urb(cam->sbuf[j].urb);
668                         return -ENOMEM;
669                 }
670 
671                 cam->sbuf[i].urb = urb;
672                 urb->dev = cam->dev;
673                 urb->context = cam;
674                 urb->pipe = usb_rcvisocpipe(cam->dev, 1 /*ISOC endpoint*/);
675                 urb->transfer_flags = URB_ISO_ASAP;
676                 urb->transfer_buffer = cam->sbuf[i].data;
677                 urb->complete = cpia2_usb_complete;
678                 urb->number_of_packets = FRAMES_PER_DESC;
679                 urb->interval = 1;
680                 urb->transfer_buffer_length =
681                         FRAME_SIZE_PER_DESC * FRAMES_PER_DESC;
682 
683                 for (fx = 0; fx < FRAMES_PER_DESC; fx++) {
684                         urb->iso_frame_desc[fx].offset =
685                                 FRAME_SIZE_PER_DESC * fx;
686                         urb->iso_frame_desc[fx].length = FRAME_SIZE_PER_DESC;
687                 }
688         }
689 
690 
691         /* Queue the ISO urbs, and resubmit in the completion handler */
692         for(i=0; i<NUM_SBUF; ++i) {
693                 err = usb_submit_urb(cam->sbuf[i].urb, GFP_KERNEL);
694                 if (err) {
695                         ERR("usb_submit_urb[%d]() = %d\n", i, err);
696                         return err;
697                 }
698         }
699 
700         return 0;
701 }
702 
703 /******************************************************************************
704  *
705  *  cpia2_usb_stream_start
706  *
707  *****************************************************************************/
708 int cpia2_usb_stream_start(struct camera_data *cam, unsigned int alternate)
709 {
710         int ret;
711         int old_alt;
712 
713         if(cam->streaming)
714                 return 0;
715 
716         if (cam->flush) {
717                 int i;
718                 DBG("Flushing buffers\n");
719                 for(i=0; i<cam->num_frames; ++i) {
720                         cam->buffers[i].status = FRAME_EMPTY;
721                         cam->buffers[i].length = 0;
722                 }
723                 cam->curbuff = &cam->buffers[0];
724                 cam->workbuff = cam->curbuff->next;
725                 cam->flush = false;
726         }
727 
728         old_alt = cam->params.camera_state.stream_mode;
729         cam->params.camera_state.stream_mode = 0;
730         ret = cpia2_usb_change_streaming_alternate(cam, alternate);
731         if (ret < 0) {
732                 int ret2;
733                 ERR("cpia2_usb_change_streaming_alternate() = %d!\n", ret);
734                 cam->params.camera_state.stream_mode = old_alt;
735                 ret2 = set_alternate(cam, USBIF_CMDONLY);
736                 if (ret2 < 0) {
737                         ERR("cpia2_usb_change_streaming_alternate(%d) =%d has already "
738                             "failed. Then tried to call "
739                             "set_alternate(USBIF_CMDONLY) = %d.\n",
740                             alternate, ret, ret2);
741                 }
742         } else {
743                 cam->frame_count = 0;
744                 cam->streaming = 1;
745                 ret = cpia2_usb_stream_resume(cam);
746         }
747         return ret;
748 }
749 
750 /******************************************************************************
751  *
752  *  cpia2_usb_stream_pause
753  *
754  *****************************************************************************/
755 int cpia2_usb_stream_pause(struct camera_data *cam)
756 {
757         int ret = 0;
758         if(cam->streaming) {
759                 free_sbufs(cam);
760                 ret = set_alternate(cam, USBIF_CMDONLY);
761         }
762         return ret;
763 }
764 
765 /******************************************************************************
766  *
767  *  cpia2_usb_stream_resume
768  *
769  *****************************************************************************/
770 int cpia2_usb_stream_resume(struct camera_data *cam)
771 {
772         int ret = 0;
773         if(cam->streaming) {
774                 cam->first_image_seen = 0;
775                 ret = set_alternate(cam, cam->params.camera_state.stream_mode);
776                 if(ret == 0) {
777                         /* for some reason the user effects need to be set
778                            again when starting streaming. */
779                         cpia2_do_command(cam, CPIA2_CMD_SET_USER_EFFECTS, TRANSFER_WRITE,
780                                         cam->params.vp_params.user_effects);
781                         ret = submit_urbs(cam);
782                 }
783         }
784         return ret;
785 }
786 
787 /******************************************************************************
788  *
789  *  cpia2_usb_stream_stop
790  *
791  *****************************************************************************/
792 int cpia2_usb_stream_stop(struct camera_data *cam)
793 {
794         int ret;
795 
796         ret = cpia2_usb_stream_pause(cam);
797         cam->streaming = 0;
798         configure_transfer_mode(cam, 0);
799         return ret;
800 }
801 
802 /******************************************************************************
803  *
804  *  cpia2_usb_probe
805  *
806  *  Probe and initialize.
807  *****************************************************************************/
808 static int cpia2_usb_probe(struct usb_interface *intf,
809                            const struct usb_device_id *id)
810 {
811         struct usb_device *udev = interface_to_usbdev(intf);
812         struct usb_interface_descriptor *interface;
813         struct camera_data *cam;
814         int ret;
815 
816         /* A multi-config CPiA2 camera? */
817         if (udev->descriptor.bNumConfigurations != 1)
818                 return -ENODEV;
819         interface = &intf->cur_altsetting->desc;
820 
821         /* If we get to this point, we found a CPiA2 camera */
822         LOG("CPiA2 USB camera found\n");
823 
824         cam = cpia2_init_camera_struct(intf);
825         if (cam == NULL)
826                 return -ENOMEM;
827 
828         cam->dev = udev;
829         cam->iface = interface->bInterfaceNumber;
830 
831         ret = set_alternate(cam, USBIF_CMDONLY);
832         if (ret < 0) {
833                 ERR("%s: usb_set_interface error (ret = %d)\n", __func__, ret);
834                 kfree(cam);
835                 return ret;
836         }
837 
838 
839         if((ret = cpia2_init_camera(cam)) < 0) {
840                 ERR("%s: failed to initialize cpia2 camera (ret = %d)\n", __func__, ret);
841                 kfree(cam);
842                 return ret;
843         }
844         LOG("  CPiA Version: %d.%02d (%d.%d)\n",
845                cam->params.version.firmware_revision_hi,
846                cam->params.version.firmware_revision_lo,
847                cam->params.version.asic_id,
848                cam->params.version.asic_rev);
849         LOG("  CPiA PnP-ID: %04x:%04x:%04x\n",
850                cam->params.pnp_id.vendor,
851                cam->params.pnp_id.product,
852                cam->params.pnp_id.device_revision);
853         LOG("  SensorID: %d.(version %d)\n",
854                cam->params.version.sensor_flags,
855                cam->params.version.sensor_rev);
856 
857         usb_set_intfdata(intf, cam);
858 
859         ret = cpia2_register_camera(cam);
860         if (ret < 0) {
861                 ERR("%s: Failed to register cpia2 camera (ret = %d)\n", __func__, ret);
862                 kfree(cam);
863                 return ret;
864         }
865 
866         return 0;
867 }
868 
869 /******************************************************************************
870  *
871  *  cpia2_disconnect
872  *
873  *****************************************************************************/
874 static void cpia2_usb_disconnect(struct usb_interface *intf)
875 {
876         struct camera_data *cam = usb_get_intfdata(intf);
877         usb_set_intfdata(intf, NULL);
878 
879         DBG("Stopping stream\n");
880         cpia2_usb_stream_stop(cam);
881 
882         mutex_lock(&cam->v4l2_lock);
883         DBG("Unregistering camera\n");
884         cpia2_unregister_camera(cam);
885         v4l2_device_disconnect(&cam->v4l2_dev);
886         mutex_unlock(&cam->v4l2_lock);
887         v4l2_device_put(&cam->v4l2_dev);
888 
889         if(cam->buffers) {
890                 DBG("Wakeup waiting processes\n");
891                 cam->curbuff->status = FRAME_READY;
892                 cam->curbuff->length = 0;
893                 if (waitqueue_active(&cam->wq_stream))
894                         wake_up_interruptible(&cam->wq_stream);
895         }
896 
897         DBG("Releasing interface\n");
898         usb_driver_release_interface(&cpia2_driver, intf);
899 
900         LOG("CPiA2 camera disconnected.\n");
901 }
902 
903 static int cpia2_usb_suspend(struct usb_interface *intf, pm_message_t message)
904 {
905         struct camera_data *cam = usb_get_intfdata(intf);
906 
907         mutex_lock(&cam->v4l2_lock);
908         if (cam->streaming) {
909                 cpia2_usb_stream_stop(cam);
910                 cam->streaming = 1;
911         }
912         mutex_unlock(&cam->v4l2_lock);
913 
914         dev_info(&intf->dev, "going into suspend..\n");
915         return 0;
916 }
917 
918 /* Resume device - start device. */
919 static int cpia2_usb_resume(struct usb_interface *intf)
920 {
921         struct camera_data *cam = usb_get_intfdata(intf);
922 
923         mutex_lock(&cam->v4l2_lock);
924         v4l2_ctrl_handler_setup(&cam->hdl);
925         if (cam->streaming) {
926                 cam->streaming = 0;
927                 cpia2_usb_stream_start(cam,
928                                 cam->params.camera_state.stream_mode);
929         }
930         mutex_unlock(&cam->v4l2_lock);
931 
932         dev_info(&intf->dev, "coming out of suspend..\n");
933         return 0;
934 }
935 
936 /******************************************************************************
937  *
938  *  usb_cpia2_init
939  *
940  *****************************************************************************/
941 int cpia2_usb_init(void)
942 {
943         return usb_register(&cpia2_driver);
944 }
945 
946 /******************************************************************************
947  *
948  *  usb_cpia_cleanup
949  *
950  *****************************************************************************/
951 void cpia2_usb_cleanup(void)
952 {
953         schedule_timeout(2 * HZ);
954         usb_deregister(&cpia2_driver);
955 }
956 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us