1 /***************************************************************************
2 * V4L2 driver for SN9C1xx PC Camera Controllers *
4 * Copyright (C) 2004-2007 by Luca Risolia <luca.risolia@studio.unibo.it> *
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. *
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. *
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 ***************************************************************************/
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>
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>
35 #include <linux/vmalloc.h>
36 #include <linux/version.h>
37 #include <linux/page-flags.h>
38 #include <asm/byteorder.h>
40 #include <asm/uaccess.h>
44 /*****************************************************************************/
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 "<luca.risolia@studio.unibo.it>"
50 #define SN9C102_MODULE_LICENSE "GPL"
51 #define SN9C102_MODULE_VERSION "1:1.48"
53 /*****************************************************************************/
55 MODULE_DEVICE_TABLE(usb, sn9c102_id_table);
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);
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,
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)
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."
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,
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"
88 "\n0 = do not force memory unmapping"
89 "\n1 = force memory unmapping (save memory)"
90 "\nDefault value is "__MODULE_STRING(SN9C102_FORCE_MUNMAP)"."
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,
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)"."
105 static unsigned short debug = SN9C102_DEBUG_LEVEL;
106 module_param(debug, ushort, 0644);
107 MODULE_PARM_DESC(debug,
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)"."
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.
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 */
139 /*****************************************************************************/
142 sn9c102_request_buffers(struct sn9c102_device* cam, u32 count,
143 enum sn9c102_io_method io)
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;
153 if (count > SN9C102_MAX_FRAMES)
154 count = SN9C102_MAX_FRAMES;
156 if (cam->bridge == BRIDGE_SN9C105 || cam->bridge == BRIDGE_SN9C120)
157 imagesize += 589 + 2; /* length of JPEG header + EOI marker */
159 cam->nbuffers = count;
160 while (cam->nbuffers > 0) {
161 if ((buff = vmalloc_32_user(cam->nbuffers *
162 PAGE_ALIGN(imagesize))))
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;
179 return cam->nbuffers;
183 static void sn9c102_release_buffers(struct sn9c102_device* cam)
186 vfree(cam->frame[0].bufmem);
189 cam->frame_current = NULL;
193 static void sn9c102_empty_framequeues(struct sn9c102_device* cam)
197 INIT_LIST_HEAD(&cam->inqueue);
198 INIT_LIST_HEAD(&cam->outqueue);
200 for (i = 0; i < SN9C102_MAX_FRAMES; i++) {
201 cam->frame[i].state = F_UNUSED;
202 cam->frame[i].buf.bytesused = 0;
207 static void sn9c102_requeue_outqueue(struct sn9c102_device* cam)
209 struct sn9c102_frame_t *i;
211 list_for_each_entry(i, &cam->outqueue, frame) {
213 list_add(&i->frame, &cam->inqueue);
216 INIT_LIST_HEAD(&cam->outqueue);
220 static void sn9c102_queue_unusedframes(struct sn9c102_device* cam)
222 unsigned long lock_flags;
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);
234 /*****************************************************************************/
237 Write a sequence of count value/register pairs. Returns -1 after the first
238 failed write, or 0 for no errors.
240 int sn9c102_write_regs(struct sn9c102_device* cam, const u8 valreg[][2],
243 struct usb_device* udev = cam->usbdev;
244 u8* buff = cam->control_buffer;
247 for (i = 0; i < count; i++) {
248 u8 index = valreg[i][1];
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.
257 *buff = valreg[i][0];
259 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08,
260 0x41, index, 0, buff, 1,
261 SN9C102_CTRL_TIMEOUT);
264 DBG(3, "Failed to write a register (value 0x%02X, "
265 "index 0x%02X, error %d)", *buff, index, res);
269 cam->reg[index] = *buff;
276 int sn9c102_write_reg(struct sn9c102_device* cam, u8 value, u16 index)
278 struct usb_device* udev = cam->usbdev;
279 u8* buff = cam->control_buffer;
282 if (index >= ARRAY_SIZE(cam->reg))
287 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
288 index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
290 DBG(3, "Failed to write a register (value 0x%02X, index "
291 "0x%02X, error %d)", value, index, res);
295 cam->reg[index] = value;
301 /* NOTE: with the SN9C10[123] reading some registers always returns 0 */
302 int sn9c102_read_reg(struct sn9c102_device* cam, u16 index)
304 struct usb_device* udev = cam->usbdev;
305 u8* buff = cam->control_buffer;
308 res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
309 index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
311 DBG(3, "Failed to read a register (index 0x%02X, error %d)",
314 return (res >= 0) ? (int)(*buff) : -1;
318 int sn9c102_pread_reg(struct sn9c102_device* cam, u16 index)
320 if (index >= ARRAY_SIZE(cam->reg))
323 return cam->reg[index];
328 sn9c102_i2c_wait(struct sn9c102_device* cam,
329 const struct sn9c102_sensor* sensor)
333 for (i = 1; i <= 5; i++) {
334 r = sn9c102_read_reg(cam, 0x08);
339 if (sensor->frequency & SN9C102_I2C_400KHZ)
349 sn9c102_i2c_detect_read_error(struct sn9c102_device* cam,
350 const struct sn9c102_sensor* sensor)
354 r = sn9c102_read_reg(cam, 0x08);
358 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
366 return err ? -EIO : 0;
371 sn9c102_i2c_detect_write_error(struct sn9c102_device* cam,
372 const struct sn9c102_sensor* sensor)
375 r = sn9c102_read_reg(cam, 0x08);
376 return (r < 0 || (r >= 0 && (r & 0x08))) ? -EIO : 0;
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[])
385 struct usb_device* udev = cam->usbdev;
386 u8* data = cam->control_buffer;
387 int i = 0, err = 0, res;
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 */
395 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
396 0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
400 err += sn9c102_i2c_wait(cam, sensor);
402 /* Read cycle - n bytes */
403 data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
404 ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) |
408 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
409 0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
413 err += sn9c102_i2c_wait(cam, sensor);
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);
421 err += sn9c102_i2c_detect_read_error(cam, sensor);
423 PDBGG("I2C read: address 0x%02X, first read byte: 0x%02X", data1,
427 DBG(3, "I2C read failed for %s image sensor", sensor->name);
432 for (i = 0; i < n && i < 5; i++)
433 buffer[n-i-1] = data[4-i];
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)
444 struct usb_device* udev = cam->usbdev;
445 u8* data = cam->control_buffer;
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)
459 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
460 0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
464 err += sn9c102_i2c_wait(cam, sensor);
465 err += sn9c102_i2c_detect_write_error(cam, sensor);
468 DBG(3, "I2C write failed for %s image sensor", sensor->name);
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);
479 sn9c102_i2c_try_read(struct sn9c102_device* cam,
480 const struct sn9c102_sensor* sensor, u8 address)
482 return sn9c102_i2c_try_raw_read(cam, sensor, sensor->i2c_slave_id,
487 static int sn9c102_i2c_try_write(struct sn9c102_device* cam,
488 const struct sn9c102_sensor* sensor,
489 u8 address, u8 value)
491 return sn9c102_i2c_try_raw_write(cam, sensor, 3,
492 sensor->i2c_slave_id, address,
497 int sn9c102_i2c_read(struct sn9c102_device* cam, u8 address)
499 return sn9c102_i2c_try_read(cam, &cam->sensor, address);
503 int sn9c102_i2c_write(struct sn9c102_device* cam, u8 address, u8 value)
505 return sn9c102_i2c_try_write(cam, &cam->sensor, address, value);
508 /*****************************************************************************/
510 static size_t sn9c102_sof_length(struct sn9c102_device* cam)
512 switch (cam->bridge) {
528 sn9c102_find_sof_header(struct sn9c102_device* cam, void* mem, size_t len)
530 static const char marker[6] = {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96};
532 size_t soflen = 0, i, j;
534 soflen = sn9c102_sof_length(cam);
536 for (i = 0; i < len; i++) {
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;
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))
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);
562 cam->sof.bytesread = 0;
573 sn9c102_find_eof_header(struct sn9c102_device* cam, void* mem, size_t len)
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},
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)
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
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))
603 sn9c102_write_jpegheader(struct sn9c102_device* cam, struct sn9c102_frame_t* f)
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
668 memcpy(pos, jpeg_header, sizeof(jpeg_header));
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);
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;
684 f->buf.bytesused += sizeof(jpeg_header);
688 static void sn9c102_urb_complete(struct urb *urb)
690 struct sn9c102_device* cam = urb->context;
691 struct sn9c102_frame_t** f;
692 size_t imagesize, soflen;
696 if (urb->status == -ENOENT)
699 f = &cam->frame_current;
701 if (cam->stream == STREAM_INTERRUPT) {
702 cam->stream = STREAM_OFF;
704 (*f)->state = F_QUEUED;
705 cam->sof.bytesread = 0;
706 DBG(3, "Stream interrupted by application");
707 wake_up(&cam->wait_stream);
710 if (cam->state & DEV_DISCONNECTED)
713 if (cam->state & DEV_MISCONFIGURED) {
714 wake_up_interruptible(&cam->wait_frame);
718 if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
722 (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
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);
732 for (i = 0; i < urb->number_of_packets; i++) {
733 unsigned int img, len, status;
734 void *pos, *sof, *eof;
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;
741 DBG(3, "Error in isochronous frame");
742 (*f)->state = F_ERROR;
743 cam->sof.bytesread = 0;
747 PDBGG("Isochrnous frame: length %u, #%u i", len, i);
750 sof = sn9c102_find_sof_header(cam, pos, len);
752 eof = sn9c102_find_eof_header(cam, pos, len);
753 if ((*f)->state == F_GRABBING) {
758 img = (eof > pos) ? eof - pos - 1 : 0;
760 if ((*f)->buf.bytesused + img > imagesize) {
762 b = (*f)->buf.bytesused + img -
764 img = imagesize - (*f)->buf.bytesused;
765 PDBGG("Expected EOF not found: video "
768 DBG(3, "Exceeded limit: +%u "
769 "bytes", (unsigned)(b));
772 memcpy((*f)->bufmem + (*f)->buf.bytesused, pos,
775 if ((*f)->buf.bytesused == 0)
776 do_gettimeofday(&(*f)->buf.timestamp);
778 (*f)->buf.bytesused += img;
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)) {
787 b = (*f)->buf.bytesused;
788 (*f)->state = F_DONE;
789 (*f)->buf.sequence= ++cam->frame_count;
791 spin_lock(&cam->queue_lock);
792 list_move_tail(&(*f)->frame,
794 if (!list_empty(&cam->inqueue))
797 struct sn9c102_frame_t,
801 spin_unlock(&cam->queue_lock);
803 memcpy(cam->sysfs.frame_header,
804 cam->sof.header, soflen);
806 DBG(3, "Video frame captured: %lu "
807 "bytes", (unsigned long)(b));
813 (*f)->state = F_ERROR;
814 DBG(3, "Not expected EOF after %lu "
815 "bytes of image data",
817 ((*f)->buf.bytesused));
824 DBG(3, "EOF without SOF");
828 PDBGG("Ignoring pointless isochronous frame");
832 } else if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR) {
834 (*f)->state = F_GRABBING;
835 (*f)->buf.bytesused = 0;
838 if (cam->sensor.pix_format.pixelformat ==
840 sn9c102_write_jpegheader(cam, (*f));
841 DBG(3, "SOF detected: new video frame");
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) */
850 if (cam->sensor.pix_format.pixelformat ==
851 V4L2_PIX_FMT_SN9C10X ||
852 cam->sensor.pix_format.pixelformat ==
854 if (sof - pos >= soflen) {
856 } else { /* remove header */
858 (*f)->buf.bytesused -=
859 (soflen - (sof - pos));
863 DBG(3, "SOF before expected EOF after "
864 "%lu bytes of image data",
866 ((*f)->buf.bytesused));
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");
881 wake_up_interruptible(&cam->wait_frame);
885 static int sn9c102_start_transfer(struct sn9c102_device* cam)
887 struct usb_device *udev = cam->usbdev;
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);
897 for (i = 0; i < SN9C102_URBS; i++) {
898 cam->transfer_buffer[i] = kzalloc(SN9C102_ISO_PACKETS * psz,
900 if (!cam->transfer_buffer[i]) {
902 DBG(1, "Not enough memory");
907 for (i = 0; i < SN9C102_URBS; i++) {
908 urb = usb_alloc_urb(SN9C102_ISO_PACKETS, GFP_KERNEL);
912 DBG(1, "usb_alloc_urb() failed");
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;
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;
931 if (!(cam->reg[0x01] & 0x04)) {
932 err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
935 DBG(1, "I/O hardware error");
940 err = usb_set_interface(udev, 0, SN9C102_ALTERNATE_SETTING);
942 DBG(1, "usb_set_interface() failed");
946 cam->frame_current = NULL;
947 cam->sof.bytesread = 0;
949 for (i = 0; i < SN9C102_URBS; i++) {
950 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
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);
962 for (i = 0; (i < SN9C102_URBS) && cam->urb[i]; i++)
963 usb_free_urb(cam->urb[i]);
966 for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
967 kfree(cam->transfer_buffer[i]);
973 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
975 struct usb_device *udev = cam->usbdev;
979 if (cam->state & DEV_DISCONNECTED)
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]);
988 err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
990 DBG(3, "usb_set_interface() failed");
996 static int sn9c102_stream_interrupt(struct sn9c102_device* cam)
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)
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));
1016 /*****************************************************************************/
1018 #ifdef CONFIG_VIDEO_ADV_DEBUG
1019 static u16 sn9c102_strtou16(const char* buff, size_t len, ssize_t* count)
1026 strncpy(str, buff, len);
1029 strncpy(str, buff, 6);
1033 val = simple_strtoul(str, &endp, 0);
1037 *count = (ssize_t)(endp - str);
1038 if ((*count) && (len == *count+1) && (buff[*count] == '\n'))
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
1050 static ssize_t sn9c102_show_reg(struct device* cd,
1051 struct device_attribute *attr, char* buf)
1053 struct sn9c102_device* cam;
1056 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1057 return -ERESTARTSYS;
1059 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1061 mutex_unlock(&sn9c102_sysfs_lock);
1065 count = sprintf(buf, "%u\n", cam->sysfs.reg);
1067 mutex_unlock(&sn9c102_sysfs_lock);
1074 sn9c102_store_reg(struct device* cd, struct device_attribute *attr,
1075 const char* buf, size_t len)
1077 struct sn9c102_device* cam;
1081 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1082 return -ERESTARTSYS;
1084 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1086 mutex_unlock(&sn9c102_sysfs_lock);
1090 index = sn9c102_strtou16(buf, len, &count);
1091 if (index >= ARRAY_SIZE(cam->reg) || !count) {
1092 mutex_unlock(&sn9c102_sysfs_lock);
1096 cam->sysfs.reg = index;
1098 DBG(2, "Moved SN9C1XX register index to 0x%02X", cam->sysfs.reg);
1099 DBG(3, "Written bytes: %zd", count);
1101 mutex_unlock(&sn9c102_sysfs_lock);
1107 static ssize_t sn9c102_show_val(struct device* cd,
1108 struct device_attribute *attr, char* buf)
1110 struct sn9c102_device* cam;
1114 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1115 return -ERESTARTSYS;
1117 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1119 mutex_unlock(&sn9c102_sysfs_lock);
1123 if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
1124 mutex_unlock(&sn9c102_sysfs_lock);
1128 count = sprintf(buf, "%d\n", val);
1130 DBG(3, "Read bytes: %zd, value: %d", count, val);
1132 mutex_unlock(&sn9c102_sysfs_lock);
1139 sn9c102_store_val(struct device* cd, struct device_attribute *attr,
1140 const char* buf, size_t len)
1142 struct sn9c102_device* cam;
1147 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1148 return -ERESTARTSYS;
1150 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1152 mutex_unlock(&sn9c102_sysfs_lock);
1156 value = sn9c102_strtou16(buf, len, &count);
1158 mutex_unlock(&sn9c102_sysfs_lock);
1162 err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
1164 mutex_unlock(&sn9c102_sysfs_lock);
1168 DBG(2, "Written SN9C1XX reg. 0x%02X, val. 0x%02X",
1169 cam->sysfs.reg, value);
1170 DBG(3, "Written bytes: %zd", count);
1172 mutex_unlock(&sn9c102_sysfs_lock);
1178 static ssize_t sn9c102_show_i2c_reg(struct device* cd,
1179 struct device_attribute *attr, char* buf)
1181 struct sn9c102_device* cam;
1184 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1185 return -ERESTARTSYS;
1187 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1189 mutex_unlock(&sn9c102_sysfs_lock);
1193 count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
1195 DBG(3, "Read bytes: %zd", count);
1197 mutex_unlock(&sn9c102_sysfs_lock);
1204 sn9c102_store_i2c_reg(struct device* cd, struct device_attribute *attr,
1205 const char* buf, size_t len)
1207 struct sn9c102_device* cam;
1211 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1212 return -ERESTARTSYS;
1214 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1216 mutex_unlock(&sn9c102_sysfs_lock);
1220 index = sn9c102_strtou16(buf, len, &count);
1222 mutex_unlock(&sn9c102_sysfs_lock);
1226 cam->sysfs.i2c_reg = index;
1228 DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg);
1229 DBG(3, "Written bytes: %zd", count);
1231 mutex_unlock(&sn9c102_sysfs_lock);
1237 static ssize_t sn9c102_show_i2c_val(struct device* cd,
1238 struct device_attribute *attr, char* buf)
1240 struct sn9c102_device* cam;
1244 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1245 return -ERESTARTSYS;
1247 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1249 mutex_unlock(&sn9c102_sysfs_lock);
1253 if (!(cam->sensor.sysfs_ops & SN9C102_I2C_READ)) {
1254 mutex_unlock(&sn9c102_sysfs_lock);
1258 if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1259 mutex_unlock(&sn9c102_sysfs_lock);
1263 count = sprintf(buf, "%d\n", val);
1265 DBG(3, "Read bytes: %zd, value: %d", count, val);
1267 mutex_unlock(&sn9c102_sysfs_lock);
1274 sn9c102_store_i2c_val(struct device* cd, struct device_attribute *attr,
1275 const char* buf, size_t len)
1277 struct sn9c102_device* cam;
1282 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1283 return -ERESTARTSYS;
1285 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1287 mutex_unlock(&sn9c102_sysfs_lock);
1291 if (!(cam->sensor.sysfs_ops & SN9C102_I2C_WRITE)) {
1292 mutex_unlock(&sn9c102_sysfs_lock);
1296 value = sn9c102_strtou16(buf, len, &count);
1298 mutex_unlock(&sn9c102_sysfs_lock);
1302 err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1304 mutex_unlock(&sn9c102_sysfs_lock);
1308 DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1309 cam->sysfs.i2c_reg, value);
1310 DBG(3, "Written bytes: %zd", count);
1312 mutex_unlock(&sn9c102_sysfs_lock);
1319 sn9c102_store_green(struct device* cd, struct device_attribute *attr,
1320 const char* buf, size_t len)
1322 struct sn9c102_device* cam;
1323 enum sn9c102_bridge bridge;
1328 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1329 return -ERESTARTSYS;
1331 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1333 mutex_unlock(&sn9c102_sysfs_lock);
1337 bridge = cam->bridge;
1339 mutex_unlock(&sn9c102_sysfs_lock);
1341 value = sn9c102_strtou16(buf, len, &count);
1346 case BRIDGE_SN9C101:
1347 case BRIDGE_SN9C102:
1350 if ((res = sn9c102_store_reg(cd, attr, "0x11", 4)) >= 0)
1351 res = sn9c102_store_val(cd, attr, buf, len);
1353 case BRIDGE_SN9C103:
1354 case BRIDGE_SN9C105:
1355 case BRIDGE_SN9C120:
1358 if ((res = sn9c102_store_reg(cd, attr, "0x07", 4)) >= 0)
1359 res = sn9c102_store_val(cd, attr, buf, len);
1368 sn9c102_store_blue(struct device* cd, struct device_attribute *attr,
1369 const char* buf, size_t len)
1375 value = sn9c102_strtou16(buf, len, &count);
1376 if (!count || value > 0x7f)
1379 if ((res = sn9c102_store_reg(cd, attr, "0x06", 4)) >= 0)
1380 res = sn9c102_store_val(cd, attr, buf, len);
1387 sn9c102_store_red(struct device* cd, struct device_attribute *attr,
1388 const char* buf, size_t len)
1394 value = sn9c102_strtou16(buf, len, &count);
1395 if (!count || value > 0x7f)
1398 if ((res = sn9c102_store_reg(cd, attr, "0x05", 4)) >= 0)
1399 res = sn9c102_store_val(cd, attr, buf, len);
1405 static ssize_t sn9c102_show_frame_header(struct device* cd,
1406 struct device_attribute *attr,
1409 struct sn9c102_device* cam;
1412 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1416 count = sizeof(cam->sysfs.frame_header);
1417 memcpy(buf, cam->sysfs.frame_header, count);
1419 DBG(3, "Frame header, read bytes: %zd", count);
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);
1437 static int sn9c102_create_sysfs(struct sn9c102_device* cam)
1439 struct device *dev = &(cam->v4ldev->dev);
1442 if ((err = device_create_file(dev, &dev_attr_reg)))
1444 if ((err = device_create_file(dev, &dev_attr_val)))
1446 if ((err = device_create_file(dev, &dev_attr_frame_header)))
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)))
1456 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
1457 if ((err = device_create_file(dev, &dev_attr_green)))
1460 if ((err = device_create_file(dev, &dev_attr_blue)))
1462 if ((err = device_create_file(dev, &dev_attr_red)))
1469 device_remove_file(dev, &dev_attr_blue);
1471 if (cam->sensor.sysfs_ops)
1472 device_remove_file(dev, &dev_attr_i2c_val);
1474 if (cam->sensor.sysfs_ops)
1475 device_remove_file(dev, &dev_attr_i2c_reg);
1477 device_remove_file(dev, &dev_attr_frame_header);
1479 device_remove_file(dev, &dev_attr_val);
1481 device_remove_file(dev, &dev_attr_reg);
1485 #endif /* CONFIG_VIDEO_ADV_DEBUG */
1487 /*****************************************************************************/
1490 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
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,
1503 case BRIDGE_SN9C105:
1504 case BRIDGE_SN9C120:
1505 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
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,
1517 case BRIDGE_SN9C105:
1518 case BRIDGE_SN9C120:
1519 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1525 return err ? -EIO : 0;
1530 sn9c102_set_compression(struct sn9c102_device* cam,
1531 struct v4l2_jpegcompression* compression)
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,
1542 else if (compression->quality == 1)
1543 err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe,
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],
1553 err += sn9c102_write_reg(cam,
1554 SN9C102_UV_QTABLE1[i],
1557 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0xbf,
1559 } else if (compression->quality == 1) {
1560 for (i = 0; i <= 63; i++) {
1561 err += sn9c102_write_reg(cam,
1562 SN9C102_Y_QTABLE1[i],
1564 err += sn9c102_write_reg(cam,
1565 SN9C102_UV_QTABLE1[i],
1568 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x40,
1574 return err ? -EIO : 0;
1578 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1584 r = cam->reg[0x18] & 0xcf;
1585 else if (scale == 2) {
1586 r = cam->reg[0x18] & 0xcf;
1588 } else if (scale == 4)
1589 r = cam->reg[0x18] | 0x20;
1591 err += sn9c102_write_reg(cam, r, 0x18);
1595 PDBGG("Scaling factor: %u", scale);
1601 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
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);
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);
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);
1624 static int sn9c102_init(struct sn9c102_device* cam)
1626 struct sn9c102_sensor* s = &cam->sensor;
1627 struct v4l2_control ctrl;
1628 struct v4l2_queryctrl *qctrl;
1629 struct v4l2_rect* rect;
1633 if (!(cam->state & DEV_INITIALIZED)) {
1634 mutex_init(&cam->open_mutex);
1635 init_waitqueue_head(&cam->wait_open);
1637 rect = &(s->cropcap.defrect);
1638 } else { /* use current values */
1643 err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1644 err += sn9c102_set_crop(cam, rect);
1651 DBG(3, "Sensor initialization failed");
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 ?
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 ?
1669 err += sn9c102_set_compression(cam, &cam->compression);
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);
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);
1684 DBG(3, "Uncompressed video format is active");
1687 if ((err = s->set_crop(cam, rect))) {
1688 DBG(3, "set_crop() failed");
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);
1700 DBG(3, "Set %s control failed",
1704 DBG(3, "Image sensor supports '%s' control",
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;
1721 DBG(2, "Initialization succeeded");
1725 /*****************************************************************************/
1727 static void sn9c102_release_resources(struct kref *kref)
1729 struct sn9c102_device *cam;
1731 mutex_lock(&sn9c102_sysfs_lock);
1733 cam = container_of(kref, struct sn9c102_device, kref);
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);
1743 mutex_unlock(&sn9c102_sysfs_lock);
1748 static int sn9c102_open(struct file *filp)
1750 struct sn9c102_device* cam;
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.
1765 if (!down_read_trylock(&sn9c102_dev_lock))
1766 return -ERESTARTSYS;
1768 cam = video_drvdata(filp);
1770 if (wait_for_completion_interruptible(&cam->probe)) {
1771 up_read(&sn9c102_dev_lock);
1772 return -ERESTARTSYS;
1775 kref_get(&cam->kref);
1778 Make sure to isolate all the simultaneous opens.
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;
1786 if (cam->state & DEV_DISCONNECTED) {
1787 DBG(1, "Device not present");
1793 DBG(2, "Device %s is already in use",
1794 video_device_node_name(cam->v4ldev));
1795 DBG(3, "Simultaneous opens are not supported");
1797 open() must follow the open flags and should block
1798 eventually while the device is in use.
1800 if ((filp->f_flags & O_NONBLOCK) ||
1801 (filp->f_flags & O_NDELAY)) {
1805 DBG(2, "A blocking open() has been requested. Wait for the "
1806 "device to be released...");
1807 up_read(&sn9c102_dev_lock);
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().
1814 err = wait_event_interruptible_exclusive(cam->wait_open,
1815 (cam->state & DEV_DISCONNECTED)
1817 down_read(&sn9c102_dev_lock);
1820 if (cam->state & DEV_DISCONNECTED) {
1826 if (cam->state & DEV_MISCONFIGURED) {
1827 err = sn9c102_init(cam);
1829 DBG(1, "Initialization failed again. "
1830 "I will retry on next open().");
1833 cam->state &= ~DEV_MISCONFIGURED;
1836 if ((err = sn9c102_start_transfer(cam)))
1839 filp->private_data = cam;
1842 cam->stream = STREAM_OFF;
1844 cam->frame_count = 0;
1845 sn9c102_empty_framequeues(cam);
1847 DBG(3, "Video device %s is open", video_device_node_name(cam->v4ldev));
1850 mutex_unlock(&cam->open_mutex);
1852 kref_put(&cam->kref, sn9c102_release_resources);
1854 up_read(&sn9c102_dev_lock);
1859 static int sn9c102_release(struct file *filp)
1861 struct sn9c102_device* cam;
1863 down_write(&sn9c102_dev_lock);
1865 cam = video_drvdata(filp);
1867 sn9c102_stop_transfer(cam);
1868 sn9c102_release_buffers(cam);
1870 wake_up_interruptible_nr(&cam->wait_open, 1);
1872 DBG(3, "Video device %s closed", video_device_node_name(cam->v4ldev));
1874 kref_put(&cam->kref, sn9c102_release_resources);
1876 up_write(&sn9c102_dev_lock);
1883 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1885 struct sn9c102_device *cam = video_drvdata(filp);
1886 struct sn9c102_frame_t* f, * i;
1887 unsigned long lock_flags;
1891 if (mutex_lock_interruptible(&cam->fileop_mutex))
1892 return -ERESTARTSYS;
1894 if (cam->state & DEV_DISCONNECTED) {
1895 DBG(1, "Device not present");
1896 mutex_unlock(&cam->fileop_mutex);
1900 if (cam->state & DEV_MISCONFIGURED) {
1901 DBG(1, "The camera is misconfigured. Close and open it "
1903 mutex_unlock(&cam->fileop_mutex);
1907 if (cam->io == IO_MMAP) {
1908 DBG(3, "Close and open the device again to choose "
1910 mutex_unlock(&cam->fileop_mutex);
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);
1921 cam->stream = STREAM_ON;
1924 if (list_empty(&cam->inqueue)) {
1925 if (!list_empty(&cam->outqueue))
1926 sn9c102_empty_framequeues(cam);
1927 sn9c102_queue_unusedframes(cam);
1931 mutex_unlock(&cam->fileop_mutex);
1935 if (list_empty(&cam->outqueue)) {
1936 if (filp->f_flags & O_NONBLOCK) {
1937 mutex_unlock(&cam->fileop_mutex);
1940 if (!cam->module_param.frame_timeout) {
1941 err = wait_event_interruptible
1943 (!list_empty(&cam->outqueue)) ||
1944 (cam->state & DEV_DISCONNECTED) ||
1945 (cam->state & DEV_MISCONFIGURED) );
1947 mutex_unlock(&cam->fileop_mutex);
1951 timeout = wait_event_interruptible_timeout
1953 (!list_empty(&cam->outqueue)) ||
1954 (cam->state & DEV_DISCONNECTED) ||
1955 (cam->state & DEV_MISCONFIGURED),
1957 cam->module_param.frame_timeout * 1000
1961 mutex_unlock(&cam->fileop_mutex);
1963 } else if (timeout == 0 &&
1964 !(cam->state & DEV_DISCONNECTED)) {
1965 DBG(1, "Video frame timeout elapsed");
1966 mutex_unlock(&cam->fileop_mutex);
1970 if (cam->state & DEV_DISCONNECTED) {
1971 mutex_unlock(&cam->fileop_mutex);
1974 if (cam->state & DEV_MISCONFIGURED) {
1975 mutex_unlock(&cam->fileop_mutex);
1980 f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1982 if (count > f->buf.bytesused)
1983 count = f->buf.bytesused;
1985 if (copy_to_user(buf, f->bufmem, count)) {
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);
1998 sn9c102_queue_unusedframes(cam);
2000 PDBGG("Frame #%lu, bytes read: %zu",
2001 (unsigned long)f->buf.index, count);
2003 mutex_unlock(&cam->fileop_mutex);
2009 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
2011 struct sn9c102_device *cam = video_drvdata(filp);
2012 struct sn9c102_frame_t* f;
2013 unsigned long lock_flags;
2014 unsigned int mask = 0;
2016 if (mutex_lock_interruptible(&cam->fileop_mutex))
2019 if (cam->state & DEV_DISCONNECTED) {
2020 DBG(1, "Device not present");
2024 if (cam->state & DEV_MISCONFIGURED) {
2025 DBG(1, "The camera is misconfigured. Close and open it "
2030 if (cam->io == IO_NONE) {
2031 if (!sn9c102_request_buffers(cam, cam->nreadbuffers,
2033 DBG(1, "poll() failed, not enough memory");
2037 cam->stream = STREAM_ON;
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);
2049 poll_wait(filp, &cam->wait_frame, wait);
2051 if (!list_empty(&cam->outqueue))
2052 mask |= POLLIN | POLLRDNORM;
2054 mutex_unlock(&cam->fileop_mutex);
2059 mutex_unlock(&cam->fileop_mutex);
2064 static void sn9c102_vm_open(struct vm_area_struct* vma)
2066 struct sn9c102_frame_t* f = vma->vm_private_data;
2071 static void sn9c102_vm_close(struct vm_area_struct* vma)
2073 /* NOTE: buffers are not freed here */
2074 struct sn9c102_frame_t* f = vma->vm_private_data;
2079 static const struct vm_operations_struct sn9c102_vm_ops = {
2080 .open = sn9c102_vm_open,
2081 .close = sn9c102_vm_close,
2085 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
2087 struct sn9c102_device *cam = video_drvdata(filp);
2088 unsigned long size = vma->vm_end - vma->vm_start,
2089 start = vma->vm_start;
2093 if (mutex_lock_interruptible(&cam->fileop_mutex))
2094 return -ERESTARTSYS;
2096 if (cam->state & DEV_DISCONNECTED) {
2097 DBG(1, "Device not present");
2098 mutex_unlock(&cam->fileop_mutex);
2102 if (cam->state & DEV_MISCONFIGURED) {
2103 DBG(1, "The camera is misconfigured. Close and open it "
2105 mutex_unlock(&cam->fileop_mutex);
2109 if (!(vma->vm_flags & (VM_WRITE | VM_READ))) {
2110 mutex_unlock(&cam->fileop_mutex);
2114 if (cam->io != IO_MMAP ||
2115 size != PAGE_ALIGN(cam->frame[0].buf.length)) {
2116 mutex_unlock(&cam->fileop_mutex);
2120 for (i = 0; i < cam->nbuffers; i++) {
2121 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
2124 if (i == cam->nbuffers) {
2125 mutex_unlock(&cam->fileop_mutex);
2129 vma->vm_flags |= VM_IO;
2130 vma->vm_flags |= VM_RESERVED;
2132 pos = cam->frame[i].bufmem;
2133 while (size > 0) { /* size is page-aligned */
2134 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
2135 mutex_unlock(&cam->fileop_mutex);
2143 vma->vm_ops = &sn9c102_vm_ops;
2144 vma->vm_private_data = &cam->frame[i];
2145 sn9c102_vm_open(vma);
2147 mutex_unlock(&cam->fileop_mutex);
2152 /*****************************************************************************/
2155 sn9c102_vidioc_querycap(struct sn9c102_device* cam, void __user * arg)
2157 struct v4l2_capability cap = {
2158 .driver = "sn9c102",
2159 .version = LINUX_VERSION_CODE,
2160 .capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2164 strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
2165 if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
2166 strlcpy(cap.bus_info, dev_name(&cam->usbdev->dev),
2167 sizeof(cap.bus_info));
2169 if (copy_to_user(arg, &cap, sizeof(cap)))
2177 sn9c102_vidioc_enuminput(struct sn9c102_device* cam, void __user * arg)
2179 struct v4l2_input i;
2181 if (copy_from_user(&i, arg, sizeof(i)))
2187 memset(&i, 0, sizeof(i));
2188 strcpy(i.name, "Camera");
2189 i.type = V4L2_INPUT_TYPE_CAMERA;
2190 i.capabilities = V4L2_IN_CAP_STD;
2192 if (copy_to_user(arg, &i, sizeof(i)))
2200 sn9c102_vidioc_g_input(struct sn9c102_device* cam, void __user * arg)
2204 if (copy_to_user(arg, &index, sizeof(index)))
2212 sn9c102_vidioc_s_input(struct sn9c102_device* cam, void __user * arg)
2216 if (copy_from_user(&index, arg, sizeof(index)))
2227 sn9c102_vidioc_query_ctrl(struct sn9c102_device* cam, void __user * arg)
2229 struct sn9c102_sensor* s = &cam->sensor;
2230 struct v4l2_queryctrl qc;
2233 if (copy_from_user(&qc, arg, sizeof(qc)))
2236 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2237 if (qc.id && qc.id == s->qctrl[i].id) {
2238 memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
2239 if (copy_to_user(arg, &qc, sizeof(qc)))
2249 sn9c102_vidioc_g_ctrl(struct sn9c102_device* cam, void __user * arg)
2251 struct sn9c102_sensor* s = &cam->sensor;
2252 struct v4l2_control ctrl;
2256 if (!s->get_ctrl && !s->set_ctrl)
2259 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2263 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2264 if (ctrl.id && ctrl.id == s->qctrl[i].id) {
2265 ctrl.value = s->_qctrl[i].default_value;
2270 err = s->get_ctrl(cam, &ctrl);
2273 if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
2276 PDBGG("VIDIOC_G_CTRL: id %lu, value %lu",
2277 (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2284 sn9c102_vidioc_s_ctrl(struct sn9c102_device* cam, void __user * arg)
2286 struct sn9c102_sensor* s = &cam->sensor;
2287 struct v4l2_control ctrl;
2294 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2297 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++) {
2298 if (ctrl.id == s->qctrl[i].id) {
2299 if (s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)
2301 if (ctrl.value < s->qctrl[i].minimum ||
2302 ctrl.value > s->qctrl[i].maximum)
2304 ctrl.value -= ctrl.value % s->qctrl[i].step;
2308 if (i == ARRAY_SIZE(s->qctrl))
2310 if ((err = s->set_ctrl(cam, &ctrl)))
2313 s->_qctrl[i].default_value = ctrl.value;
2315 PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
2316 (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2323 sn9c102_vidioc_cropcap(struct sn9c102_device* cam, void __user * arg)
2325 struct v4l2_cropcap* cc = &(cam->sensor.cropcap);
2327 cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2328 cc->pixelaspect.numerator = 1;
2329 cc->pixelaspect.denominator = 1;
2331 if (copy_to_user(arg, cc, sizeof(*cc)))
2339 sn9c102_vidioc_g_crop(struct sn9c102_device* cam, void __user * arg)
2341 struct sn9c102_sensor* s = &cam->sensor;
2342 struct v4l2_crop crop = {
2343 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
2346 memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
2348 if (copy_to_user(arg, &crop, sizeof(crop)))
2356 sn9c102_vidioc_s_crop(struct sn9c102_device* cam, void __user * arg)
2358 struct sn9c102_sensor* s = &cam->sensor;
2359 struct v4l2_crop crop;
2360 struct v4l2_rect* rect;
2361 struct v4l2_rect* bounds = &(s->cropcap.bounds);
2362 struct v4l2_pix_format* pix_format = &(s->pix_format);
2364 const enum sn9c102_stream_state stream = cam->stream;
2365 const u32 nbuffers = cam->nbuffers;
2369 if (copy_from_user(&crop, arg, sizeof(crop)))
2374 if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2377 if (cam->module_param.force_munmap)
2378 for (i = 0; i < cam->nbuffers; i++)
2379 if (cam->frame[i].vma_use_count) {
2380 DBG(3, "VIDIOC_S_CROP failed. "
2381 "Unmap the buffers first.");
2385 /* Preserve R,G or B origin */
2386 rect->left = (s->_rect.left & 1L) ? rect->left | 1L : rect->left & ~1L;
2387 rect->top = (s->_rect.top & 1L) ? rect->top | 1L : rect->top & ~1L;
2389 if (rect->width < 16)
2391 if (rect->height < 16)
2393 if (rect->width > bounds->width)
2394 rect->width = bounds->width;
2395 if (rect->height > bounds->height)
2396 rect->height = bounds->height;
2397 if (rect->left < bounds->left)
2398 rect->left = bounds->left;
2399 if (rect->top < bounds->top)
2400 rect->top = bounds->top;
2401 if (rect->left + rect->width > bounds->left + bounds->width)
2402 rect->left = bounds->left+bounds->width - rect->width;
2403 if (rect->top + rect->height > bounds->top + bounds->height)
2404 rect->top = bounds->top+bounds->height - rect->height;
2406 rect->width &= ~15L;
2407 rect->height &= ~15L;
2409 if (SN9C102_PRESERVE_IMGSCALE) {
2410 /* Calculate the actual scaling factor */
2412 a = rect->width * rect->height;
2413 b = pix_format->width * pix_format->height;
2414 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2418 if (cam->stream == STREAM_ON)
2419 if ((err = sn9c102_stream_interrupt(cam)))
2422 if (copy_to_user(arg, &crop, sizeof(crop))) {
2423 cam->stream = stream;
2427 if (cam->module_param.force_munmap || cam->io == IO_READ)
2428 sn9c102_release_buffers(cam);
2430 err = sn9c102_set_crop(cam, rect);
2432 err += s->set_crop(cam, rect);
2433 err += sn9c102_set_scale(cam, scale);
2435 if (err) { /* atomic, no rollback in ioctl() */
2436 cam->state |= DEV_MISCONFIGURED;
2437 DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
2438 "use the camera, close and open %s again.",
2439 video_device_node_name(cam->v4ldev));
2443 s->pix_format.width = rect->width/scale;
2444 s->pix_format.height = rect->height/scale;
2445 memcpy(&(s->_rect), rect, sizeof(*rect));
2447 if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2448 nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2449 cam->state |= DEV_MISCONFIGURED;
2450 DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
2451 "use the camera, close and open %s again.",
2452 video_device_node_name(cam->v4ldev));
2456 if (cam->io == IO_READ)
2457 sn9c102_empty_framequeues(cam);
2458 else if (cam->module_param.force_munmap)
2459 sn9c102_requeue_outqueue(cam);
2461 cam->stream = stream;
2468 sn9c102_vidioc_enum_framesizes(struct sn9c102_device* cam, void __user * arg)
2470 struct v4l2_frmsizeenum frmsize;
2472 if (copy_from_user(&frmsize, arg, sizeof(frmsize)))
2475 if (frmsize.index != 0)
2478 switch (cam->bridge) {
2479 case BRIDGE_SN9C101:
2480 case BRIDGE_SN9C102:
2481 case BRIDGE_SN9C103:
2482 if (frmsize.pixel_format != V4L2_PIX_FMT_SN9C10X &&
2483 frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2485 case BRIDGE_SN9C105:
2486 case BRIDGE_SN9C120:
2487 if (frmsize.pixel_format != V4L2_PIX_FMT_JPEG &&
2488 frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2492 frmsize.type = V4L2_FRMSIZE_TYPE_STEPWISE;
2493 frmsize.stepwise.min_width = frmsize.stepwise.step_width = 16;
2494 frmsize.stepwise.min_height = frmsize.stepwise.step_height = 16;
2495 frmsize.stepwise.max_width = cam->sensor.cropcap.bounds.width;
2496 frmsize.stepwise.max_height = cam->sensor.cropcap.bounds.height;
2497 memset(&frmsize.reserved, 0, sizeof(frmsize.reserved));
2499 if (copy_to_user(arg, &frmsize, sizeof(frmsize)))
2507 sn9c102_vidioc_enum_fmt(struct sn9c102_device* cam, void __user * arg)
2509 struct v4l2_fmtdesc fmtd;
2511 if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
2514 if (fmtd.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2517 if (fmtd.index == 0) {
2518 strcpy(fmtd.description, "bayer rgb");
2519 fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
2520 } else if (fmtd.index == 1) {
2521 switch (cam->bridge) {
2522 case BRIDGE_SN9C101:
2523 case BRIDGE_SN9C102:
2524 case BRIDGE_SN9C103:
2525 strcpy(fmtd.description, "compressed");
2526 fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
2528 case BRIDGE_SN9C105:
2529 case BRIDGE_SN9C120:
2530 strcpy(fmtd.description, "JPEG");
2531 fmtd.pixelformat = V4L2_PIX_FMT_JPEG;
2534 fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
2538 fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2539 memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
2541 if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
2549 sn9c102_vidioc_g_fmt(struct sn9c102_device* cam, void __user * arg)
2551 struct v4l2_format format;
2552 struct v4l2_pix_format* pfmt = &(cam->sensor.pix_format);
2554 if (copy_from_user(&format, arg, sizeof(format)))
2557 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2560 pfmt->colorspace = (pfmt->pixelformat == V4L2_PIX_FMT_JPEG) ?
2561 V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2562 pfmt->bytesperline = (pfmt->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2563 pfmt->pixelformat == V4L2_PIX_FMT_JPEG)
2564 ? 0 : (pfmt->width * pfmt->priv) / 8;
2565 pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
2566 pfmt->field = V4L2_FIELD_NONE;
2567 memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
2569 if (copy_to_user(arg, &format, sizeof(format)))
2577 sn9c102_vidioc_try_s_fmt(struct sn9c102_device* cam, unsigned int cmd,
2580 struct sn9c102_sensor* s = &cam->sensor;
2581 struct v4l2_format format;
2582 struct v4l2_pix_format* pix;
2583 struct v4l2_pix_format* pfmt = &(s->pix_format);
2584 struct v4l2_rect* bounds = &(s->cropcap.bounds);
2585 struct v4l2_rect rect;
2587 const enum sn9c102_stream_state stream = cam->stream;
2588 const u32 nbuffers = cam->nbuffers;
2592 if (copy_from_user(&format, arg, sizeof(format)))
2595 pix = &(format.fmt.pix);
2597 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2600 memcpy(&rect, &(s->_rect), sizeof(rect));
2602 { /* calculate the actual scaling factor */
2604 a = rect.width * rect.height;
2605 b = pix->width * pix->height;
2606 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2609 rect.width = scale * pix->width;
2610 rect.height = scale * pix->height;
2612 if (rect.width < 16)
2614 if (rect.height < 16)
2616 if (rect.width > bounds->left + bounds->width - rect.left)
2617 rect.width = bounds->left + bounds->width - rect.left;
2618 if (rect.height > bounds->top + bounds->height - rect.top)
2619 rect.height = bounds->top + bounds->height - rect.top;
2622 rect.height &= ~15L;
2624 { /* adjust the scaling factor */
2626 a = rect.width * rect.height;
2627 b = pix->width * pix->height;
2628 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2631 pix->width = rect.width / scale;
2632 pix->height = rect.height / scale;
2634 switch (cam->bridge) {
2635 case BRIDGE_SN9C101:
2636 case BRIDGE_SN9C102:
2637 case BRIDGE_SN9C103:
2638 if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2639 pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2640 pix->pixelformat = pfmt->pixelformat;
2642 case BRIDGE_SN9C105:
2643 case BRIDGE_SN9C120:
2644 if (pix->pixelformat != V4L2_PIX_FMT_JPEG &&
2645 pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2646 pix->pixelformat = pfmt->pixelformat;
2649 pix->priv = pfmt->priv; /* bpp */
2650 pix->colorspace = (pix->pixelformat == V4L2_PIX_FMT_JPEG) ?
2651 V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2652 pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2653 pix->pixelformat == V4L2_PIX_FMT_JPEG)
2654 ? 0 : (pix->width * pix->priv) / 8;
2655 pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2656 pix->field = V4L2_FIELD_NONE;
2658 if (cmd == VIDIOC_TRY_FMT) {
2659 if (copy_to_user(arg, &format, sizeof(format)))
2664 if (cam->module_param.force_munmap)
2665 for (i = 0; i < cam->nbuffers; i++)
2666 if (cam->frame[i].vma_use_count) {
2667 DBG(3, "VIDIOC_S_FMT failed. Unmap the "
2672 if (cam->stream == STREAM_ON)
2673 if ((err = sn9c102_stream_interrupt(cam)))
2676 if (copy_to_user(arg, &format, sizeof(format))) {
2677 cam->stream = stream;
2681 if (cam->module_param.force_munmap || cam->io == IO_READ)
2682 sn9c102_release_buffers(cam);
2684 err += sn9c102_set_pix_format(cam, pix);
2685 err += sn9c102_set_crop(cam, &rect);
2686 if (s->set_pix_format)
2687 err += s->set_pix_format(cam, pix);
2689 err += s->set_crop(cam, &rect);
2690 err += sn9c102_set_scale(cam, scale);
2692 if (err) { /* atomic, no rollback in ioctl() */
2693 cam->state |= DEV_MISCONFIGURED;
2694 DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
2695 "use the camera, close and open %s again.",
2696 video_device_node_name(cam->v4ldev));
2700 memcpy(pfmt, pix, sizeof(*pix));
2701 memcpy(&(s->_rect), &rect, sizeof(rect));
2703 if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2704 nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2705 cam->state |= DEV_MISCONFIGURED;
2706 DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
2707 "use the camera, close and open %s again.",
2708 video_device_node_name(cam->v4ldev));
2712 if (cam->io == IO_READ)
2713 sn9c102_empty_framequeues(cam);
2714 else if (cam->module_param.force_munmap)
2715 sn9c102_requeue_outqueue(cam);
2717 cam->stream = stream;
2724 sn9c102_vidioc_g_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2726 if (copy_to_user(arg, &cam->compression, sizeof(cam->compression)))
2734 sn9c102_vidioc_s_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2736 struct v4l2_jpegcompression jc;
2737 const enum sn9c102_stream_state stream = cam->stream;
2740 if (copy_from_user(&jc, arg, sizeof(jc)))
2743 if (jc.quality != 0 && jc.quality != 1)
2746 if (cam->stream == STREAM_ON)
2747 if ((err = sn9c102_stream_interrupt(cam)))
2750 err += sn9c102_set_compression(cam, &jc);
2751 if (err) { /* atomic, no rollback in ioctl() */
2752 cam->state |= DEV_MISCONFIGURED;
2753 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware problems. "
2754 "To use the camera, close and open %s again.",
2755 video_device_node_name(cam->v4ldev));
2759 cam->compression.quality = jc.quality;
2761 cam->stream = stream;
2768 sn9c102_vidioc_reqbufs(struct sn9c102_device* cam, void __user * arg)
2770 struct v4l2_requestbuffers rb;
2774 if (copy_from_user(&rb, arg, sizeof(rb)))
2777 if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2778 rb.memory != V4L2_MEMORY_MMAP)
2781 if (cam->io == IO_READ) {
2782 DBG(3, "Close and open the device again to choose the mmap "
2787 for (i = 0; i < cam->nbuffers; i++)
2788 if (cam->frame[i].vma_use_count) {
2789 DBG(3, "VIDIOC_REQBUFS failed. Previous buffers are "
2794 if (cam->stream == STREAM_ON)
2795 if ((err = sn9c102_stream_interrupt(cam)))
2798 sn9c102_empty_framequeues(cam);
2800 sn9c102_release_buffers(cam);
2802 rb.count = sn9c102_request_buffers(cam, rb.count, IO_MMAP);
2804 if (copy_to_user(arg, &rb, sizeof(rb))) {
2805 sn9c102_release_buffers(cam);
2810 cam->io = rb.count ? IO_MMAP : IO_NONE;
2817 sn9c102_vidioc_querybuf(struct sn9c102_device* cam, void __user * arg)
2819 struct v4l2_buffer b;
2821 if (copy_from_user(&b, arg, sizeof(b)))
2824 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2825 b.index >= cam->nbuffers || cam->io != IO_MMAP)
2828 memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2830 if (cam->frame[b.index].vma_use_count)
2831 b.flags |= V4L2_BUF_FLAG_MAPPED;
2833 if (cam->frame[b.index].state == F_DONE)
2834 b.flags |= V4L2_BUF_FLAG_DONE;
2835 else if (cam->frame[b.index].state != F_UNUSED)
2836 b.flags |= V4L2_BUF_FLAG_QUEUED;
2838 if (copy_to_user(arg, &b, sizeof(b)))
2846 sn9c102_vidioc_qbuf(struct sn9c102_device* cam, void __user * arg)
2848 struct v4l2_buffer b;
2849 unsigned long lock_flags;
2851 if (copy_from_user(&b, arg, sizeof(b)))
2854 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2855 b.index >= cam->nbuffers || cam->io != IO_MMAP)
2858 if (cam->frame[b.index].state != F_UNUSED)
2861 cam->frame[b.index].state = F_QUEUED;
2863 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2864 list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2865 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2867 PDBGG("Frame #%lu queued", (unsigned long)b.index);
2874 sn9c102_vidioc_dqbuf(struct sn9c102_device* cam, struct file* filp,
2877 struct v4l2_buffer b;
2878 struct sn9c102_frame_t *f;
2879 unsigned long lock_flags;
2883 if (copy_from_user(&b, arg, sizeof(b)))
2886 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2889 if (list_empty(&cam->outqueue)) {
2890 if (cam->stream == STREAM_OFF)
2892 if (filp->f_flags & O_NONBLOCK)
2894 if (!cam->module_param.frame_timeout) {
2895 err = wait_event_interruptible
2897 (!list_empty(&cam->outqueue)) ||
2898 (cam->state & DEV_DISCONNECTED) ||
2899 (cam->state & DEV_MISCONFIGURED) );
2903 timeout = wait_event_interruptible_timeout
2905 (!list_empty(&cam->outqueue)) ||
2906 (cam->state & DEV_DISCONNECTED) ||
2907 (cam->state & DEV_MISCONFIGURED),
2908 cam->module_param.frame_timeout *
2909 1000 * msecs_to_jiffies(1) );
2912 else if (timeout == 0 &&
2913 !(cam->state & DEV_DISCONNECTED)) {
2914 DBG(1, "Video frame timeout elapsed");
2918 if (cam->state & DEV_DISCONNECTED)
2920 if (cam->state & DEV_MISCONFIGURED)
2924 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2925 f = list_entry(cam->outqueue.next, struct sn9c102_frame_t, frame);
2926 list_del(cam->outqueue.next);
2927 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2929 f->state = F_UNUSED;
2931 memcpy(&b, &f->buf, sizeof(b));
2932 if (f->vma_use_count)
2933 b.flags |= V4L2_BUF_FLAG_MAPPED;
2935 if (copy_to_user(arg, &b, sizeof(b)))
2938 PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index);
2945 sn9c102_vidioc_streamon(struct sn9c102_device* cam, void __user * arg)
2949 if (copy_from_user(&type, arg, sizeof(type)))
2952 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2955 cam->stream = STREAM_ON;
2957 DBG(3, "Stream on");
2964 sn9c102_vidioc_streamoff(struct sn9c102_device* cam, void __user * arg)
2968 if (copy_from_user(&type, arg, sizeof(type)))
2971 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2974 if (cam->stream == STREAM_ON)
2975 if ((err = sn9c102_stream_interrupt(cam)))
2978 sn9c102_empty_framequeues(cam);
2980 DBG(3, "Stream off");
2987 sn9c102_vidioc_g_parm(struct sn9c102_device* cam, void __user * arg)
2989 struct v4l2_streamparm sp;
2991 if (copy_from_user(&sp, arg, sizeof(sp)))
2994 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2997 sp.parm.capture.extendedmode = 0;
2998 sp.parm.capture.readbuffers = cam->nreadbuffers;
3000 if (copy_to_user(arg, &sp, sizeof(sp)))
3008 sn9c102_vidioc_s_parm(struct sn9c102_device* cam, void __user * arg)
3010 struct v4l2_streamparm sp;
3012 if (copy_from_user(&sp, arg, sizeof(sp)))
3015 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
3018 sp.parm.capture.extendedmode = 0;
3020 if (sp.parm.capture.readbuffers == 0)
3021 sp.parm.capture.readbuffers = cam->nreadbuffers;
3023 if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
3024 sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
3026 if (copy_to_user(arg, &sp, sizeof(sp)))
3029 cam->nreadbuffers = sp.parm.capture.readbuffers;
3036 sn9c102_vidioc_enumaudio(struct sn9c102_device* cam, void __user * arg)
3038 struct v4l2_audio audio;
3040 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3043 if (copy_from_user(&audio, arg, sizeof(audio)))
3046 if (audio.index != 0)
3049 strcpy(audio.name, "Microphone");
3050 audio.capability = 0;
3053 if (copy_to_user(arg, &audio, sizeof(audio)))
3061 sn9c102_vidioc_g_audio(struct sn9c102_device* cam, void __user * arg)
3063 struct v4l2_audio audio;
3065 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3068 if (copy_from_user(&audio, arg, sizeof(audio)))
3071 memset(&audio, 0, sizeof(audio));
3072 strcpy(audio.name, "Microphone");
3074 if (copy_to_user(arg, &audio, sizeof(audio)))
3082 sn9c102_vidioc_s_audio(struct sn9c102_device* cam, void __user * arg)
3084 struct v4l2_audio audio;
3086 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3089 if (copy_from_user(&audio, arg, sizeof(audio)))
3092 if (audio.index != 0)
3099 static long sn9c102_ioctl_v4l2(struct file *filp,
3100 unsigned int cmd, void __user *arg)
3102 struct sn9c102_device *cam = video_drvdata(filp);
3106 case VIDIOC_QUERYCAP:
3107 return sn9c102_vidioc_querycap(cam, arg);
3109 case VIDIOC_ENUMINPUT:
3110 return sn9c102_vidioc_enuminput(cam, arg);
3112 case VIDIOC_G_INPUT:
3113 return sn9c102_vidioc_g_input(cam, arg);
3115 case VIDIOC_S_INPUT:
3116 return sn9c102_vidioc_s_input(cam, arg);
3118 case VIDIOC_QUERYCTRL:
3119 return sn9c102_vidioc_query_ctrl(cam, arg);
3122 return sn9c102_vidioc_g_ctrl(cam, arg);
3125 return sn9c102_vidioc_s_ctrl(cam, arg);
3127 case VIDIOC_CROPCAP:
3128 return sn9c102_vidioc_cropcap(cam, arg);
3131 return sn9c102_vidioc_g_crop(cam, arg);
3134 return sn9c102_vidioc_s_crop(cam, arg);
3136 case VIDIOC_ENUM_FRAMESIZES:
3137 return sn9c102_vidioc_enum_framesizes(cam, arg);
3139 case VIDIOC_ENUM_FMT:
3140 return sn9c102_vidioc_enum_fmt(cam, arg);
3143 return sn9c102_vidioc_g_fmt(cam, arg);
3145 case VIDIOC_TRY_FMT:
3147 return sn9c102_vidioc_try_s_fmt(cam, cmd, arg);
3149 case VIDIOC_G_JPEGCOMP:
3150 return sn9c102_vidioc_g_jpegcomp(cam, arg);
3152 case VIDIOC_S_JPEGCOMP:
3153 return sn9c102_vidioc_s_jpegcomp(cam, arg);
3155 case VIDIOC_REQBUFS:
3156 return sn9c102_vidioc_reqbufs(cam, arg);
3158 case VIDIOC_QUERYBUF:
3159 return sn9c102_vidioc_querybuf(cam, arg);
3162 return sn9c102_vidioc_qbuf(cam, arg);
3165 return sn9c102_vidioc_dqbuf(cam, filp, arg);
3167 case VIDIOC_STREAMON:
3168 return sn9c102_vidioc_streamon(cam, arg);
3170 case VIDIOC_STREAMOFF:
3171 return sn9c102_vidioc_streamoff(cam, arg);
3174 return sn9c102_vidioc_g_parm(cam, arg);
3177 return sn9c102_vidioc_s_parm(cam, arg);
3179 case VIDIOC_ENUMAUDIO:
3180 return sn9c102_vidioc_enumaudio(cam, arg);
3182 case VIDIOC_G_AUDIO:
3183 return sn9c102_vidioc_g_audio(cam, arg);
3185 case VIDIOC_S_AUDIO:
3186 return sn9c102_vidioc_s_audio(cam, arg);
3195 static long sn9c102_ioctl(struct file *filp,
3196 unsigned int cmd, unsigned long arg)
3198 struct sn9c102_device *cam = video_drvdata(filp);
3201 if (mutex_lock_interruptible(&cam->fileop_mutex))
3202 return -ERESTARTSYS;
3204 if (cam->state & DEV_DISCONNECTED) {
3205 DBG(1, "Device not present");
3206 mutex_unlock(&cam->fileop_mutex);
3210 if (cam->state & DEV_MISCONFIGURED) {
3211 DBG(1, "The camera is misconfigured. Close and open it "
3213 mutex_unlock(&cam->fileop_mutex);
3217 V4LDBG(3, "sn9c102", cmd);
3219 err = sn9c102_ioctl_v4l2(filp, cmd, (void __user *)arg);
3221 mutex_unlock(&cam->fileop_mutex);
3226 /*****************************************************************************/
3228 static const struct v4l2_file_operations sn9c102_fops = {
3229 .owner = THIS_MODULE,
3230 .open = sn9c102_open,
3231 .release = sn9c102_release,
3232 .unlocked_ioctl = sn9c102_ioctl,
3233 .read = sn9c102_read,
3234 .poll = sn9c102_poll,
3235 .mmap = sn9c102_mmap,
3238 /*****************************************************************************/
3240 /* It exists a single interface only. We do not need to validate anything. */
3242 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
3244 struct usb_device *udev = interface_to_usbdev(intf);
3245 struct sn9c102_device* cam;
3246 static unsigned int dev_nr;
3250 if (!(cam = kzalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
3255 if (!(cam->control_buffer = kzalloc(8, GFP_KERNEL))) {
3256 DBG(1, "kzalloc() failed");
3261 if (!(cam->v4ldev = video_device_alloc())) {
3262 DBG(1, "video_device_alloc() failed");
3267 r = sn9c102_read_reg(cam, 0x00);
3268 if (r < 0 || (r != 0x10 && r != 0x11 && r != 0x12)) {
3269 DBG(1, "Sorry, this is not a SN9C1xx-based camera "
3270 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3275 cam->bridge = id->driver_info;
3276 switch (cam->bridge) {
3277 case BRIDGE_SN9C101:
3278 case BRIDGE_SN9C102:
3279 DBG(2, "SN9C10[12] PC Camera Controller detected "
3280 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3282 case BRIDGE_SN9C103:
3283 DBG(2, "SN9C103 PC Camera Controller detected "
3284 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3286 case BRIDGE_SN9C105:
3287 DBG(2, "SN9C105 PC Camera Controller detected "
3288 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3290 case BRIDGE_SN9C120:
3291 DBG(2, "SN9C120 PC Camera Controller detected "
3292 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3296 for (i = 0; i < ARRAY_SIZE(sn9c102_sensor_table); i++) {
3297 err = sn9c102_sensor_table[i](cam);
3303 DBG(2, "%s image sensor detected", cam->sensor.name);
3304 DBG(3, "Support for %s maintained by %s",
3305 cam->sensor.name, cam->sensor.maintainer);
3307 DBG(1, "No supported image sensor detected for this bridge");
3312 if (!(cam->bridge & cam->sensor.supported_bridge)) {
3313 DBG(1, "Bridge not supported");
3318 if (sn9c102_init(cam)) {
3319 DBG(1, "Initialization failed. I will retry on open().");
3320 cam->state |= DEV_MISCONFIGURED;
3323 strcpy(cam->v4ldev->name, "SN9C1xx PC Camera");
3324 cam->v4ldev->fops = &sn9c102_fops;
3325 cam->v4ldev->release = video_device_release;
3326 cam->v4ldev->parent = &udev->dev;
3328 init_completion(&cam->probe);
3330 err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3333 DBG(1, "V4L2 device registration failed");
3334 if (err == -ENFILE && video_nr[dev_nr] == -1)
3335 DBG(1, "Free /dev/videoX node not found");
3336 video_nr[dev_nr] = -1;
3337 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3338 complete_all(&cam->probe);
3342 DBG(2, "V4L2 device registered as %s",
3343 video_device_node_name(cam->v4ldev));
3345 video_set_drvdata(cam->v4ldev, cam);
3346 cam->module_param.force_munmap = force_munmap[dev_nr];
3347 cam->module_param.frame_timeout = frame_timeout[dev_nr];
3349 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3351 #ifdef CONFIG_VIDEO_ADV_DEBUG
3352 err = sn9c102_create_sysfs(cam);
3354 DBG(2, "Optional device control through 'sysfs' "
3357 DBG(2, "Failed to create optional 'sysfs' interface for "
3358 "device controlling. Error #%d", err);
3360 DBG(2, "Optional device control through 'sysfs' interface disabled");
3361 DBG(3, "Compile the kernel with the 'CONFIG_VIDEO_ADV_DEBUG' "
3362 "configuration option to enable it.");
3365 usb_set_intfdata(intf, cam);
3366 kref_init(&cam->kref);
3367 usb_get_dev(cam->usbdev);
3369 complete_all(&cam->probe);
3375 kfree(cam->control_buffer);
3377 video_device_release(cam->v4ldev);
3384 static void sn9c102_usb_disconnect(struct usb_interface* intf)
3386 struct sn9c102_device* cam;
3388 down_write(&sn9c102_dev_lock);
3390 cam = usb_get_intfdata(intf);
3392 DBG(2, "Disconnecting %s...", cam->v4ldev->name);
3395 DBG(2, "Device %s is open! Deregistration and memory "
3396 "deallocation are deferred.",
3397 video_device_node_name(cam->v4ldev));
3398 cam->state |= DEV_MISCONFIGURED;
3399 sn9c102_stop_transfer(cam);
3400 cam->state |= DEV_DISCONNECTED;
3401 wake_up_interruptible(&cam->wait_frame);
3402 wake_up(&cam->wait_stream);
3404 cam->state |= DEV_DISCONNECTED;
3406 wake_up_interruptible_all(&cam->wait_open);
3408 kref_put(&cam->kref, sn9c102_release_resources);
3410 up_write(&sn9c102_dev_lock);
3414 static struct usb_driver sn9c102_usb_driver = {
3416 .id_table = sn9c102_id_table,
3417 .probe = sn9c102_usb_probe,
3418 .disconnect = sn9c102_usb_disconnect,
3421 module_usb_driver(sn9c102_usb_driver);