Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sn9c102_core.c
Go to the documentation of this file.
1 /***************************************************************************
2  * V4L2 driver for SN9C1xx PC Camera Controllers *
3  * *
4  * Copyright (C) 2004-2007 by Luca Risolia <[email protected]> *
5  * *
6  * This program is free software; you can redistribute it and/or modify *
7  * it under the terms of the GNU General Public License as published by *
8  * the Free Software Foundation; either version 2 of the License, or *
9  * (at your option) any later version. *
10  * *
11  * This program is distributed in the hope that it will be useful, *
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14  * GNU General Public License for more details. *
15  * *
16  * You should have received a copy of the GNU General Public License *
17  * along with this program; if not, write to the Free Software *
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
19  ***************************************************************************/
20 
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/kernel.h>
24 #include <linux/param.h>
25 #include <linux/errno.h>
26 #include <linux/slab.h>
27 #include <linux/device.h>
28 #include <linux/fs.h>
29 #include <linux/delay.h>
30 #include <linux/compiler.h>
31 #include <linux/ioctl.h>
32 #include <linux/poll.h>
33 #include <linux/stat.h>
34 #include <linux/mm.h>
35 #include <linux/vmalloc.h>
36 #include <linux/version.h>
37 #include <linux/page-flags.h>
38 #include <asm/byteorder.h>
39 #include <asm/page.h>
40 #include <asm/uaccess.h>
41 
42 #include "sn9c102.h"
43 
44 /*****************************************************************************/
45 
46 #define SN9C102_MODULE_NAME "V4L2 driver for SN9C1xx PC Camera Controllers"
47 #define SN9C102_MODULE_ALIAS "sn9c1xx"
48 #define SN9C102_MODULE_AUTHOR "(C) 2004-2007 Luca Risolia"
49 #define SN9C102_AUTHOR_EMAIL "<[email protected]>"
50 #define SN9C102_MODULE_LICENSE "GPL"
51 #define SN9C102_MODULE_VERSION "1:1.48"
52 
53 /*****************************************************************************/
54 
55 MODULE_DEVICE_TABLE(usb, sn9c102_id_table);
56 
57 MODULE_AUTHOR(SN9C102_MODULE_AUTHOR " " SN9C102_AUTHOR_EMAIL);
58 MODULE_DESCRIPTION(SN9C102_MODULE_NAME);
59 MODULE_ALIAS(SN9C102_MODULE_ALIAS);
60 MODULE_VERSION(SN9C102_MODULE_VERSION);
61 MODULE_LICENSE(SN9C102_MODULE_LICENSE);
62 
63 static short video_nr[] = {[0 ... SN9C102_MAX_DEVICES-1] = -1};
64 module_param_array(video_nr, short, NULL, 0444);
65 MODULE_PARM_DESC(video_nr,
66  " <-1|n[,...]>"
67  "\nSpecify V4L2 minor mode number."
68  "\n-1 = use next available (default)"
69  "\n n = use minor number n (integer >= 0)"
70  "\nYou can specify up to "__MODULE_STRING(SN9C102_MAX_DEVICES)
71  " cameras this way."
72  "\nFor example:"
73  "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
74  "\nthe second camera and use auto for the first"
75  "\none and for every other camera."
76  "\n");
77 
78 static bool force_munmap[] = {[0 ... SN9C102_MAX_DEVICES-1] =
79  SN9C102_FORCE_MUNMAP};
80 module_param_array(force_munmap, bool, NULL, 0444);
81 MODULE_PARM_DESC(force_munmap,
82  " <0|1[,...]>"
83  "\nForce the application to unmap previously"
84  "\nmapped buffer memory before calling any VIDIOC_S_CROP or"
85  "\nVIDIOC_S_FMT ioctl's. Not all the applications support"
86  "\nthis feature. This parameter is specific for each"
87  "\ndetected camera."
88  "\n0 = do not force memory unmapping"
89  "\n1 = force memory unmapping (save memory)"
90  "\nDefault value is "__MODULE_STRING(SN9C102_FORCE_MUNMAP)"."
91  "\n");
92 
93 static unsigned int frame_timeout[] = {[0 ... SN9C102_MAX_DEVICES-1] =
94  SN9C102_FRAME_TIMEOUT};
95 module_param_array(frame_timeout, uint, NULL, 0644);
96 MODULE_PARM_DESC(frame_timeout,
97  " <0|n[,...]>"
98  "\nTimeout for a video frame in seconds before"
99  "\nreturning an I/O error; 0 for infinity."
100  "\nThis parameter is specific for each detected camera."
101  "\nDefault value is "__MODULE_STRING(SN9C102_FRAME_TIMEOUT)"."
102  "\n");
103 
104 #ifdef SN9C102_DEBUG
105 static unsigned short debug = SN9C102_DEBUG_LEVEL;
106 module_param(debug, ushort, 0644);
107 MODULE_PARM_DESC(debug,
108  " <n>"
109  "\nDebugging information level, from 0 to 3:"
110  "\n0 = none (use carefully)"
111  "\n1 = critical errors"
112  "\n2 = significant informations"
113  "\n3 = more verbose messages"
114  "\nLevel 3 is useful for testing only."
115  "\nDefault value is "__MODULE_STRING(SN9C102_DEBUG_LEVEL)"."
116  "\n");
117 #endif
118 
119 /*
120  Add the probe entries to this table. Be sure to add the entry in the right
121  place, since, on failure, the next probing routine is called according to
122  the order of the list below, from top to bottom.
123 */
124 static int (*sn9c102_sensor_table[])(struct sn9c102_device *) = {
125  &sn9c102_probe_hv7131d, /* strong detection based on SENSOR ids */
126  &sn9c102_probe_hv7131r, /* strong detection based on SENSOR ids */
127  &sn9c102_probe_mi0343, /* strong detection based on SENSOR ids */
128  &sn9c102_probe_mi0360, /* strong detection based on SENSOR ids */
129  &sn9c102_probe_mt9v111, /* strong detection based on SENSOR ids */
130  &sn9c102_probe_pas106b, /* strong detection based on SENSOR ids */
131  &sn9c102_probe_pas202bcb, /* strong detection based on SENSOR ids */
132  &sn9c102_probe_ov7630, /* strong detection based on SENSOR ids */
133  &sn9c102_probe_ov7660, /* strong detection based on SENSOR ids */
134  &sn9c102_probe_tas5110c1b, /* detection based on USB pid/vid */
135  &sn9c102_probe_tas5110d, /* detection based on USB pid/vid */
136  &sn9c102_probe_tas5130d1b, /* detection based on USB pid/vid */
137 };
138 
139 /*****************************************************************************/
140 
141 static u32
142 sn9c102_request_buffers(struct sn9c102_device* cam, u32 count,
143  enum sn9c102_io_method io)
144 {
145  struct v4l2_pix_format* p = &(cam->sensor.pix_format);
146  struct v4l2_rect* r = &(cam->sensor.cropcap.bounds);
147  size_t imagesize = cam->module_param.force_munmap || io == IO_READ ?
148  (p->width * p->height * p->priv) / 8 :
149  (r->width * r->height * p->priv) / 8;
150  void* buff = NULL;
151  u32 i;
152 
153  if (count > SN9C102_MAX_FRAMES)
154  count = SN9C102_MAX_FRAMES;
155 
156  if (cam->bridge == BRIDGE_SN9C105 || cam->bridge == BRIDGE_SN9C120)
157  imagesize += 589 + 2; /* length of JPEG header + EOI marker */
158 
159  cam->nbuffers = count;
160  while (cam->nbuffers > 0) {
161  if ((buff = vmalloc_32_user(cam->nbuffers *
162  PAGE_ALIGN(imagesize))))
163  break;
164  cam->nbuffers--;
165  }
166 
167  for (i = 0; i < cam->nbuffers; i++) {
168  cam->frame[i].bufmem = buff + i*PAGE_ALIGN(imagesize);
169  cam->frame[i].buf.index = i;
170  cam->frame[i].buf.m.offset = i*PAGE_ALIGN(imagesize);
171  cam->frame[i].buf.length = imagesize;
172  cam->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
173  cam->frame[i].buf.sequence = 0;
174  cam->frame[i].buf.field = V4L2_FIELD_NONE;
175  cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
176  cam->frame[i].buf.flags = 0;
177  }
178 
179  return cam->nbuffers;
180 }
181 
182 
183 static void sn9c102_release_buffers(struct sn9c102_device* cam)
184 {
185  if (cam->nbuffers) {
186  vfree(cam->frame[0].bufmem);
187  cam->nbuffers = 0;
188  }
189  cam->frame_current = NULL;
190 }
191 
192 
193 static void sn9c102_empty_framequeues(struct sn9c102_device* cam)
194 {
195  u32 i;
196 
197  INIT_LIST_HEAD(&cam->inqueue);
198  INIT_LIST_HEAD(&cam->outqueue);
199 
200  for (i = 0; i < SN9C102_MAX_FRAMES; i++) {
201  cam->frame[i].state = F_UNUSED;
202  cam->frame[i].buf.bytesused = 0;
203  }
204 }
205 
206 
207 static void sn9c102_requeue_outqueue(struct sn9c102_device* cam)
208 {
209  struct sn9c102_frame_t *i;
210 
211  list_for_each_entry(i, &cam->outqueue, frame) {
212  i->state = F_QUEUED;
213  list_add(&i->frame, &cam->inqueue);
214  }
215 
216  INIT_LIST_HEAD(&cam->outqueue);
217 }
218 
219 
220 static void sn9c102_queue_unusedframes(struct sn9c102_device* cam)
221 {
222  unsigned long lock_flags;
223  u32 i;
224 
225  for (i = 0; i < cam->nbuffers; i++)
226  if (cam->frame[i].state == F_UNUSED) {
227  cam->frame[i].state = F_QUEUED;
228  spin_lock_irqsave(&cam->queue_lock, lock_flags);
229  list_add_tail(&cam->frame[i].frame, &cam->inqueue);
230  spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
231  }
232 }
233 
234 /*****************************************************************************/
235 
236 /*
237  Write a sequence of count value/register pairs. Returns -1 after the first
238  failed write, or 0 for no errors.
239 */
240 int sn9c102_write_regs(struct sn9c102_device* cam, const u8 valreg[][2],
241  int count)
242 {
243  struct usb_device* udev = cam->usbdev;
244  u8* buff = cam->control_buffer;
245  int i, res;
246 
247  for (i = 0; i < count; i++) {
248  u8 index = valreg[i][1];
249 
250  /*
251  index is a u8, so it must be <256 and can't be out of range.
252  If we put in a check anyway, gcc annoys us with a warning
253  hat our check is useless. People get all uppity when they
254  see warnings in the kernel compile.
255  */
256 
257  *buff = valreg[i][0];
258 
259  res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08,
260  0x41, index, 0, buff, 1,
261  SN9C102_CTRL_TIMEOUT);
262 
263  if (res < 0) {
264  DBG(3, "Failed to write a register (value 0x%02X, "
265  "index 0x%02X, error %d)", *buff, index, res);
266  return -1;
267  }
268 
269  cam->reg[index] = *buff;
270  }
271 
272  return 0;
273 }
274 
275 
276 int sn9c102_write_reg(struct sn9c102_device* cam, u8 value, u16 index)
277 {
278  struct usb_device* udev = cam->usbdev;
279  u8* buff = cam->control_buffer;
280  int res;
281 
282  if (index >= ARRAY_SIZE(cam->reg))
283  return -1;
284 
285  *buff = value;
286 
287  res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
288  index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
289  if (res < 0) {
290  DBG(3, "Failed to write a register (value 0x%02X, index "
291  "0x%02X, error %d)", value, index, res);
292  return -1;
293  }
294 
295  cam->reg[index] = value;
296 
297  return 0;
298 }
299 
300 
301 /* NOTE: with the SN9C10[123] reading some registers always returns 0 */
302 int sn9c102_read_reg(struct sn9c102_device* cam, u16 index)
303 {
304  struct usb_device* udev = cam->usbdev;
305  u8* buff = cam->control_buffer;
306  int res;
307 
308  res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
309  index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
310  if (res < 0)
311  DBG(3, "Failed to read a register (index 0x%02X, error %d)",
312  index, res);
313 
314  return (res >= 0) ? (int)(*buff) : -1;
315 }
316 
317 
318 int sn9c102_pread_reg(struct sn9c102_device* cam, u16 index)
319 {
320  if (index >= ARRAY_SIZE(cam->reg))
321  return -1;
322 
323  return cam->reg[index];
324 }
325 
326 
327 static int
328 sn9c102_i2c_wait(struct sn9c102_device* cam,
329  const struct sn9c102_sensor* sensor)
330 {
331  int i, r;
332 
333  for (i = 1; i <= 5; i++) {
334  r = sn9c102_read_reg(cam, 0x08);
335  if (r < 0)
336  return -EIO;
337  if (r & 0x04)
338  return 0;
339  if (sensor->frequency & SN9C102_I2C_400KHZ)
340  udelay(5*16);
341  else
342  udelay(16*16);
343  }
344  return -EBUSY;
345 }
346 
347 
348 static int
349 sn9c102_i2c_detect_read_error(struct sn9c102_device* cam,
350  const struct sn9c102_sensor* sensor)
351 {
352  int r , err = 0;
353 
354  r = sn9c102_read_reg(cam, 0x08);
355  if (r < 0)
356  err += r;
357 
358  if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
359  if (!(r & 0x08))
360  err += -1;
361  } else {
362  if (r & 0x08)
363  err += -1;
364  }
365 
366  return err ? -EIO : 0;
367 }
368 
369 
370 static int
371 sn9c102_i2c_detect_write_error(struct sn9c102_device* cam,
372  const struct sn9c102_sensor* sensor)
373 {
374  int r;
375  r = sn9c102_read_reg(cam, 0x08);
376  return (r < 0 || (r >= 0 && (r & 0x08))) ? -EIO : 0;
377 }
378 
379 
380 int
381 sn9c102_i2c_try_raw_read(struct sn9c102_device* cam,
382  const struct sn9c102_sensor* sensor, u8 data0,
383  u8 data1, u8 n, u8 buffer[])
384 {
385  struct usb_device* udev = cam->usbdev;
386  u8* data = cam->control_buffer;
387  int i = 0, err = 0, res;
388 
389  /* Write cycle */
390  data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
391  ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) | 0x10;
392  data[1] = data0; /* I2C slave id */
393  data[2] = data1; /* address */
394  data[7] = 0x10;
395  res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
396  0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
397  if (res < 0)
398  err += res;
399 
400  err += sn9c102_i2c_wait(cam, sensor);
401 
402  /* Read cycle - n bytes */
403  data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
404  ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) |
405  (n << 4) | 0x02;
406  data[1] = data0;
407  data[7] = 0x10;
408  res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
409  0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
410  if (res < 0)
411  err += res;
412 
413  err += sn9c102_i2c_wait(cam, sensor);
414 
415  /* The first read byte will be placed in data[4] */
416  res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
417  0x0a, 0, data, 5, SN9C102_CTRL_TIMEOUT);
418  if (res < 0)
419  err += res;
420 
421  err += sn9c102_i2c_detect_read_error(cam, sensor);
422 
423  PDBGG("I2C read: address 0x%02X, first read byte: 0x%02X", data1,
424  data[4]);
425 
426  if (err) {
427  DBG(3, "I2C read failed for %s image sensor", sensor->name);
428  return -1;
429  }
430 
431  if (buffer)
432  for (i = 0; i < n && i < 5; i++)
433  buffer[n-i-1] = data[4-i];
434 
435  return (int)data[4];
436 }
437 
438 
439 int
440 sn9c102_i2c_try_raw_write(struct sn9c102_device* cam,
441  const struct sn9c102_sensor* sensor, u8 n, u8 data0,
442  u8 data1, u8 data2, u8 data3, u8 data4, u8 data5)
443 {
444  struct usb_device* udev = cam->usbdev;
445  u8* data = cam->control_buffer;
446  int err = 0, res;
447 
448  /* Write cycle. It usually is address + value */
449  data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
450  ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0)
451  | ((n - 1) << 4);
452  data[1] = data0;
453  data[2] = data1;
454  data[3] = data2;
455  data[4] = data3;
456  data[5] = data4;
457  data[6] = data5;
458  data[7] = 0x17;
459  res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
460  0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
461  if (res < 0)
462  err += res;
463 
464  err += sn9c102_i2c_wait(cam, sensor);
465  err += sn9c102_i2c_detect_write_error(cam, sensor);
466 
467  if (err)
468  DBG(3, "I2C write failed for %s image sensor", sensor->name);
469 
470  PDBGG("I2C raw write: %u bytes, data0 = 0x%02X, data1 = 0x%02X, "
471  "data2 = 0x%02X, data3 = 0x%02X, data4 = 0x%02X, data5 = 0x%02X",
472  n, data0, data1, data2, data3, data4, data5);
473 
474  return err ? -1 : 0;
475 }
476 
477 
478 int
479 sn9c102_i2c_try_read(struct sn9c102_device* cam,
480  const struct sn9c102_sensor* sensor, u8 address)
481 {
482  return sn9c102_i2c_try_raw_read(cam, sensor, sensor->i2c_slave_id,
483  address, 1, NULL);
484 }
485 
486 
487 static int sn9c102_i2c_try_write(struct sn9c102_device* cam,
488  const struct sn9c102_sensor* sensor,
489  u8 address, u8 value)
490 {
491  return sn9c102_i2c_try_raw_write(cam, sensor, 3,
492  sensor->i2c_slave_id, address,
493  value, 0, 0, 0);
494 }
495 
496 
497 int sn9c102_i2c_read(struct sn9c102_device* cam, u8 address)
498 {
499  return sn9c102_i2c_try_read(cam, &cam->sensor, address);
500 }
501 
502 
503 int sn9c102_i2c_write(struct sn9c102_device* cam, u8 address, u8 value)
504 {
505  return sn9c102_i2c_try_write(cam, &cam->sensor, address, value);
506 }
507 
508 /*****************************************************************************/
509 
510 static size_t sn9c102_sof_length(struct sn9c102_device* cam)
511 {
512  switch (cam->bridge) {
513  case BRIDGE_SN9C101:
514  case BRIDGE_SN9C102:
515  return 12;
516  case BRIDGE_SN9C103:
517  return 18;
518  case BRIDGE_SN9C105:
519  case BRIDGE_SN9C120:
520  return 62;
521  }
522 
523  return 0;
524 }
525 
526 
527 static void*
528 sn9c102_find_sof_header(struct sn9c102_device* cam, void* mem, size_t len)
529 {
530  static const char marker[6] = {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96};
531  const char *m = mem;
532  size_t soflen = 0, i, j;
533 
534  soflen = sn9c102_sof_length(cam);
535 
536  for (i = 0; i < len; i++) {
537  size_t b;
538 
539  /* Read the variable part of the header */
540  if (unlikely(cam->sof.bytesread >= sizeof(marker))) {
541  cam->sof.header[cam->sof.bytesread] = *(m+i);
542  if (++cam->sof.bytesread == soflen) {
543  cam->sof.bytesread = 0;
544  return mem + i;
545  }
546  continue;
547  }
548 
549  /* Search for the SOF marker (fixed part) in the header */
550  for (j = 0, b=cam->sof.bytesread; j+b < sizeof(marker); j++) {
551  if (unlikely(i+j == len))
552  return NULL;
553  if (*(m+i+j) == marker[cam->sof.bytesread]) {
554  cam->sof.header[cam->sof.bytesread] = *(m+i+j);
555  if (++cam->sof.bytesread == sizeof(marker)) {
556  PDBGG("Bytes to analyze: %zd. SOF "
557  "starts at byte #%zd", len, i);
558  i += j+1;
559  break;
560  }
561  } else {
562  cam->sof.bytesread = 0;
563  break;
564  }
565  }
566  }
567 
568  return NULL;
569 }
570 
571 
572 static void*
573 sn9c102_find_eof_header(struct sn9c102_device* cam, void* mem, size_t len)
574 {
575  static const u8 eof_header[4][4] = {
576  {0x00, 0x00, 0x00, 0x00},
577  {0x40, 0x00, 0x00, 0x00},
578  {0x80, 0x00, 0x00, 0x00},
579  {0xc0, 0x00, 0x00, 0x00},
580  };
581  size_t i, j;
582 
583  /* The EOF header does not exist in compressed data */
584  if (cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X ||
585  cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
586  return NULL;
587 
588  /*
589  The EOF header might cross the packet boundary, but this is not a
590  problem, since the end of a frame is determined by checking its size
591  in the first place.
592  */
593  for (i = 0; (len >= 4) && (i <= len - 4); i++)
594  for (j = 0; j < ARRAY_SIZE(eof_header); j++)
595  if (!memcmp(mem + i, eof_header[j], 4))
596  return mem + i;
597 
598  return NULL;
599 }
600 
601 
602 static void
603 sn9c102_write_jpegheader(struct sn9c102_device* cam, struct sn9c102_frame_t* f)
604 {
605  static const u8 jpeg_header[589] = {
606  0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x06, 0x04, 0x05,
607  0x06, 0x05, 0x04, 0x06, 0x06, 0x05, 0x06, 0x07, 0x07, 0x06,
608  0x08, 0x0a, 0x10, 0x0a, 0x0a, 0x09, 0x09, 0x0a, 0x14, 0x0e,
609  0x0f, 0x0c, 0x10, 0x17, 0x14, 0x18, 0x18, 0x17, 0x14, 0x16,
610  0x16, 0x1a, 0x1d, 0x25, 0x1f, 0x1a, 0x1b, 0x23, 0x1c, 0x16,
611  0x16, 0x20, 0x2c, 0x20, 0x23, 0x26, 0x27, 0x29, 0x2a, 0x29,
612  0x19, 0x1f, 0x2d, 0x30, 0x2d, 0x28, 0x30, 0x25, 0x28, 0x29,
613  0x28, 0x01, 0x07, 0x07, 0x07, 0x0a, 0x08, 0x0a, 0x13, 0x0a,
614  0x0a, 0x13, 0x28, 0x1a, 0x16, 0x1a, 0x28, 0x28, 0x28, 0x28,
615  0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
616  0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
617  0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
618  0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
619  0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0xff, 0xc4, 0x01, 0xa2,
620  0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
621  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02,
622  0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x01,
623  0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
624  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
625  0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x10, 0x00,
626  0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04,
627  0x04, 0x00, 0x00, 0x01, 0x7d, 0x01, 0x02, 0x03, 0x00, 0x04,
628  0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
629  0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23,
630  0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62,
631  0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25,
632  0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38,
633  0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a,
634  0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64,
635  0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76,
636  0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
637  0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
638  0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
639  0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2,
640  0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3,
641  0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3,
642  0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3,
643  0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0x11, 0x00, 0x02,
644  0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04,
645  0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04,
646  0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
647  0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1,
648  0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1,
649  0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19,
650  0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
651  0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a,
652  0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64,
653  0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76,
654  0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
655  0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
656  0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
657  0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba,
658  0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
659  0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3,
660  0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4,
661  0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xc0, 0x00, 0x11,
662  0x08, 0x01, 0xe0, 0x02, 0x80, 0x03, 0x01, 0x21, 0x00, 0x02,
663  0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xda, 0x00, 0x0c, 0x03,
664  0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00
665  };
666  u8 *pos = f->bufmem;
667 
668  memcpy(pos, jpeg_header, sizeof(jpeg_header));
669  *(pos + 6) = 0x00;
670  *(pos + 7 + 64) = 0x01;
671  if (cam->compression.quality == 0) {
672  memcpy(pos + 7, SN9C102_Y_QTABLE0, 64);
673  memcpy(pos + 8 + 64, SN9C102_UV_QTABLE0, 64);
674  } else if (cam->compression.quality == 1) {
675  memcpy(pos + 7, SN9C102_Y_QTABLE1, 64);
676  memcpy(pos + 8 + 64, SN9C102_UV_QTABLE1, 64);
677  }
678  *(pos + 564) = cam->sensor.pix_format.width & 0xFF;
679  *(pos + 563) = (cam->sensor.pix_format.width >> 8) & 0xFF;
680  *(pos + 562) = cam->sensor.pix_format.height & 0xFF;
681  *(pos + 561) = (cam->sensor.pix_format.height >> 8) & 0xFF;
682  *(pos + 567) = 0x21;
683 
684  f->buf.bytesused += sizeof(jpeg_header);
685 }
686 
687 
688 static void sn9c102_urb_complete(struct urb *urb)
689 {
690  struct sn9c102_device* cam = urb->context;
691  struct sn9c102_frame_t** f;
692  size_t imagesize, soflen;
693  u8 i;
694  int err = 0;
695 
696  if (urb->status == -ENOENT)
697  return;
698 
699  f = &cam->frame_current;
700 
701  if (cam->stream == STREAM_INTERRUPT) {
702  cam->stream = STREAM_OFF;
703  if ((*f))
704  (*f)->state = F_QUEUED;
705  cam->sof.bytesread = 0;
706  DBG(3, "Stream interrupted by application");
707  wake_up(&cam->wait_stream);
708  }
709 
710  if (cam->state & DEV_DISCONNECTED)
711  return;
712 
713  if (cam->state & DEV_MISCONFIGURED) {
714  wake_up_interruptible(&cam->wait_frame);
715  return;
716  }
717 
718  if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
719  goto resubmit_urb;
720 
721  if (!(*f))
722  (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
723  frame);
724 
725  imagesize = (cam->sensor.pix_format.width *
726  cam->sensor.pix_format.height *
727  cam->sensor.pix_format.priv) / 8;
728  if (cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
729  imagesize += 589; /* length of jpeg header */
730  soflen = sn9c102_sof_length(cam);
731 
732  for (i = 0; i < urb->number_of_packets; i++) {
733  unsigned int img, len, status;
734  void *pos, *sof, *eof;
735 
736  len = urb->iso_frame_desc[i].actual_length;
737  status = urb->iso_frame_desc[i].status;
738  pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
739 
740  if (status) {
741  DBG(3, "Error in isochronous frame");
742  (*f)->state = F_ERROR;
743  cam->sof.bytesread = 0;
744  continue;
745  }
746 
747  PDBGG("Isochrnous frame: length %u, #%u i", len, i);
748 
749 redo:
750  sof = sn9c102_find_sof_header(cam, pos, len);
751  if (likely(!sof)) {
752  eof = sn9c102_find_eof_header(cam, pos, len);
753  if ((*f)->state == F_GRABBING) {
754 end_of_frame:
755  img = len;
756 
757  if (eof)
758  img = (eof > pos) ? eof - pos - 1 : 0;
759 
760  if ((*f)->buf.bytesused + img > imagesize) {
761  u32 b;
762  b = (*f)->buf.bytesused + img -
763  imagesize;
764  img = imagesize - (*f)->buf.bytesused;
765  PDBGG("Expected EOF not found: video "
766  "frame cut");
767  if (eof)
768  DBG(3, "Exceeded limit: +%u "
769  "bytes", (unsigned)(b));
770  }
771 
772  memcpy((*f)->bufmem + (*f)->buf.bytesused, pos,
773  img);
774 
775  if ((*f)->buf.bytesused == 0)
776  do_gettimeofday(&(*f)->buf.timestamp);
777 
778  (*f)->buf.bytesused += img;
779 
780  if ((*f)->buf.bytesused == imagesize ||
781  ((cam->sensor.pix_format.pixelformat ==
782  V4L2_PIX_FMT_SN9C10X ||
783  cam->sensor.pix_format.pixelformat ==
784  V4L2_PIX_FMT_JPEG) && eof)) {
785  u32 b;
786 
787  b = (*f)->buf.bytesused;
788  (*f)->state = F_DONE;
789  (*f)->buf.sequence= ++cam->frame_count;
790 
791  spin_lock(&cam->queue_lock);
792  list_move_tail(&(*f)->frame,
793  &cam->outqueue);
794  if (!list_empty(&cam->inqueue))
795  (*f) = list_entry(
796  cam->inqueue.next,
797  struct sn9c102_frame_t,
798  frame );
799  else
800  (*f) = NULL;
801  spin_unlock(&cam->queue_lock);
802 
803  memcpy(cam->sysfs.frame_header,
804  cam->sof.header, soflen);
805 
806  DBG(3, "Video frame captured: %lu "
807  "bytes", (unsigned long)(b));
808 
809  if (!(*f))
810  goto resubmit_urb;
811 
812  } else if (eof) {
813  (*f)->state = F_ERROR;
814  DBG(3, "Not expected EOF after %lu "
815  "bytes of image data",
816  (unsigned long)
817  ((*f)->buf.bytesused));
818  }
819 
820  if (sof) /* (1) */
821  goto start_of_frame;
822 
823  } else if (eof) {
824  DBG(3, "EOF without SOF");
825  continue;
826 
827  } else {
828  PDBGG("Ignoring pointless isochronous frame");
829  continue;
830  }
831 
832  } else if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR) {
833 start_of_frame:
834  (*f)->state = F_GRABBING;
835  (*f)->buf.bytesused = 0;
836  len -= (sof - pos);
837  pos = sof;
838  if (cam->sensor.pix_format.pixelformat ==
839  V4L2_PIX_FMT_JPEG)
840  sn9c102_write_jpegheader(cam, (*f));
841  DBG(3, "SOF detected: new video frame");
842  if (len)
843  goto redo;
844 
845  } else if ((*f)->state == F_GRABBING) {
846  eof = sn9c102_find_eof_header(cam, pos, len);
847  if (eof && eof < sof)
848  goto end_of_frame; /* (1) */
849  else {
850  if (cam->sensor.pix_format.pixelformat ==
851  V4L2_PIX_FMT_SN9C10X ||
852  cam->sensor.pix_format.pixelformat ==
853  V4L2_PIX_FMT_JPEG) {
854  if (sof - pos >= soflen) {
855  eof = sof - soflen;
856  } else { /* remove header */
857  eof = pos;
858  (*f)->buf.bytesused -=
859  (soflen - (sof - pos));
860  }
861  goto end_of_frame;
862  } else {
863  DBG(3, "SOF before expected EOF after "
864  "%lu bytes of image data",
865  (unsigned long)
866  ((*f)->buf.bytesused));
867  goto start_of_frame;
868  }
869  }
870  }
871  }
872 
873 resubmit_urb:
874  urb->dev = cam->usbdev;
875  err = usb_submit_urb(urb, GFP_ATOMIC);
876  if (err < 0 && err != -EPERM) {
877  cam->state |= DEV_MISCONFIGURED;
878  DBG(1, "usb_submit_urb() failed");
879  }
880 
881  wake_up_interruptible(&cam->wait_frame);
882 }
883 
884 
885 static int sn9c102_start_transfer(struct sn9c102_device* cam)
886 {
887  struct usb_device *udev = cam->usbdev;
888  struct urb* urb;
889  struct usb_host_interface* altsetting = usb_altnum_to_altsetting(
890  usb_ifnum_to_if(udev, 0),
891  SN9C102_ALTERNATE_SETTING);
892  const unsigned int psz = le16_to_cpu(altsetting->
893  endpoint[0].desc.wMaxPacketSize);
894  s8 i, j;
895  int err = 0;
896 
897  for (i = 0; i < SN9C102_URBS; i++) {
898  cam->transfer_buffer[i] = kzalloc(SN9C102_ISO_PACKETS * psz,
899  GFP_KERNEL);
900  if (!cam->transfer_buffer[i]) {
901  err = -ENOMEM;
902  DBG(1, "Not enough memory");
903  goto free_buffers;
904  }
905  }
906 
907  for (i = 0; i < SN9C102_URBS; i++) {
908  urb = usb_alloc_urb(SN9C102_ISO_PACKETS, GFP_KERNEL);
909  cam->urb[i] = urb;
910  if (!urb) {
911  err = -ENOMEM;
912  DBG(1, "usb_alloc_urb() failed");
913  goto free_urbs;
914  }
915  urb->dev = udev;
916  urb->context = cam;
917  urb->pipe = usb_rcvisocpipe(udev, 1);
918  urb->transfer_flags = URB_ISO_ASAP;
919  urb->number_of_packets = SN9C102_ISO_PACKETS;
920  urb->complete = sn9c102_urb_complete;
921  urb->transfer_buffer = cam->transfer_buffer[i];
922  urb->transfer_buffer_length = psz * SN9C102_ISO_PACKETS;
923  urb->interval = 1;
924  for (j = 0; j < SN9C102_ISO_PACKETS; j++) {
925  urb->iso_frame_desc[j].offset = psz * j;
926  urb->iso_frame_desc[j].length = psz;
927  }
928  }
929 
930  /* Enable video */
931  if (!(cam->reg[0x01] & 0x04)) {
932  err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
933  if (err) {
934  err = -EIO;
935  DBG(1, "I/O hardware error");
936  goto free_urbs;
937  }
938  }
939 
940  err = usb_set_interface(udev, 0, SN9C102_ALTERNATE_SETTING);
941  if (err) {
942  DBG(1, "usb_set_interface() failed");
943  goto free_urbs;
944  }
945 
946  cam->frame_current = NULL;
947  cam->sof.bytesread = 0;
948 
949  for (i = 0; i < SN9C102_URBS; i++) {
950  err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
951  if (err) {
952  for (j = i-1; j >= 0; j--)
953  usb_kill_urb(cam->urb[j]);
954  DBG(1, "usb_submit_urb() failed, error %d", err);
955  goto free_urbs;
956  }
957  }
958 
959  return 0;
960 
961 free_urbs:
962  for (i = 0; (i < SN9C102_URBS) && cam->urb[i]; i++)
963  usb_free_urb(cam->urb[i]);
964 
965 free_buffers:
966  for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
967  kfree(cam->transfer_buffer[i]);
968 
969  return err;
970 }
971 
972 
973 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
974 {
975  struct usb_device *udev = cam->usbdev;
976  s8 i;
977  int err = 0;
978 
979  if (cam->state & DEV_DISCONNECTED)
980  return 0;
981 
982  for (i = SN9C102_URBS-1; i >= 0; i--) {
983  usb_kill_urb(cam->urb[i]);
984  usb_free_urb(cam->urb[i]);
985  kfree(cam->transfer_buffer[i]);
986  }
987 
988  err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
989  if (err)
990  DBG(3, "usb_set_interface() failed");
991 
992  return err;
993 }
994 
995 
996 static int sn9c102_stream_interrupt(struct sn9c102_device* cam)
997 {
998  cam->stream = STREAM_INTERRUPT;
999  wait_event_timeout(cam->wait_stream,
1000  (cam->stream == STREAM_OFF) ||
1001  (cam->state & DEV_DISCONNECTED),
1002  SN9C102_URB_TIMEOUT);
1003  if (cam->state & DEV_DISCONNECTED)
1004  return -ENODEV;
1005  else if (cam->stream != STREAM_OFF) {
1006  cam->state |= DEV_MISCONFIGURED;
1007  DBG(1, "URB timeout reached. The camera is misconfigured. "
1008  "To use it, close and open %s again.",
1009  video_device_node_name(cam->v4ldev));
1010  return -EIO;
1011  }
1012 
1013  return 0;
1014 }
1015 
1016 /*****************************************************************************/
1017 
1018 #ifdef CONFIG_VIDEO_ADV_DEBUG
1019 static u16 sn9c102_strtou16(const char* buff, size_t len, ssize_t* count)
1020 {
1021  char str[7];
1022  char* endp;
1023  unsigned long val;
1024 
1025  if (len < 6) {
1026  strncpy(str, buff, len);
1027  str[len] = '\0';
1028  } else {
1029  strncpy(str, buff, 6);
1030  str[6] = '\0';
1031  }
1032 
1033  val = simple_strtoul(str, &endp, 0);
1034 
1035  *count = 0;
1036  if (val <= 0xffff)
1037  *count = (ssize_t)(endp - str);
1038  if ((*count) && (len == *count+1) && (buff[*count] == '\n'))
1039  *count += 1;
1040 
1041  return (u16)val;
1042 }
1043 
1044 /*
1045  NOTE 1: being inside one of the following methods implies that the v4l
1046  device exists for sure (see kobjects and reference counters)
1047  NOTE 2: buffers are PAGE_SIZE long
1048 */
1049 
1050 static ssize_t sn9c102_show_reg(struct device* cd,
1051  struct device_attribute *attr, char* buf)
1052 {
1053  struct sn9c102_device* cam;
1054  ssize_t count;
1055 
1056  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1057  return -ERESTARTSYS;
1058 
1059  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1060  if (!cam) {
1061  mutex_unlock(&sn9c102_sysfs_lock);
1062  return -ENODEV;
1063  }
1064 
1065  count = sprintf(buf, "%u\n", cam->sysfs.reg);
1066 
1067  mutex_unlock(&sn9c102_sysfs_lock);
1068 
1069  return count;
1070 }
1071 
1072 
1073 static ssize_t
1074 sn9c102_store_reg(struct device* cd, struct device_attribute *attr,
1075  const char* buf, size_t len)
1076 {
1077  struct sn9c102_device* cam;
1078  u16 index;
1079  ssize_t count;
1080 
1081  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1082  return -ERESTARTSYS;
1083 
1084  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1085  if (!cam) {
1086  mutex_unlock(&sn9c102_sysfs_lock);
1087  return -ENODEV;
1088  }
1089 
1090  index = sn9c102_strtou16(buf, len, &count);
1091  if (index >= ARRAY_SIZE(cam->reg) || !count) {
1092  mutex_unlock(&sn9c102_sysfs_lock);
1093  return -EINVAL;
1094  }
1095 
1096  cam->sysfs.reg = index;
1097 
1098  DBG(2, "Moved SN9C1XX register index to 0x%02X", cam->sysfs.reg);
1099  DBG(3, "Written bytes: %zd", count);
1100 
1101  mutex_unlock(&sn9c102_sysfs_lock);
1102 
1103  return count;
1104 }
1105 
1106 
1107 static ssize_t sn9c102_show_val(struct device* cd,
1108  struct device_attribute *attr, char* buf)
1109 {
1110  struct sn9c102_device* cam;
1111  ssize_t count;
1112  int val;
1113 
1114  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1115  return -ERESTARTSYS;
1116 
1117  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1118  if (!cam) {
1119  mutex_unlock(&sn9c102_sysfs_lock);
1120  return -ENODEV;
1121  }
1122 
1123  if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
1124  mutex_unlock(&sn9c102_sysfs_lock);
1125  return -EIO;
1126  }
1127 
1128  count = sprintf(buf, "%d\n", val);
1129 
1130  DBG(3, "Read bytes: %zd, value: %d", count, val);
1131 
1132  mutex_unlock(&sn9c102_sysfs_lock);
1133 
1134  return count;
1135 }
1136 
1137 
1138 static ssize_t
1139 sn9c102_store_val(struct device* cd, struct device_attribute *attr,
1140  const char* buf, size_t len)
1141 {
1142  struct sn9c102_device* cam;
1143  u16 value;
1144  ssize_t count;
1145  int err;
1146 
1147  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1148  return -ERESTARTSYS;
1149 
1150  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1151  if (!cam) {
1152  mutex_unlock(&sn9c102_sysfs_lock);
1153  return -ENODEV;
1154  }
1155 
1156  value = sn9c102_strtou16(buf, len, &count);
1157  if (!count) {
1158  mutex_unlock(&sn9c102_sysfs_lock);
1159  return -EINVAL;
1160  }
1161 
1162  err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
1163  if (err) {
1164  mutex_unlock(&sn9c102_sysfs_lock);
1165  return -EIO;
1166  }
1167 
1168  DBG(2, "Written SN9C1XX reg. 0x%02X, val. 0x%02X",
1169  cam->sysfs.reg, value);
1170  DBG(3, "Written bytes: %zd", count);
1171 
1172  mutex_unlock(&sn9c102_sysfs_lock);
1173 
1174  return count;
1175 }
1176 
1177 
1178 static ssize_t sn9c102_show_i2c_reg(struct device* cd,
1179  struct device_attribute *attr, char* buf)
1180 {
1181  struct sn9c102_device* cam;
1182  ssize_t count;
1183 
1184  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1185  return -ERESTARTSYS;
1186 
1187  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1188  if (!cam) {
1189  mutex_unlock(&sn9c102_sysfs_lock);
1190  return -ENODEV;
1191  }
1192 
1193  count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
1194 
1195  DBG(3, "Read bytes: %zd", count);
1196 
1197  mutex_unlock(&sn9c102_sysfs_lock);
1198 
1199  return count;
1200 }
1201 
1202 
1203 static ssize_t
1204 sn9c102_store_i2c_reg(struct device* cd, struct device_attribute *attr,
1205  const char* buf, size_t len)
1206 {
1207  struct sn9c102_device* cam;
1208  u16 index;
1209  ssize_t count;
1210 
1211  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1212  return -ERESTARTSYS;
1213 
1214  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1215  if (!cam) {
1216  mutex_unlock(&sn9c102_sysfs_lock);
1217  return -ENODEV;
1218  }
1219 
1220  index = sn9c102_strtou16(buf, len, &count);
1221  if (!count) {
1222  mutex_unlock(&sn9c102_sysfs_lock);
1223  return -EINVAL;
1224  }
1225 
1226  cam->sysfs.i2c_reg = index;
1227 
1228  DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg);
1229  DBG(3, "Written bytes: %zd", count);
1230 
1231  mutex_unlock(&sn9c102_sysfs_lock);
1232 
1233  return count;
1234 }
1235 
1236 
1237 static ssize_t sn9c102_show_i2c_val(struct device* cd,
1238  struct device_attribute *attr, char* buf)
1239 {
1240  struct sn9c102_device* cam;
1241  ssize_t count;
1242  int val;
1243 
1244  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1245  return -ERESTARTSYS;
1246 
1247  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1248  if (!cam) {
1249  mutex_unlock(&sn9c102_sysfs_lock);
1250  return -ENODEV;
1251  }
1252 
1253  if (!(cam->sensor.sysfs_ops & SN9C102_I2C_READ)) {
1254  mutex_unlock(&sn9c102_sysfs_lock);
1255  return -ENOSYS;
1256  }
1257 
1258  if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1259  mutex_unlock(&sn9c102_sysfs_lock);
1260  return -EIO;
1261  }
1262 
1263  count = sprintf(buf, "%d\n", val);
1264 
1265  DBG(3, "Read bytes: %zd, value: %d", count, val);
1266 
1267  mutex_unlock(&sn9c102_sysfs_lock);
1268 
1269  return count;
1270 }
1271 
1272 
1273 static ssize_t
1274 sn9c102_store_i2c_val(struct device* cd, struct device_attribute *attr,
1275  const char* buf, size_t len)
1276 {
1277  struct sn9c102_device* cam;
1278  u16 value;
1279  ssize_t count;
1280  int err;
1281 
1282  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1283  return -ERESTARTSYS;
1284 
1285  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1286  if (!cam) {
1287  mutex_unlock(&sn9c102_sysfs_lock);
1288  return -ENODEV;
1289  }
1290 
1291  if (!(cam->sensor.sysfs_ops & SN9C102_I2C_WRITE)) {
1292  mutex_unlock(&sn9c102_sysfs_lock);
1293  return -ENOSYS;
1294  }
1295 
1296  value = sn9c102_strtou16(buf, len, &count);
1297  if (!count) {
1298  mutex_unlock(&sn9c102_sysfs_lock);
1299  return -EINVAL;
1300  }
1301 
1302  err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1303  if (err) {
1304  mutex_unlock(&sn9c102_sysfs_lock);
1305  return -EIO;
1306  }
1307 
1308  DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1309  cam->sysfs.i2c_reg, value);
1310  DBG(3, "Written bytes: %zd", count);
1311 
1312  mutex_unlock(&sn9c102_sysfs_lock);
1313 
1314  return count;
1315 }
1316 
1317 
1318 static ssize_t
1319 sn9c102_store_green(struct device* cd, struct device_attribute *attr,
1320  const char* buf, size_t len)
1321 {
1322  struct sn9c102_device* cam;
1323  enum sn9c102_bridge bridge;
1324  ssize_t res = 0;
1325  u16 value;
1326  ssize_t count;
1327 
1328  if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1329  return -ERESTARTSYS;
1330 
1331  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1332  if (!cam) {
1333  mutex_unlock(&sn9c102_sysfs_lock);
1334  return -ENODEV;
1335  }
1336 
1337  bridge = cam->bridge;
1338 
1339  mutex_unlock(&sn9c102_sysfs_lock);
1340 
1341  value = sn9c102_strtou16(buf, len, &count);
1342  if (!count)
1343  return -EINVAL;
1344 
1345  switch (bridge) {
1346  case BRIDGE_SN9C101:
1347  case BRIDGE_SN9C102:
1348  if (value > 0x0f)
1349  return -EINVAL;
1350  if ((res = sn9c102_store_reg(cd, attr, "0x11", 4)) >= 0)
1351  res = sn9c102_store_val(cd, attr, buf, len);
1352  break;
1353  case BRIDGE_SN9C103:
1354  case BRIDGE_SN9C105:
1355  case BRIDGE_SN9C120:
1356  if (value > 0x7f)
1357  return -EINVAL;
1358  if ((res = sn9c102_store_reg(cd, attr, "0x07", 4)) >= 0)
1359  res = sn9c102_store_val(cd, attr, buf, len);
1360  break;
1361  }
1362 
1363  return res;
1364 }
1365 
1366 
1367 static ssize_t
1368 sn9c102_store_blue(struct device* cd, struct device_attribute *attr,
1369  const char* buf, size_t len)
1370 {
1371  ssize_t res = 0;
1372  u16 value;
1373  ssize_t count;
1374 
1375  value = sn9c102_strtou16(buf, len, &count);
1376  if (!count || value > 0x7f)
1377  return -EINVAL;
1378 
1379  if ((res = sn9c102_store_reg(cd, attr, "0x06", 4)) >= 0)
1380  res = sn9c102_store_val(cd, attr, buf, len);
1381 
1382  return res;
1383 }
1384 
1385 
1386 static ssize_t
1387 sn9c102_store_red(struct device* cd, struct device_attribute *attr,
1388  const char* buf, size_t len)
1389 {
1390  ssize_t res = 0;
1391  u16 value;
1392  ssize_t count;
1393 
1394  value = sn9c102_strtou16(buf, len, &count);
1395  if (!count || value > 0x7f)
1396  return -EINVAL;
1397 
1398  if ((res = sn9c102_store_reg(cd, attr, "0x05", 4)) >= 0)
1399  res = sn9c102_store_val(cd, attr, buf, len);
1400 
1401  return res;
1402 }
1403 
1404 
1405 static ssize_t sn9c102_show_frame_header(struct device* cd,
1406  struct device_attribute *attr,
1407  char* buf)
1408 {
1409  struct sn9c102_device* cam;
1410  ssize_t count;
1411 
1412  cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1413  if (!cam)
1414  return -ENODEV;
1415 
1416  count = sizeof(cam->sysfs.frame_header);
1417  memcpy(buf, cam->sysfs.frame_header, count);
1418 
1419  DBG(3, "Frame header, read bytes: %zd", count);
1420 
1421  return count;
1422 }
1423 
1424 
1425 static DEVICE_ATTR(reg, S_IRUGO | S_IWUSR, sn9c102_show_reg, sn9c102_store_reg);
1426 static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, sn9c102_show_val, sn9c102_store_val);
1427 static DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
1428  sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
1429 static DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
1430  sn9c102_show_i2c_val, sn9c102_store_i2c_val);
1431 static DEVICE_ATTR(green, S_IWUSR, NULL, sn9c102_store_green);
1432 static DEVICE_ATTR(blue, S_IWUSR, NULL, sn9c102_store_blue);
1433 static DEVICE_ATTR(red, S_IWUSR, NULL, sn9c102_store_red);
1434 static DEVICE_ATTR(frame_header, S_IRUGO, sn9c102_show_frame_header, NULL);
1435 
1436 
1437 static int sn9c102_create_sysfs(struct sn9c102_device* cam)
1438 {
1439  struct device *dev = &(cam->v4ldev->dev);
1440  int err = 0;
1441 
1442  if ((err = device_create_file(dev, &dev_attr_reg)))
1443  goto err_out;
1444  if ((err = device_create_file(dev, &dev_attr_val)))
1445  goto err_reg;
1446  if ((err = device_create_file(dev, &dev_attr_frame_header)))
1447  goto err_val;
1448 
1449  if (cam->sensor.sysfs_ops) {
1450  if ((err = device_create_file(dev, &dev_attr_i2c_reg)))
1451  goto err_frame_header;
1452  if ((err = device_create_file(dev, &dev_attr_i2c_val)))
1453  goto err_i2c_reg;
1454  }
1455 
1456  if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
1457  if ((err = device_create_file(dev, &dev_attr_green)))
1458  goto err_i2c_val;
1459  } else {
1460  if ((err = device_create_file(dev, &dev_attr_blue)))
1461  goto err_i2c_val;
1462  if ((err = device_create_file(dev, &dev_attr_red)))
1463  goto err_blue;
1464  }
1465 
1466  return 0;
1467 
1468 err_blue:
1469  device_remove_file(dev, &dev_attr_blue);
1470 err_i2c_val:
1471  if (cam->sensor.sysfs_ops)
1472  device_remove_file(dev, &dev_attr_i2c_val);
1473 err_i2c_reg:
1474  if (cam->sensor.sysfs_ops)
1475  device_remove_file(dev, &dev_attr_i2c_reg);
1476 err_frame_header:
1477  device_remove_file(dev, &dev_attr_frame_header);
1478 err_val:
1479  device_remove_file(dev, &dev_attr_val);
1480 err_reg:
1481  device_remove_file(dev, &dev_attr_reg);
1482 err_out:
1483  return err;
1484 }
1485 #endif /* CONFIG_VIDEO_ADV_DEBUG */
1486 
1487 /*****************************************************************************/
1488 
1489 static int
1490 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
1491 {
1492  int err = 0;
1493 
1494  if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
1495  pix->pixelformat == V4L2_PIX_FMT_JPEG) {
1496  switch (cam->bridge) {
1497  case BRIDGE_SN9C101:
1498  case BRIDGE_SN9C102:
1499  case BRIDGE_SN9C103:
1500  err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1501  0x18);
1502  break;
1503  case BRIDGE_SN9C105:
1504  case BRIDGE_SN9C120:
1505  err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1506  0x18);
1507  break;
1508  }
1509  } else {
1510  switch (cam->bridge) {
1511  case BRIDGE_SN9C101:
1512  case BRIDGE_SN9C102:
1513  case BRIDGE_SN9C103:
1514  err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1515  0x18);
1516  break;
1517  case BRIDGE_SN9C105:
1518  case BRIDGE_SN9C120:
1519  err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1520  0x18);
1521  break;
1522  }
1523  }
1524 
1525  return err ? -EIO : 0;
1526 }
1527 
1528 
1529 static int
1530 sn9c102_set_compression(struct sn9c102_device* cam,
1531  struct v4l2_jpegcompression* compression)
1532 {
1533  int i, err = 0;
1534 
1535  switch (cam->bridge) {
1536  case BRIDGE_SN9C101:
1537  case BRIDGE_SN9C102:
1538  case BRIDGE_SN9C103:
1539  if (compression->quality == 0)
1540  err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01,
1541  0x17);
1542  else if (compression->quality == 1)
1543  err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe,
1544  0x17);
1545  break;
1546  case BRIDGE_SN9C105:
1547  case BRIDGE_SN9C120:
1548  if (compression->quality == 0) {
1549  for (i = 0; i <= 63; i++) {
1550  err += sn9c102_write_reg(cam,
1551  SN9C102_Y_QTABLE1[i],
1552  0x100 + i);
1553  err += sn9c102_write_reg(cam,
1554  SN9C102_UV_QTABLE1[i],
1555  0x140 + i);
1556  }
1557  err += sn9c102_write_reg(cam, cam->reg[0x18] & 0xbf,
1558  0x18);
1559  } else if (compression->quality == 1) {
1560  for (i = 0; i <= 63; i++) {
1561  err += sn9c102_write_reg(cam,
1562  SN9C102_Y_QTABLE1[i],
1563  0x100 + i);
1564  err += sn9c102_write_reg(cam,
1565  SN9C102_UV_QTABLE1[i],
1566  0x140 + i);
1567  }
1568  err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x40,
1569  0x18);
1570  }
1571  break;
1572  }
1573 
1574  return err ? -EIO : 0;
1575 }
1576 
1577 
1578 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1579 {
1580  u8 r = 0;
1581  int err = 0;
1582 
1583  if (scale == 1)
1584  r = cam->reg[0x18] & 0xcf;
1585  else if (scale == 2) {
1586  r = cam->reg[0x18] & 0xcf;
1587  r |= 0x10;
1588  } else if (scale == 4)
1589  r = cam->reg[0x18] | 0x20;
1590 
1591  err += sn9c102_write_reg(cam, r, 0x18);
1592  if (err)
1593  return -EIO;
1594 
1595  PDBGG("Scaling factor: %u", scale);
1596 
1597  return 0;
1598 }
1599 
1600 
1601 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1602 {
1603  struct sn9c102_sensor* s = &cam->sensor;
1604  u8 h_start = (u8)(rect->left - s->cropcap.bounds.left),
1605  v_start = (u8)(rect->top - s->cropcap.bounds.top),
1606  h_size = (u8)(rect->width / 16),
1607  v_size = (u8)(rect->height / 16);
1608  int err = 0;
1609 
1610  err += sn9c102_write_reg(cam, h_start, 0x12);
1611  err += sn9c102_write_reg(cam, v_start, 0x13);
1612  err += sn9c102_write_reg(cam, h_size, 0x15);
1613  err += sn9c102_write_reg(cam, v_size, 0x16);
1614  if (err)
1615  return -EIO;
1616 
1617  PDBGG("h_start, v_start, h_size, v_size, ho_size, vo_size "
1618  "%u %u %u %u", h_start, v_start, h_size, v_size);
1619 
1620  return 0;
1621 }
1622 
1623 
1624 static int sn9c102_init(struct sn9c102_device* cam)
1625 {
1626  struct sn9c102_sensor* s = &cam->sensor;
1627  struct v4l2_control ctrl;
1628  struct v4l2_queryctrl *qctrl;
1629  struct v4l2_rect* rect;
1630  u8 i = 0;
1631  int err = 0;
1632 
1633  if (!(cam->state & DEV_INITIALIZED)) {
1634  mutex_init(&cam->open_mutex);
1635  init_waitqueue_head(&cam->wait_open);
1636  qctrl = s->qctrl;
1637  rect = &(s->cropcap.defrect);
1638  } else { /* use current values */
1639  qctrl = s->_qctrl;
1640  rect = &(s->_rect);
1641  }
1642 
1643  err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1644  err += sn9c102_set_crop(cam, rect);
1645  if (err)
1646  return err;
1647 
1648  if (s->init) {
1649  err = s->init(cam);
1650  if (err) {
1651  DBG(3, "Sensor initialization failed");
1652  return err;
1653  }
1654  }
1655 
1656  if (!(cam->state & DEV_INITIALIZED))
1657  if (cam->bridge == BRIDGE_SN9C101 ||
1658  cam->bridge == BRIDGE_SN9C102 ||
1659  cam->bridge == BRIDGE_SN9C103) {
1660  if (s->pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
1661  s->pix_format.pixelformat= V4L2_PIX_FMT_SBGGR8;
1662  cam->compression.quality = cam->reg[0x17] & 0x01 ?
1663  0 : 1;
1664  } else {
1665  if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
1666  s->pix_format.pixelformat = V4L2_PIX_FMT_JPEG;
1667  cam->compression.quality = cam->reg[0x18] & 0x40 ?
1668  0 : 1;
1669  err += sn9c102_set_compression(cam, &cam->compression);
1670  }
1671  else
1672  err += sn9c102_set_compression(cam, &cam->compression);
1673  err += sn9c102_set_pix_format(cam, &s->pix_format);
1674  if (s->set_pix_format)
1675  err += s->set_pix_format(cam, &s->pix_format);
1676  if (err)
1677  return err;
1678 
1679  if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X ||
1680  s->pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
1681  DBG(3, "Compressed video format is active, quality %d",
1682  cam->compression.quality);
1683  else
1684  DBG(3, "Uncompressed video format is active");
1685 
1686  if (s->set_crop)
1687  if ((err = s->set_crop(cam, rect))) {
1688  DBG(3, "set_crop() failed");
1689  return err;
1690  }
1691 
1692  if (s->set_ctrl) {
1693  for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
1694  if (s->qctrl[i].id != 0 &&
1695  !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
1696  ctrl.id = s->qctrl[i].id;
1697  ctrl.value = qctrl[i].default_value;
1698  err = s->set_ctrl(cam, &ctrl);
1699  if (err) {
1700  DBG(3, "Set %s control failed",
1701  s->qctrl[i].name);
1702  return err;
1703  }
1704  DBG(3, "Image sensor supports '%s' control",
1705  s->qctrl[i].name);
1706  }
1707  }
1708 
1709  if (!(cam->state & DEV_INITIALIZED)) {
1710  mutex_init(&cam->fileop_mutex);
1711  spin_lock_init(&cam->queue_lock);
1712  init_waitqueue_head(&cam->wait_frame);
1713  init_waitqueue_head(&cam->wait_stream);
1714  cam->nreadbuffers = 2;
1715  memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
1716  memcpy(&(s->_rect), &(s->cropcap.defrect),
1717  sizeof(struct v4l2_rect));
1718  cam->state |= DEV_INITIALIZED;
1719  }
1720 
1721  DBG(2, "Initialization succeeded");
1722  return 0;
1723 }
1724 
1725 /*****************************************************************************/
1726 
1727 static void sn9c102_release_resources(struct kref *kref)
1728 {
1729  struct sn9c102_device *cam;
1730 
1731  mutex_lock(&sn9c102_sysfs_lock);
1732 
1733  cam = container_of(kref, struct sn9c102_device, kref);
1734 
1735  DBG(2, "V4L2 device %s deregistered",
1736  video_device_node_name(cam->v4ldev));
1737  video_set_drvdata(cam->v4ldev, NULL);
1738  video_unregister_device(cam->v4ldev);
1739  usb_put_dev(cam->usbdev);
1740  kfree(cam->control_buffer);
1741  kfree(cam);
1742 
1743  mutex_unlock(&sn9c102_sysfs_lock);
1744 
1745 }
1746 
1747 
1748 static int sn9c102_open(struct file *filp)
1749 {
1750  struct sn9c102_device* cam;
1751  int err = 0;
1752 
1753  /*
1754  A read_trylock() in open() is the only safe way to prevent race
1755  conditions with disconnect(), one close() and multiple (not
1756  necessarily simultaneous) attempts to open(). For example, it
1757  prevents from waiting for a second access, while the device
1758  structure is being deallocated, after a possible disconnect() and
1759  during a following close() holding the write lock: given that, after
1760  this deallocation, no access will be possible anymore, using the
1761  non-trylock version would have let open() gain the access to the
1762  device structure improperly.
1763  For this reason the lock must also not be per-device.
1764  */
1765  if (!down_read_trylock(&sn9c102_dev_lock))
1766  return -ERESTARTSYS;
1767 
1768  cam = video_drvdata(filp);
1769 
1770  if (wait_for_completion_interruptible(&cam->probe)) {
1771  up_read(&sn9c102_dev_lock);
1772  return -ERESTARTSYS;
1773  }
1774 
1775  kref_get(&cam->kref);
1776 
1777  /*
1778  Make sure to isolate all the simultaneous opens.
1779  */
1780  if (mutex_lock_interruptible(&cam->open_mutex)) {
1781  kref_put(&cam->kref, sn9c102_release_resources);
1782  up_read(&sn9c102_dev_lock);
1783  return -ERESTARTSYS;
1784  }
1785 
1786  if (cam->state & DEV_DISCONNECTED) {
1787  DBG(1, "Device not present");
1788  err = -ENODEV;
1789  goto out;
1790  }
1791 
1792  if (cam->users) {
1793  DBG(2, "Device %s is already in use",
1794  video_device_node_name(cam->v4ldev));
1795  DBG(3, "Simultaneous opens are not supported");
1796  /*
1797  open() must follow the open flags and should block
1798  eventually while the device is in use.
1799  */
1800  if ((filp->f_flags & O_NONBLOCK) ||
1801  (filp->f_flags & O_NDELAY)) {
1802  err = -EWOULDBLOCK;
1803  goto out;
1804  }
1805  DBG(2, "A blocking open() has been requested. Wait for the "
1806  "device to be released...");
1807  up_read(&sn9c102_dev_lock);
1808  /*
1809  We will not release the "open_mutex" lock, so that only one
1810  process can be in the wait queue below. This way the process
1811  will be sleeping while holding the lock, without losing its
1812  priority after any wake_up().
1813  */
1814  err = wait_event_interruptible_exclusive(cam->wait_open,
1815  (cam->state & DEV_DISCONNECTED)
1816  || !cam->users);
1817  down_read(&sn9c102_dev_lock);
1818  if (err)
1819  goto out;
1820  if (cam->state & DEV_DISCONNECTED) {
1821  err = -ENODEV;
1822  goto out;
1823  }
1824  }
1825 
1826  if (cam->state & DEV_MISCONFIGURED) {
1827  err = sn9c102_init(cam);
1828  if (err) {
1829  DBG(1, "Initialization failed again. "
1830  "I will retry on next open().");
1831  goto out;
1832  }
1833  cam->state &= ~DEV_MISCONFIGURED;
1834  }
1835 
1836  if ((err = sn9c102_start_transfer(cam)))
1837  goto out;
1838 
1839  filp->private_data = cam;
1840  cam->users++;
1841  cam->io = IO_NONE;
1842  cam->stream = STREAM_OFF;
1843  cam->nbuffers = 0;
1844  cam->frame_count = 0;
1845  sn9c102_empty_framequeues(cam);
1846 
1847  DBG(3, "Video device %s is open", video_device_node_name(cam->v4ldev));
1848 
1849 out:
1850  mutex_unlock(&cam->open_mutex);
1851  if (err)
1852  kref_put(&cam->kref, sn9c102_release_resources);
1853 
1854  up_read(&sn9c102_dev_lock);
1855  return err;
1856 }
1857 
1858 
1859 static int sn9c102_release(struct file *filp)
1860 {
1861  struct sn9c102_device* cam;
1862 
1863  down_write(&sn9c102_dev_lock);
1864 
1865  cam = video_drvdata(filp);
1866 
1867  sn9c102_stop_transfer(cam);
1868  sn9c102_release_buffers(cam);
1869  cam->users--;
1870  wake_up_interruptible_nr(&cam->wait_open, 1);
1871 
1872  DBG(3, "Video device %s closed", video_device_node_name(cam->v4ldev));
1873 
1874  kref_put(&cam->kref, sn9c102_release_resources);
1875 
1876  up_write(&sn9c102_dev_lock);
1877 
1878  return 0;
1879 }
1880 
1881 
1882 static ssize_t
1883 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1884 {
1885  struct sn9c102_device *cam = video_drvdata(filp);
1886  struct sn9c102_frame_t* f, * i;
1887  unsigned long lock_flags;
1888  long timeout;
1889  int err = 0;
1890 
1891  if (mutex_lock_interruptible(&cam->fileop_mutex))
1892  return -ERESTARTSYS;
1893 
1894  if (cam->state & DEV_DISCONNECTED) {
1895  DBG(1, "Device not present");
1896  mutex_unlock(&cam->fileop_mutex);
1897  return -ENODEV;
1898  }
1899 
1900  if (cam->state & DEV_MISCONFIGURED) {
1901  DBG(1, "The camera is misconfigured. Close and open it "
1902  "again.");
1903  mutex_unlock(&cam->fileop_mutex);
1904  return -EIO;
1905  }
1906 
1907  if (cam->io == IO_MMAP) {
1908  DBG(3, "Close and open the device again to choose "
1909  "the read method");
1910  mutex_unlock(&cam->fileop_mutex);
1911  return -EBUSY;
1912  }
1913 
1914  if (cam->io == IO_NONE) {
1915  if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
1916  DBG(1, "read() failed, not enough memory");
1917  mutex_unlock(&cam->fileop_mutex);
1918  return -ENOMEM;
1919  }
1920  cam->io = IO_READ;
1921  cam->stream = STREAM_ON;
1922  }
1923 
1924  if (list_empty(&cam->inqueue)) {
1925  if (!list_empty(&cam->outqueue))
1926  sn9c102_empty_framequeues(cam);
1927  sn9c102_queue_unusedframes(cam);
1928  }
1929 
1930  if (!count) {
1931  mutex_unlock(&cam->fileop_mutex);
1932  return 0;
1933  }
1934 
1935  if (list_empty(&cam->outqueue)) {
1936  if (filp->f_flags & O_NONBLOCK) {
1937  mutex_unlock(&cam->fileop_mutex);
1938  return -EAGAIN;
1939  }
1940  if (!cam->module_param.frame_timeout) {
1941  err = wait_event_interruptible
1942  ( cam->wait_frame,
1943  (!list_empty(&cam->outqueue)) ||
1944  (cam->state & DEV_DISCONNECTED) ||
1945  (cam->state & DEV_MISCONFIGURED) );
1946  if (err) {
1947  mutex_unlock(&cam->fileop_mutex);
1948  return err;
1949  }
1950  } else {
1951  timeout = wait_event_interruptible_timeout
1952  ( cam->wait_frame,
1953  (!list_empty(&cam->outqueue)) ||
1954  (cam->state & DEV_DISCONNECTED) ||
1955  (cam->state & DEV_MISCONFIGURED),
1956  msecs_to_jiffies(
1957  cam->module_param.frame_timeout * 1000
1958  )
1959  );
1960  if (timeout < 0) {
1961  mutex_unlock(&cam->fileop_mutex);
1962  return timeout;
1963  } else if (timeout == 0 &&
1964  !(cam->state & DEV_DISCONNECTED)) {
1965  DBG(1, "Video frame timeout elapsed");
1966  mutex_unlock(&cam->fileop_mutex);
1967  return -EIO;
1968  }
1969  }
1970  if (cam->state & DEV_DISCONNECTED) {
1971  mutex_unlock(&cam->fileop_mutex);
1972  return -ENODEV;
1973  }
1974  if (cam->state & DEV_MISCONFIGURED) {
1975  mutex_unlock(&cam->fileop_mutex);
1976  return -EIO;
1977  }
1978  }
1979 
1980  f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1981 
1982  if (count > f->buf.bytesused)
1983  count = f->buf.bytesused;
1984 
1985  if (copy_to_user(buf, f->bufmem, count)) {
1986  err = -EFAULT;
1987  goto exit;
1988  }
1989  *f_pos += count;
1990 
1991 exit:
1992  spin_lock_irqsave(&cam->queue_lock, lock_flags);
1993  list_for_each_entry(i, &cam->outqueue, frame)
1994  i->state = F_UNUSED;
1995  INIT_LIST_HEAD(&cam->outqueue);
1996  spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1997 
1998  sn9c102_queue_unusedframes(cam);
1999 
2000  PDBGG("Frame #%lu, bytes read: %zu",
2001  (unsigned long)f->buf.index, count);
2002 
2003  mutex_unlock(&cam->fileop_mutex);
2004 
2005  return count;
2006 }
2007 
2008 
2009 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
2010 {
2011  struct sn9c102_device *cam = video_drvdata(filp);
2012  struct sn9c102_frame_t* f;
2013  unsigned long lock_flags;
2014  unsigned int mask = 0;
2015 
2016  if (mutex_lock_interruptible(&cam->fileop_mutex))
2017  return POLLERR;
2018 
2019  if (cam->state & DEV_DISCONNECTED) {
2020  DBG(1, "Device not present");
2021  goto error;
2022  }
2023 
2024  if (cam->state & DEV_MISCONFIGURED) {
2025  DBG(1, "The camera is misconfigured. Close and open it "
2026  "again.");
2027  goto error;
2028  }
2029 
2030  if (cam->io == IO_NONE) {
2031  if (!sn9c102_request_buffers(cam, cam->nreadbuffers,
2032  IO_READ)) {
2033  DBG(1, "poll() failed, not enough memory");
2034  goto error;
2035  }
2036  cam->io = IO_READ;
2037  cam->stream = STREAM_ON;
2038  }
2039 
2040  if (cam->io == IO_READ) {
2041  spin_lock_irqsave(&cam->queue_lock, lock_flags);
2042  list_for_each_entry(f, &cam->outqueue, frame)
2043  f->state = F_UNUSED;
2044  INIT_LIST_HEAD(&cam->outqueue);
2045  spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2046  sn9c102_queue_unusedframes(cam);
2047  }
2048 
2049  poll_wait(filp, &cam->wait_frame, wait);
2050 
2051  if (!list_empty(&cam->outqueue))
2052  mask |= POLLIN | POLLRDNORM;
2053 
2054  mutex_unlock(&cam->fileop_mutex);
2055 
2056  return mask;
2057 
2058 error:
2059  mutex_unlock(&cam->fileop_mutex);
2060  return POLLERR;
2061 }
2062 
2063 
2064 static void sn9c102_vm_open(struct vm_area_struct* vma)
2065 {
2066  struct sn9c102_frame_t* f = vma->vm_private_data;
2067  f->vma_use_count++;
2068 }
2069 
2070 
2071 static void sn9c102_vm_close(struct vm_area_struct* vma)
2072 {
2073  /* NOTE: buffers are not freed here */
2074  struct sn9c102_frame_t* f = vma->vm_private_data;
2075  f->vma_use_count--;
2076 }
2077 
2078 
2079 static const struct vm_operations_struct sn9c102_vm_ops = {
2080  .open = sn9c102_vm_open,
2081  .close = sn9c102_vm_close,
2082 };
2083 
2084 
2085 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
2086 {
2087  struct sn9c102_device *cam = video_drvdata(filp);
2088  unsigned long size = vma->vm_end - vma->vm_start,
2089  start = vma->vm_start;
2090  void *pos;
2091  u32 i;
2092 
2093  if (mutex_lock_interruptible(&cam->fileop_mutex))
2094  return -ERESTARTSYS;
2095 
2096  if (cam->state & DEV_DISCONNECTED) {
2097  DBG(1, "Device not present");
2098  mutex_unlock(&cam->fileop_mutex);
2099  return -ENODEV;
2100  }
2101 
2102  if (cam->state & DEV_MISCONFIGURED) {
2103  DBG(1, "The camera is misconfigured. Close and open it "
2104  "again.");
2105  mutex_unlock(&cam->fileop_mutex);
2106  return -EIO;
2107  }
2108 
2109  if (!(vma->vm_flags & (VM_WRITE | VM_READ))) {
2110  mutex_unlock(&cam->fileop_mutex);
2111  return -EACCES;
2112  }
2113 
2114  if (cam->io != IO_MMAP ||
2115  size != PAGE_ALIGN(cam->frame[0].buf.length)) {
2116  mutex_unlock(&cam->fileop_mutex);
2117  return -EINVAL;
2118  }
2119 
2120  for (i = 0; i < cam->nbuffers; i++) {
2121  if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
2122  break;
2123  }
2124  if (i == cam->nbuffers) {
2125  mutex_unlock(&cam->fileop_mutex);
2126  return -EINVAL;
2127  }
2128 
2129  vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
2130 
2131  pos = cam->frame[i].bufmem;
2132  while (size > 0) { /* size is page-aligned */
2133  if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
2134  mutex_unlock(&cam->fileop_mutex);
2135  return -EAGAIN;
2136  }
2137  start += PAGE_SIZE;
2138  pos += PAGE_SIZE;
2139  size -= PAGE_SIZE;
2140  }
2141 
2142  vma->vm_ops = &sn9c102_vm_ops;
2143  vma->vm_private_data = &cam->frame[i];
2144  sn9c102_vm_open(vma);
2145 
2146  mutex_unlock(&cam->fileop_mutex);
2147 
2148  return 0;
2149 }
2150 
2151 /*****************************************************************************/
2152 
2153 static int
2154 sn9c102_vidioc_querycap(struct sn9c102_device* cam, void __user * arg)
2155 {
2156  struct v4l2_capability cap = {
2157  .driver = "sn9c102",
2158  .version = LINUX_VERSION_CODE,
2159  .capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2160  V4L2_CAP_STREAMING,
2161  };
2162 
2163  strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
2164  if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
2165  strlcpy(cap.bus_info, dev_name(&cam->usbdev->dev),
2166  sizeof(cap.bus_info));
2167 
2168  if (copy_to_user(arg, &cap, sizeof(cap)))
2169  return -EFAULT;
2170 
2171  return 0;
2172 }
2173 
2174 
2175 static int
2176 sn9c102_vidioc_enuminput(struct sn9c102_device* cam, void __user * arg)
2177 {
2178  struct v4l2_input i;
2179 
2180  if (copy_from_user(&i, arg, sizeof(i)))
2181  return -EFAULT;
2182 
2183  if (i.index)
2184  return -EINVAL;
2185 
2186  memset(&i, 0, sizeof(i));
2187  strcpy(i.name, "Camera");
2188  i.type = V4L2_INPUT_TYPE_CAMERA;
2189  i.capabilities = V4L2_IN_CAP_STD;
2190 
2191  if (copy_to_user(arg, &i, sizeof(i)))
2192  return -EFAULT;
2193 
2194  return 0;
2195 }
2196 
2197 
2198 static int
2199 sn9c102_vidioc_g_input(struct sn9c102_device* cam, void __user * arg)
2200 {
2201  int index = 0;
2202 
2203  if (copy_to_user(arg, &index, sizeof(index)))
2204  return -EFAULT;
2205 
2206  return 0;
2207 }
2208 
2209 
2210 static int
2211 sn9c102_vidioc_s_input(struct sn9c102_device* cam, void __user * arg)
2212 {
2213  int index;
2214 
2215  if (copy_from_user(&index, arg, sizeof(index)))
2216  return -EFAULT;
2217 
2218  if (index != 0)
2219  return -EINVAL;
2220 
2221  return 0;
2222 }
2223 
2224 
2225 static int
2226 sn9c102_vidioc_query_ctrl(struct sn9c102_device* cam, void __user * arg)
2227 {
2228  struct sn9c102_sensor* s = &cam->sensor;
2229  struct v4l2_queryctrl qc;
2230  u8 i;
2231 
2232  if (copy_from_user(&qc, arg, sizeof(qc)))
2233  return -EFAULT;
2234 
2235  for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2236  if (qc.id && qc.id == s->qctrl[i].id) {
2237  memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
2238  if (copy_to_user(arg, &qc, sizeof(qc)))
2239  return -EFAULT;
2240  return 0;
2241  }
2242 
2243  return -EINVAL;
2244 }
2245 
2246 
2247 static int
2248 sn9c102_vidioc_g_ctrl(struct sn9c102_device* cam, void __user * arg)
2249 {
2250  struct sn9c102_sensor* s = &cam->sensor;
2251  struct v4l2_control ctrl;
2252  int err = 0;
2253  u8 i;
2254 
2255  if (!s->get_ctrl && !s->set_ctrl)
2256  return -EINVAL;
2257 
2258  if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2259  return -EFAULT;
2260 
2261  if (!s->get_ctrl) {
2262  for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2263  if (ctrl.id && ctrl.id == s->qctrl[i].id) {
2264  ctrl.value = s->_qctrl[i].default_value;
2265  goto exit;
2266  }
2267  return -EINVAL;
2268  } else
2269  err = s->get_ctrl(cam, &ctrl);
2270 
2271 exit:
2272  if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
2273  return -EFAULT;
2274 
2275  PDBGG("VIDIOC_G_CTRL: id %lu, value %lu",
2276  (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2277 
2278  return err;
2279 }
2280 
2281 
2282 static int
2283 sn9c102_vidioc_s_ctrl(struct sn9c102_device* cam, void __user * arg)
2284 {
2285  struct sn9c102_sensor* s = &cam->sensor;
2286  struct v4l2_control ctrl;
2287  u8 i;
2288  int err = 0;
2289 
2290  if (!s->set_ctrl)
2291  return -EINVAL;
2292 
2293  if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2294  return -EFAULT;
2295 
2296  for (i = 0; i < ARRAY_SIZE(s->qctrl); i++) {
2297  if (ctrl.id == s->qctrl[i].id) {
2298  if (s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)
2299  return -EINVAL;
2300  if (ctrl.value < s->qctrl[i].minimum ||
2301  ctrl.value > s->qctrl[i].maximum)
2302  return -ERANGE;
2303  ctrl.value -= ctrl.value % s->qctrl[i].step;
2304  break;
2305  }
2306  }
2307  if (i == ARRAY_SIZE(s->qctrl))
2308  return -EINVAL;
2309  if ((err = s->set_ctrl(cam, &ctrl)))
2310  return err;
2311 
2312  s->_qctrl[i].default_value = ctrl.value;
2313 
2314  PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
2315  (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2316 
2317  return 0;
2318 }
2319 
2320 
2321 static int
2322 sn9c102_vidioc_cropcap(struct sn9c102_device* cam, void __user * arg)
2323 {
2324  struct v4l2_cropcap* cc = &(cam->sensor.cropcap);
2325 
2326  cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2327  cc->pixelaspect.numerator = 1;
2328  cc->pixelaspect.denominator = 1;
2329 
2330  if (copy_to_user(arg, cc, sizeof(*cc)))
2331  return -EFAULT;
2332 
2333  return 0;
2334 }
2335 
2336 
2337 static int
2338 sn9c102_vidioc_g_crop(struct sn9c102_device* cam, void __user * arg)
2339 {
2340  struct sn9c102_sensor* s = &cam->sensor;
2341  struct v4l2_crop crop = {
2342  .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
2343  };
2344 
2345  memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
2346 
2347  if (copy_to_user(arg, &crop, sizeof(crop)))
2348  return -EFAULT;
2349 
2350  return 0;
2351 }
2352 
2353 
2354 static int
2355 sn9c102_vidioc_s_crop(struct sn9c102_device* cam, void __user * arg)
2356 {
2357  struct sn9c102_sensor* s = &cam->sensor;
2358  struct v4l2_crop crop;
2359  struct v4l2_rect* rect;
2360  struct v4l2_rect* bounds = &(s->cropcap.bounds);
2361  struct v4l2_pix_format* pix_format = &(s->pix_format);
2362  u8 scale;
2363  const enum sn9c102_stream_state stream = cam->stream;
2364  const u32 nbuffers = cam->nbuffers;
2365  u32 i;
2366  int err = 0;
2367 
2368  if (copy_from_user(&crop, arg, sizeof(crop)))
2369  return -EFAULT;
2370 
2371  rect = &(crop.c);
2372 
2373  if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2374  return -EINVAL;
2375 
2376  if (cam->module_param.force_munmap)
2377  for (i = 0; i < cam->nbuffers; i++)
2378  if (cam->frame[i].vma_use_count) {
2379  DBG(3, "VIDIOC_S_CROP failed. "
2380  "Unmap the buffers first.");
2381  return -EBUSY;
2382  }
2383 
2384  /* Preserve R,G or B origin */
2385  rect->left = (s->_rect.left & 1L) ? rect->left | 1L : rect->left & ~1L;
2386  rect->top = (s->_rect.top & 1L) ? rect->top | 1L : rect->top & ~1L;
2387 
2388  if (rect->width < 16)
2389  rect->width = 16;
2390  if (rect->height < 16)
2391  rect->height = 16;
2392  if (rect->width > bounds->width)
2393  rect->width = bounds->width;
2394  if (rect->height > bounds->height)
2395  rect->height = bounds->height;
2396  if (rect->left < bounds->left)
2397  rect->left = bounds->left;
2398  if (rect->top < bounds->top)
2399  rect->top = bounds->top;
2400  if (rect->left + rect->width > bounds->left + bounds->width)
2401  rect->left = bounds->left+bounds->width - rect->width;
2402  if (rect->top + rect->height > bounds->top + bounds->height)
2403  rect->top = bounds->top+bounds->height - rect->height;
2404 
2405  rect->width &= ~15L;
2406  rect->height &= ~15L;
2407 
2408  if (SN9C102_PRESERVE_IMGSCALE) {
2409  /* Calculate the actual scaling factor */
2410  u32 a, b;
2411  a = rect->width * rect->height;
2412  b = pix_format->width * pix_format->height;
2413  scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2414  } else
2415  scale = 1;
2416 
2417  if (cam->stream == STREAM_ON)
2418  if ((err = sn9c102_stream_interrupt(cam)))
2419  return err;
2420 
2421  if (copy_to_user(arg, &crop, sizeof(crop))) {
2422  cam->stream = stream;
2423  return -EFAULT;
2424  }
2425 
2426  if (cam->module_param.force_munmap || cam->io == IO_READ)
2427  sn9c102_release_buffers(cam);
2428 
2429  err = sn9c102_set_crop(cam, rect);
2430  if (s->set_crop)
2431  err += s->set_crop(cam, rect);
2432  err += sn9c102_set_scale(cam, scale);
2433 
2434  if (err) { /* atomic, no rollback in ioctl() */
2435  cam->state |= DEV_MISCONFIGURED;
2436  DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
2437  "use the camera, close and open %s again.",
2438  video_device_node_name(cam->v4ldev));
2439  return -EIO;
2440  }
2441 
2442  s->pix_format.width = rect->width/scale;
2443  s->pix_format.height = rect->height/scale;
2444  memcpy(&(s->_rect), rect, sizeof(*rect));
2445 
2446  if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2447  nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2448  cam->state |= DEV_MISCONFIGURED;
2449  DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
2450  "use the camera, close and open %s again.",
2451  video_device_node_name(cam->v4ldev));
2452  return -ENOMEM;
2453  }
2454 
2455  if (cam->io == IO_READ)
2456  sn9c102_empty_framequeues(cam);
2457  else if (cam->module_param.force_munmap)
2458  sn9c102_requeue_outqueue(cam);
2459 
2460  cam->stream = stream;
2461 
2462  return 0;
2463 }
2464 
2465 
2466 static int
2467 sn9c102_vidioc_enum_framesizes(struct sn9c102_device* cam, void __user * arg)
2468 {
2469  struct v4l2_frmsizeenum frmsize;
2470 
2471  if (copy_from_user(&frmsize, arg, sizeof(frmsize)))
2472  return -EFAULT;
2473 
2474  if (frmsize.index != 0)
2475  return -EINVAL;
2476 
2477  switch (cam->bridge) {
2478  case BRIDGE_SN9C101:
2479  case BRIDGE_SN9C102:
2480  case BRIDGE_SN9C103:
2481  if (frmsize.pixel_format != V4L2_PIX_FMT_SN9C10X &&
2482  frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2483  return -EINVAL;
2484  case BRIDGE_SN9C105:
2485  case BRIDGE_SN9C120:
2486  if (frmsize.pixel_format != V4L2_PIX_FMT_JPEG &&
2487  frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2488  return -EINVAL;
2489  }
2490 
2491  frmsize.type = V4L2_FRMSIZE_TYPE_STEPWISE;
2492  frmsize.stepwise.min_width = frmsize.stepwise.step_width = 16;
2493  frmsize.stepwise.min_height = frmsize.stepwise.step_height = 16;
2494  frmsize.stepwise.max_width = cam->sensor.cropcap.bounds.width;
2495  frmsize.stepwise.max_height = cam->sensor.cropcap.bounds.height;
2496  memset(&frmsize.reserved, 0, sizeof(frmsize.reserved));
2497 
2498  if (copy_to_user(arg, &frmsize, sizeof(frmsize)))
2499  return -EFAULT;
2500 
2501  return 0;
2502 }
2503 
2504 
2505 static int
2506 sn9c102_vidioc_enum_fmt(struct sn9c102_device* cam, void __user * arg)
2507 {
2508  struct v4l2_fmtdesc fmtd;
2509 
2510  if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
2511  return -EFAULT;
2512 
2513  if (fmtd.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2514  return -EINVAL;
2515 
2516  if (fmtd.index == 0) {
2517  strcpy(fmtd.description, "bayer rgb");
2518  fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
2519  } else if (fmtd.index == 1) {
2520  switch (cam->bridge) {
2521  case BRIDGE_SN9C101:
2522  case BRIDGE_SN9C102:
2523  case BRIDGE_SN9C103:
2524  strcpy(fmtd.description, "compressed");
2525  fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
2526  break;
2527  case BRIDGE_SN9C105:
2528  case BRIDGE_SN9C120:
2529  strcpy(fmtd.description, "JPEG");
2530  fmtd.pixelformat = V4L2_PIX_FMT_JPEG;
2531  break;
2532  }
2533  fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
2534  } else
2535  return -EINVAL;
2536 
2537  fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2538  memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
2539 
2540  if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
2541  return -EFAULT;
2542 
2543  return 0;
2544 }
2545 
2546 
2547 static int
2548 sn9c102_vidioc_g_fmt(struct sn9c102_device* cam, void __user * arg)
2549 {
2550  struct v4l2_format format;
2551  struct v4l2_pix_format* pfmt = &(cam->sensor.pix_format);
2552 
2553  if (copy_from_user(&format, arg, sizeof(format)))
2554  return -EFAULT;
2555 
2556  if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2557  return -EINVAL;
2558 
2559  pfmt->colorspace = (pfmt->pixelformat == V4L2_PIX_FMT_JPEG) ?
2560  V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2561  pfmt->bytesperline = (pfmt->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2562  pfmt->pixelformat == V4L2_PIX_FMT_JPEG)
2563  ? 0 : (pfmt->width * pfmt->priv) / 8;
2564  pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
2565  pfmt->field = V4L2_FIELD_NONE;
2566  memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
2567 
2568  if (copy_to_user(arg, &format, sizeof(format)))
2569  return -EFAULT;
2570 
2571  return 0;
2572 }
2573 
2574 
2575 static int
2576 sn9c102_vidioc_try_s_fmt(struct sn9c102_device* cam, unsigned int cmd,
2577  void __user * arg)
2578 {
2579  struct sn9c102_sensor* s = &cam->sensor;
2580  struct v4l2_format format;
2581  struct v4l2_pix_format* pix;
2582  struct v4l2_pix_format* pfmt = &(s->pix_format);
2583  struct v4l2_rect* bounds = &(s->cropcap.bounds);
2584  struct v4l2_rect rect;
2585  u8 scale;
2586  const enum sn9c102_stream_state stream = cam->stream;
2587  const u32 nbuffers = cam->nbuffers;
2588  u32 i;
2589  int err = 0;
2590 
2591  if (copy_from_user(&format, arg, sizeof(format)))
2592  return -EFAULT;
2593 
2594  pix = &(format.fmt.pix);
2595 
2596  if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2597  return -EINVAL;
2598 
2599  memcpy(&rect, &(s->_rect), sizeof(rect));
2600 
2601  { /* calculate the actual scaling factor */
2602  u32 a, b;
2603  a = rect.width * rect.height;
2604  b = pix->width * pix->height;
2605  scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2606  }
2607 
2608  rect.width = scale * pix->width;
2609  rect.height = scale * pix->height;
2610 
2611  if (rect.width < 16)
2612  rect.width = 16;
2613  if (rect.height < 16)
2614  rect.height = 16;
2615  if (rect.width > bounds->left + bounds->width - rect.left)
2616  rect.width = bounds->left + bounds->width - rect.left;
2617  if (rect.height > bounds->top + bounds->height - rect.top)
2618  rect.height = bounds->top + bounds->height - rect.top;
2619 
2620  rect.width &= ~15L;
2621  rect.height &= ~15L;
2622 
2623  { /* adjust the scaling factor */
2624  u32 a, b;
2625  a = rect.width * rect.height;
2626  b = pix->width * pix->height;
2627  scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2628  }
2629 
2630  pix->width = rect.width / scale;
2631  pix->height = rect.height / scale;
2632 
2633  switch (cam->bridge) {
2634  case BRIDGE_SN9C101:
2635  case BRIDGE_SN9C102:
2636  case BRIDGE_SN9C103:
2637  if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2638  pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2639  pix->pixelformat = pfmt->pixelformat;
2640  break;
2641  case BRIDGE_SN9C105:
2642  case BRIDGE_SN9C120:
2643  if (pix->pixelformat != V4L2_PIX_FMT_JPEG &&
2644  pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2645  pix->pixelformat = pfmt->pixelformat;
2646  break;
2647  }
2648  pix->priv = pfmt->priv; /* bpp */
2649  pix->colorspace = (pix->pixelformat == V4L2_PIX_FMT_JPEG) ?
2650  V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2651  pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2652  pix->pixelformat == V4L2_PIX_FMT_JPEG)
2653  ? 0 : (pix->width * pix->priv) / 8;
2654  pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2655  pix->field = V4L2_FIELD_NONE;
2656 
2657  if (cmd == VIDIOC_TRY_FMT) {
2658  if (copy_to_user(arg, &format, sizeof(format)))
2659  return -EFAULT;
2660  return 0;
2661  }
2662 
2663  if (cam->module_param.force_munmap)
2664  for (i = 0; i < cam->nbuffers; i++)
2665  if (cam->frame[i].vma_use_count) {
2666  DBG(3, "VIDIOC_S_FMT failed. Unmap the "
2667  "buffers first.");
2668  return -EBUSY;
2669  }
2670 
2671  if (cam->stream == STREAM_ON)
2672  if ((err = sn9c102_stream_interrupt(cam)))
2673  return err;
2674 
2675  if (copy_to_user(arg, &format, sizeof(format))) {
2676  cam->stream = stream;
2677  return -EFAULT;
2678  }
2679 
2680  if (cam->module_param.force_munmap || cam->io == IO_READ)
2681  sn9c102_release_buffers(cam);
2682 
2683  err += sn9c102_set_pix_format(cam, pix);
2684  err += sn9c102_set_crop(cam, &rect);
2685  if (s->set_pix_format)
2686  err += s->set_pix_format(cam, pix);
2687  if (s->set_crop)
2688  err += s->set_crop(cam, &rect);
2689  err += sn9c102_set_scale(cam, scale);
2690 
2691  if (err) { /* atomic, no rollback in ioctl() */
2692  cam->state |= DEV_MISCONFIGURED;
2693  DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
2694  "use the camera, close and open %s again.",
2695  video_device_node_name(cam->v4ldev));
2696  return -EIO;
2697  }
2698 
2699  memcpy(pfmt, pix, sizeof(*pix));
2700  memcpy(&(s->_rect), &rect, sizeof(rect));
2701 
2702  if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2703  nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2704  cam->state |= DEV_MISCONFIGURED;
2705  DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
2706  "use the camera, close and open %s again.",
2707  video_device_node_name(cam->v4ldev));
2708  return -ENOMEM;
2709  }
2710 
2711  if (cam->io == IO_READ)
2712  sn9c102_empty_framequeues(cam);
2713  else if (cam->module_param.force_munmap)
2714  sn9c102_requeue_outqueue(cam);
2715 
2716  cam->stream = stream;
2717 
2718  return 0;
2719 }
2720 
2721 
2722 static int
2723 sn9c102_vidioc_g_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2724 {
2725  if (copy_to_user(arg, &cam->compression, sizeof(cam->compression)))
2726  return -EFAULT;
2727 
2728  return 0;
2729 }
2730 
2731 
2732 static int
2733 sn9c102_vidioc_s_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2734 {
2735  struct v4l2_jpegcompression jc;
2736  const enum sn9c102_stream_state stream = cam->stream;
2737  int err = 0;
2738 
2739  if (copy_from_user(&jc, arg, sizeof(jc)))
2740  return -EFAULT;
2741 
2742  if (jc.quality != 0 && jc.quality != 1)
2743  return -EINVAL;
2744 
2745  if (cam->stream == STREAM_ON)
2746  if ((err = sn9c102_stream_interrupt(cam)))
2747  return err;
2748 
2749  err += sn9c102_set_compression(cam, &jc);
2750  if (err) { /* atomic, no rollback in ioctl() */
2751  cam->state |= DEV_MISCONFIGURED;
2752  DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware problems. "
2753  "To use the camera, close and open %s again.",
2754  video_device_node_name(cam->v4ldev));
2755  return -EIO;
2756  }
2757 
2758  cam->compression.quality = jc.quality;
2759 
2760  cam->stream = stream;
2761 
2762  return 0;
2763 }
2764 
2765 
2766 static int
2767 sn9c102_vidioc_reqbufs(struct sn9c102_device* cam, void __user * arg)
2768 {
2769  struct v4l2_requestbuffers rb;
2770  u32 i;
2771  int err;
2772 
2773  if (copy_from_user(&rb, arg, sizeof(rb)))
2774  return -EFAULT;
2775 
2776  if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2777  rb.memory != V4L2_MEMORY_MMAP)
2778  return -EINVAL;
2779 
2780  if (cam->io == IO_READ) {
2781  DBG(3, "Close and open the device again to choose the mmap "
2782  "I/O method");
2783  return -EBUSY;
2784  }
2785 
2786  for (i = 0; i < cam->nbuffers; i++)
2787  if (cam->frame[i].vma_use_count) {
2788  DBG(3, "VIDIOC_REQBUFS failed. Previous buffers are "
2789  "still mapped.");
2790  return -EBUSY;
2791  }
2792 
2793  if (cam->stream == STREAM_ON)
2794  if ((err = sn9c102_stream_interrupt(cam)))
2795  return err;
2796 
2797  sn9c102_empty_framequeues(cam);
2798 
2799  sn9c102_release_buffers(cam);
2800  if (rb.count)
2801  rb.count = sn9c102_request_buffers(cam, rb.count, IO_MMAP);
2802 
2803  if (copy_to_user(arg, &rb, sizeof(rb))) {
2804  sn9c102_release_buffers(cam);
2805  cam->io = IO_NONE;
2806  return -EFAULT;
2807  }
2808 
2809  cam->io = rb.count ? IO_MMAP : IO_NONE;
2810 
2811  return 0;
2812 }
2813 
2814 
2815 static int
2816 sn9c102_vidioc_querybuf(struct sn9c102_device* cam, void __user * arg)
2817 {
2818  struct v4l2_buffer b;
2819 
2820  if (copy_from_user(&b, arg, sizeof(b)))
2821  return -EFAULT;
2822 
2823  if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2824  b.index >= cam->nbuffers || cam->io != IO_MMAP)
2825  return -EINVAL;
2826 
2827  memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2828 
2829  if (cam->frame[b.index].vma_use_count)
2830  b.flags |= V4L2_BUF_FLAG_MAPPED;
2831 
2832  if (cam->frame[b.index].state == F_DONE)
2833  b.flags |= V4L2_BUF_FLAG_DONE;
2834  else if (cam->frame[b.index].state != F_UNUSED)
2835  b.flags |= V4L2_BUF_FLAG_QUEUED;
2836 
2837  if (copy_to_user(arg, &b, sizeof(b)))
2838  return -EFAULT;
2839 
2840  return 0;
2841 }
2842 
2843 
2844 static int
2845 sn9c102_vidioc_qbuf(struct sn9c102_device* cam, void __user * arg)
2846 {
2847  struct v4l2_buffer b;
2848  unsigned long lock_flags;
2849 
2850  if (copy_from_user(&b, arg, sizeof(b)))
2851  return -EFAULT;
2852 
2853  if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2854  b.index >= cam->nbuffers || cam->io != IO_MMAP)
2855  return -EINVAL;
2856 
2857  if (cam->frame[b.index].state != F_UNUSED)
2858  return -EINVAL;
2859 
2860  cam->frame[b.index].state = F_QUEUED;
2861 
2862  spin_lock_irqsave(&cam->queue_lock, lock_flags);
2863  list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2864  spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2865 
2866  PDBGG("Frame #%lu queued", (unsigned long)b.index);
2867 
2868  return 0;
2869 }
2870 
2871 
2872 static int
2873 sn9c102_vidioc_dqbuf(struct sn9c102_device* cam, struct file* filp,
2874  void __user * arg)
2875 {
2876  struct v4l2_buffer b;
2877  struct sn9c102_frame_t *f;
2878  unsigned long lock_flags;
2879  long timeout;
2880  int err = 0;
2881 
2882  if (copy_from_user(&b, arg, sizeof(b)))
2883  return -EFAULT;
2884 
2885  if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2886  return -EINVAL;
2887 
2888  if (list_empty(&cam->outqueue)) {
2889  if (cam->stream == STREAM_OFF)
2890  return -EINVAL;
2891  if (filp->f_flags & O_NONBLOCK)
2892  return -EAGAIN;
2893  if (!cam->module_param.frame_timeout) {
2894  err = wait_event_interruptible
2895  ( cam->wait_frame,
2896  (!list_empty(&cam->outqueue)) ||
2897  (cam->state & DEV_DISCONNECTED) ||
2898  (cam->state & DEV_MISCONFIGURED) );
2899  if (err)
2900  return err;
2901  } else {
2902  timeout = wait_event_interruptible_timeout
2903  ( cam->wait_frame,
2904  (!list_empty(&cam->outqueue)) ||
2905  (cam->state & DEV_DISCONNECTED) ||
2906  (cam->state & DEV_MISCONFIGURED),
2907  cam->module_param.frame_timeout *
2908  1000 * msecs_to_jiffies(1) );
2909  if (timeout < 0)
2910  return timeout;
2911  else if (timeout == 0 &&
2912  !(cam->state & DEV_DISCONNECTED)) {
2913  DBG(1, "Video frame timeout elapsed");
2914  return -EIO;
2915  }
2916  }
2917  if (cam->state & DEV_DISCONNECTED)
2918  return -ENODEV;
2919  if (cam->state & DEV_MISCONFIGURED)
2920  return -EIO;
2921  }
2922 
2923  spin_lock_irqsave(&cam->queue_lock, lock_flags);
2924  f = list_entry(cam->outqueue.next, struct sn9c102_frame_t, frame);
2925  list_del(cam->outqueue.next);
2926  spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2927 
2928  f->state = F_UNUSED;
2929 
2930  memcpy(&b, &f->buf, sizeof(b));
2931  if (f->vma_use_count)
2932  b.flags |= V4L2_BUF_FLAG_MAPPED;
2933 
2934  if (copy_to_user(arg, &b, sizeof(b)))
2935  return -EFAULT;
2936 
2937  PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index);
2938 
2939  return 0;
2940 }
2941 
2942 
2943 static int
2944 sn9c102_vidioc_streamon(struct sn9c102_device* cam, void __user * arg)
2945 {
2946  int type;
2947 
2948  if (copy_from_user(&type, arg, sizeof(type)))
2949  return -EFAULT;
2950 
2951  if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2952  return -EINVAL;
2953 
2954  cam->stream = STREAM_ON;
2955 
2956  DBG(3, "Stream on");
2957 
2958  return 0;
2959 }
2960 
2961 
2962 static int
2963 sn9c102_vidioc_streamoff(struct sn9c102_device* cam, void __user * arg)
2964 {
2965  int type, err;
2966 
2967  if (copy_from_user(&type, arg, sizeof(type)))
2968  return -EFAULT;
2969 
2970  if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2971  return -EINVAL;
2972 
2973  if (cam->stream == STREAM_ON)
2974  if ((err = sn9c102_stream_interrupt(cam)))
2975  return err;
2976 
2977  sn9c102_empty_framequeues(cam);
2978 
2979  DBG(3, "Stream off");
2980 
2981  return 0;
2982 }
2983 
2984 
2985 static int
2986 sn9c102_vidioc_g_parm(struct sn9c102_device* cam, void __user * arg)
2987 {
2988  struct v4l2_streamparm sp;
2989 
2990  if (copy_from_user(&sp, arg, sizeof(sp)))
2991  return -EFAULT;
2992 
2993  if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2994  return -EINVAL;
2995 
2996  sp.parm.capture.extendedmode = 0;
2997  sp.parm.capture.readbuffers = cam->nreadbuffers;
2998 
2999  if (copy_to_user(arg, &sp, sizeof(sp)))
3000  return -EFAULT;
3001 
3002  return 0;
3003 }
3004 
3005 
3006 static int
3007 sn9c102_vidioc_s_parm(struct sn9c102_device* cam, void __user * arg)
3008 {
3009  struct v4l2_streamparm sp;
3010 
3011  if (copy_from_user(&sp, arg, sizeof(sp)))
3012  return -EFAULT;
3013 
3014  if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
3015  return -EINVAL;
3016 
3017  sp.parm.capture.extendedmode = 0;
3018 
3019  if (sp.parm.capture.readbuffers == 0)
3020  sp.parm.capture.readbuffers = cam->nreadbuffers;
3021 
3022  if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
3023  sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
3024 
3025  if (copy_to_user(arg, &sp, sizeof(sp)))
3026  return -EFAULT;
3027 
3028  cam->nreadbuffers = sp.parm.capture.readbuffers;
3029 
3030  return 0;
3031 }
3032 
3033 
3034 static int
3035 sn9c102_vidioc_enumaudio(struct sn9c102_device* cam, void __user * arg)
3036 {
3037  struct v4l2_audio audio;
3038 
3039  if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3040  return -EINVAL;
3041 
3042  if (copy_from_user(&audio, arg, sizeof(audio)))
3043  return -EFAULT;
3044 
3045  if (audio.index != 0)
3046  return -EINVAL;
3047 
3048  strcpy(audio.name, "Microphone");
3049  audio.capability = 0;
3050  audio.mode = 0;
3051 
3052  if (copy_to_user(arg, &audio, sizeof(audio)))
3053  return -EFAULT;
3054 
3055  return 0;
3056 }
3057 
3058 
3059 static int
3060 sn9c102_vidioc_g_audio(struct sn9c102_device* cam, void __user * arg)
3061 {
3062  struct v4l2_audio audio;
3063 
3064  if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3065  return -EINVAL;
3066 
3067  if (copy_from_user(&audio, arg, sizeof(audio)))
3068  return -EFAULT;
3069 
3070  memset(&audio, 0, sizeof(audio));
3071  strcpy(audio.name, "Microphone");
3072 
3073  if (copy_to_user(arg, &audio, sizeof(audio)))
3074  return -EFAULT;
3075 
3076  return 0;
3077 }
3078 
3079 
3080 static int
3081 sn9c102_vidioc_s_audio(struct sn9c102_device* cam, void __user * arg)
3082 {
3083  struct v4l2_audio audio;
3084 
3085  if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3086  return -EINVAL;
3087 
3088  if (copy_from_user(&audio, arg, sizeof(audio)))
3089  return -EFAULT;
3090 
3091  if (audio.index != 0)
3092  return -EINVAL;
3093 
3094  return 0;
3095 }
3096 
3097 
3098 static long sn9c102_ioctl_v4l2(struct file *filp,
3099  unsigned int cmd, void __user *arg)
3100 {
3101  struct sn9c102_device *cam = video_drvdata(filp);
3102 
3103  switch (cmd) {
3104 
3105  case VIDIOC_QUERYCAP:
3106  return sn9c102_vidioc_querycap(cam, arg);
3107 
3108  case VIDIOC_ENUMINPUT:
3109  return sn9c102_vidioc_enuminput(cam, arg);
3110 
3111  case VIDIOC_G_INPUT:
3112  return sn9c102_vidioc_g_input(cam, arg);
3113 
3114  case VIDIOC_S_INPUT:
3115  return sn9c102_vidioc_s_input(cam, arg);
3116 
3117  case VIDIOC_QUERYCTRL:
3118  return sn9c102_vidioc_query_ctrl(cam, arg);
3119 
3120  case VIDIOC_G_CTRL:
3121  return sn9c102_vidioc_g_ctrl(cam, arg);
3122 
3123  case VIDIOC_S_CTRL:
3124  return sn9c102_vidioc_s_ctrl(cam, arg);
3125 
3126  case VIDIOC_CROPCAP:
3127  return sn9c102_vidioc_cropcap(cam, arg);
3128 
3129  case VIDIOC_G_CROP:
3130  return sn9c102_vidioc_g_crop(cam, arg);
3131 
3132  case VIDIOC_S_CROP:
3133  return sn9c102_vidioc_s_crop(cam, arg);
3134 
3135  case VIDIOC_ENUM_FRAMESIZES:
3136  return sn9c102_vidioc_enum_framesizes(cam, arg);
3137 
3138  case VIDIOC_ENUM_FMT:
3139  return sn9c102_vidioc_enum_fmt(cam, arg);
3140 
3141  case VIDIOC_G_FMT:
3142  return sn9c102_vidioc_g_fmt(cam, arg);
3143 
3144  case VIDIOC_TRY_FMT:
3145  case VIDIOC_S_FMT:
3146  return sn9c102_vidioc_try_s_fmt(cam, cmd, arg);
3147 
3148  case VIDIOC_G_JPEGCOMP:
3149  return sn9c102_vidioc_g_jpegcomp(cam, arg);
3150 
3151  case VIDIOC_S_JPEGCOMP:
3152  return sn9c102_vidioc_s_jpegcomp(cam, arg);
3153 
3154  case VIDIOC_REQBUFS:
3155  return sn9c102_vidioc_reqbufs(cam, arg);
3156 
3157  case VIDIOC_QUERYBUF:
3158  return sn9c102_vidioc_querybuf(cam, arg);
3159 
3160  case VIDIOC_QBUF:
3161  return sn9c102_vidioc_qbuf(cam, arg);
3162 
3163  case VIDIOC_DQBUF:
3164  return sn9c102_vidioc_dqbuf(cam, filp, arg);
3165 
3166  case VIDIOC_STREAMON:
3167  return sn9c102_vidioc_streamon(cam, arg);
3168 
3169  case VIDIOC_STREAMOFF:
3170  return sn9c102_vidioc_streamoff(cam, arg);
3171 
3172  case VIDIOC_G_PARM:
3173  return sn9c102_vidioc_g_parm(cam, arg);
3174 
3175  case VIDIOC_S_PARM:
3176  return sn9c102_vidioc_s_parm(cam, arg);
3177 
3178  case VIDIOC_ENUMAUDIO:
3179  return sn9c102_vidioc_enumaudio(cam, arg);
3180 
3181  case VIDIOC_G_AUDIO:
3182  return sn9c102_vidioc_g_audio(cam, arg);
3183 
3184  case VIDIOC_S_AUDIO:
3185  return sn9c102_vidioc_s_audio(cam, arg);
3186 
3187  default:
3188  return -ENOTTY;
3189 
3190  }
3191 }
3192 
3193 
3194 static long sn9c102_ioctl(struct file *filp,
3195  unsigned int cmd, unsigned long arg)
3196 {
3197  struct sn9c102_device *cam = video_drvdata(filp);
3198  int err = 0;
3199 
3200  if (mutex_lock_interruptible(&cam->fileop_mutex))
3201  return -ERESTARTSYS;
3202 
3203  if (cam->state & DEV_DISCONNECTED) {
3204  DBG(1, "Device not present");
3205  mutex_unlock(&cam->fileop_mutex);
3206  return -ENODEV;
3207  }
3208 
3209  if (cam->state & DEV_MISCONFIGURED) {
3210  DBG(1, "The camera is misconfigured. Close and open it "
3211  "again.");
3212  mutex_unlock(&cam->fileop_mutex);
3213  return -EIO;
3214  }
3215 
3216  V4LDBG(3, "sn9c102", cmd);
3217 
3218  err = sn9c102_ioctl_v4l2(filp, cmd, (void __user *)arg);
3219 
3220  mutex_unlock(&cam->fileop_mutex);
3221 
3222  return err;
3223 }
3224 
3225 /*****************************************************************************/
3226 
3227 static const struct v4l2_file_operations sn9c102_fops = {
3228  .owner = THIS_MODULE,
3229  .open = sn9c102_open,
3230  .release = sn9c102_release,
3231  .unlocked_ioctl = sn9c102_ioctl,
3232  .read = sn9c102_read,
3233  .poll = sn9c102_poll,
3234  .mmap = sn9c102_mmap,
3235 };
3236 
3237 /*****************************************************************************/
3238 
3239 /* It exists a single interface only. We do not need to validate anything. */
3240 static int
3241 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
3242 {
3243  struct usb_device *udev = interface_to_usbdev(intf);
3244  struct sn9c102_device* cam;
3245  static unsigned int dev_nr;
3246  unsigned int i;
3247  int err = 0, r;
3248 
3249  if (!(cam = kzalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
3250  return -ENOMEM;
3251 
3252  cam->usbdev = udev;
3253 
3254  if (!(cam->control_buffer = kzalloc(8, GFP_KERNEL))) {
3255  DBG(1, "kzalloc() failed");
3256  err = -ENOMEM;
3257  goto fail;
3258  }
3259 
3260  if (!(cam->v4ldev = video_device_alloc())) {
3261  DBG(1, "video_device_alloc() failed");
3262  err = -ENOMEM;
3263  goto fail;
3264  }
3265 
3266  r = sn9c102_read_reg(cam, 0x00);
3267  if (r < 0 || (r != 0x10 && r != 0x11 && r != 0x12)) {
3268  DBG(1, "Sorry, this is not a SN9C1xx-based camera "
3269  "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3270  err = -ENODEV;
3271  goto fail;
3272  }
3273 
3274  cam->bridge = id->driver_info;
3275  switch (cam->bridge) {
3276  case BRIDGE_SN9C101:
3277  case BRIDGE_SN9C102:
3278  DBG(2, "SN9C10[12] PC Camera Controller detected "
3279  "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3280  break;
3281  case BRIDGE_SN9C103:
3282  DBG(2, "SN9C103 PC Camera Controller detected "
3283  "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3284  break;
3285  case BRIDGE_SN9C105:
3286  DBG(2, "SN9C105 PC Camera Controller detected "
3287  "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3288  break;
3289  case BRIDGE_SN9C120:
3290  DBG(2, "SN9C120 PC Camera Controller detected "
3291  "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3292  break;
3293  }
3294 
3295  for (i = 0; i < ARRAY_SIZE(sn9c102_sensor_table); i++) {
3296  err = sn9c102_sensor_table[i](cam);
3297  if (!err)
3298  break;
3299  }
3300 
3301  if (!err) {
3302  DBG(2, "%s image sensor detected", cam->sensor.name);
3303  DBG(3, "Support for %s maintained by %s",
3304  cam->sensor.name, cam->sensor.maintainer);
3305  } else {
3306  DBG(1, "No supported image sensor detected for this bridge");
3307  err = -ENODEV;
3308  goto fail;
3309  }
3310 
3311  if (!(cam->bridge & cam->sensor.supported_bridge)) {
3312  DBG(1, "Bridge not supported");
3313  err = -ENODEV;
3314  goto fail;
3315  }
3316 
3317  if (sn9c102_init(cam)) {
3318  DBG(1, "Initialization failed. I will retry on open().");
3319  cam->state |= DEV_MISCONFIGURED;
3320  }
3321 
3322  strcpy(cam->v4ldev->name, "SN9C1xx PC Camera");
3323  cam->v4ldev->fops = &sn9c102_fops;
3324  cam->v4ldev->release = video_device_release;
3325  cam->v4ldev->parent = &udev->dev;
3326 
3327  init_completion(&cam->probe);
3328 
3329  err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3330  video_nr[dev_nr]);
3331  if (err) {
3332  DBG(1, "V4L2 device registration failed");
3333  if (err == -ENFILE && video_nr[dev_nr] == -1)
3334  DBG(1, "Free /dev/videoX node not found");
3335  video_nr[dev_nr] = -1;
3336  dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3337  complete_all(&cam->probe);
3338  goto fail;
3339  }
3340 
3341  DBG(2, "V4L2 device registered as %s",
3342  video_device_node_name(cam->v4ldev));
3343 
3344  video_set_drvdata(cam->v4ldev, cam);
3345  cam->module_param.force_munmap = force_munmap[dev_nr];
3346  cam->module_param.frame_timeout = frame_timeout[dev_nr];
3347 
3348  dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3349 
3350 #ifdef CONFIG_VIDEO_ADV_DEBUG
3351  err = sn9c102_create_sysfs(cam);
3352  if (!err)
3353  DBG(2, "Optional device control through 'sysfs' "
3354  "interface ready");
3355  else
3356  DBG(2, "Failed to create optional 'sysfs' interface for "
3357  "device controlling. Error #%d", err);
3358 #else
3359  DBG(2, "Optional device control through 'sysfs' interface disabled");
3360  DBG(3, "Compile the kernel with the 'CONFIG_VIDEO_ADV_DEBUG' "
3361  "configuration option to enable it.");
3362 #endif
3363 
3364  usb_set_intfdata(intf, cam);
3365  kref_init(&cam->kref);
3366  usb_get_dev(cam->usbdev);
3367 
3368  complete_all(&cam->probe);
3369 
3370  return 0;
3371 
3372 fail:
3373  if (cam) {
3374  kfree(cam->control_buffer);
3375  if (cam->v4ldev)
3376  video_device_release(cam->v4ldev);
3377  kfree(cam);
3378  }
3379  return err;
3380 }
3381 
3382 
3383 static void sn9c102_usb_disconnect(struct usb_interface* intf)
3384 {
3385  struct sn9c102_device* cam;
3386 
3387  down_write(&sn9c102_dev_lock);
3388 
3389  cam = usb_get_intfdata(intf);
3390 
3391  DBG(2, "Disconnecting %s...", cam->v4ldev->name);
3392 
3393  if (cam->users) {
3394  DBG(2, "Device %s is open! Deregistration and memory "
3395  "deallocation are deferred.",
3396  video_device_node_name(cam->v4ldev));
3397  cam->state |= DEV_MISCONFIGURED;
3398  sn9c102_stop_transfer(cam);
3399  cam->state |= DEV_DISCONNECTED;
3400  wake_up_interruptible(&cam->wait_frame);
3401  wake_up(&cam->wait_stream);
3402  } else
3403  cam->state |= DEV_DISCONNECTED;
3404 
3405  wake_up_interruptible_all(&cam->wait_open);
3406 
3407  kref_put(&cam->kref, sn9c102_release_resources);
3408 
3409  up_write(&sn9c102_dev_lock);
3410 }
3411 
3412 
3413 static struct usb_driver sn9c102_usb_driver = {
3414  .name = "sn9c102",
3415  .id_table = sn9c102_id_table,
3416  .probe = sn9c102_usb_probe,
3417  .disconnect = sn9c102_usb_disconnect,
3418 };
3419 
3420 module_usb_driver(sn9c102_usb_driver);
Generated on Thu Jan 10 2013 13:52:19 for Linux Kernel by   doxygen 1.8.2