Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cpia2_usb.c
Go to the documentation of this file.
1 /****************************************************************************
2  *
3  * Filename: cpia2_usb.c
4  *
5  * Copyright 2001, STMicrolectronics, Inc.
6  * Contact: [email protected]
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 <[email protected]>
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 int 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  do_gettimeofday(&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 }
Generated on Thu Jan 10 2013 13:50:55 for Linux Kernel by   doxygen 1.8.2