Linux 3.11-rc3
[cris-mirror.git] / drivers / media / usb / sn9c102 / sn9c102_core.c
blob2cb44de2b92cb18513a7d18ec41d8838828c2def
1 /***************************************************************************
2 * V4L2 driver for SN9C1xx PC Camera Controllers *
3 * *
4 * Copyright (C) 2004-2007 by Luca Risolia <luca.risolia@studio.unibo.it> *
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 ***************************************************************************/
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>
42 #include "sn9c102.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,
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");
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");
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");
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
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 /*****************************************************************************/
141 static u32
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;
150 void* buff = NULL;
151 u32 i;
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))))
163 break;
164 cam->nbuffers--;
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 = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
179 return cam->nbuffers;
183 static void sn9c102_release_buffers(struct sn9c102_device* cam)
185 if (cam->nbuffers) {
186 vfree(cam->frame[0].bufmem);
187 cam->nbuffers = 0;
189 cam->frame_current = NULL;
193 static void sn9c102_empty_framequeues(struct sn9c102_device* cam)
195 u32 i;
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) {
212 i->state = F_QUEUED;
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;
223 u32 i;
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],
241 int count)
243 struct usb_device* udev = cam->usbdev;
244 u8* buff = cam->control_buffer;
245 int i, res;
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);
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;
269 cam->reg[index] = *buff;
272 return 0;
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;
280 int res;
282 if (index >= ARRAY_SIZE(cam->reg))
283 return -1;
285 *buff = value;
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;
295 cam->reg[index] = value;
297 return 0;
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;
306 int res;
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);
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))
321 return -1;
323 return cam->reg[index];
327 static int
328 sn9c102_i2c_wait(struct sn9c102_device* cam,
329 const struct sn9c102_sensor* sensor)
331 int i, r;
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);
344 return -EBUSY;
348 static int
349 sn9c102_i2c_detect_read_error(struct sn9c102_device* cam,
350 const struct sn9c102_sensor* sensor)
352 int r , err = 0;
354 r = sn9c102_read_reg(cam, 0x08);
355 if (r < 0)
356 err += r;
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;
366 return err ? -EIO : 0;
370 static int
371 sn9c102_i2c_detect_write_error(struct sn9c102_device* cam,
372 const struct sn9c102_sensor* sensor)
374 int r;
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;
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;
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) |
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;
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);
418 if (res < 0)
419 err += res;
421 err += sn9c102_i2c_detect_read_error(cam, sensor);
423 PDBGG("I2C read: address 0x%02X, first read byte: 0x%02X", data1,
424 data[4]);
426 if (err) {
427 DBG(3, "I2C read failed for %s image sensor", sensor->name);
428 return -1;
431 if (buffer)
432 for (i = 0; i < n && i < 5; i++)
433 buffer[n-i-1] = data[4-i];
435 return (int)data[4];
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;
446 int err = 0, res;
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;
464 err += sn9c102_i2c_wait(cam, sensor);
465 err += sn9c102_i2c_detect_write_error(cam, sensor);
467 if (err)
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);
474 return err ? -1 : 0;
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,
483 address, 1, NULL);
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,
493 value, 0, 0, 0);
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) {
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;
523 return 0;
527 static void*
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};
531 const char *m = mem;
532 size_t soflen = 0, i, j;
534 soflen = sn9c102_sof_length(cam);
536 for (i = 0; i < len; i++) {
537 size_t b;
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;
546 continue;
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;
561 } else {
562 cam->sof.bytesread = 0;
563 break;
568 return NULL;
572 static void*
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},
581 size_t i, j;
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;
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.
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;
598 return NULL;
602 static void
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
666 u8 *pos = f->bufmem;
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);
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;
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;
693 u8 i;
694 int err = 0;
696 if (urb->status == -ENOENT)
697 return;
699 f = &cam->frame_current;
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);
710 if (cam->state & DEV_DISCONNECTED)
711 return;
713 if (cam->state & DEV_MISCONFIGURED) {
714 wake_up_interruptible(&cam->wait_frame);
715 return;
718 if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
719 goto resubmit_urb;
721 if (!(*f))
722 (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
723 frame);
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;
740 if (status) {
741 DBG(3, "Error in isochronous frame");
742 (*f)->state = F_ERROR;
743 cam->sof.bytesread = 0;
744 continue;
747 PDBGG("Isochrnous frame: length %u, #%u i", len, i);
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;
757 if (eof)
758 img = (eof > pos) ? eof - pos - 1 : 0;
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));
772 memcpy((*f)->bufmem + (*f)->buf.bytesused, pos,
773 img);
775 if ((*f)->buf.bytesused == 0)
776 v4l2_get_timestamp(
777 &(*f)->buf.timestamp);
779 (*f)->buf.bytesused += img;
781 if ((*f)->buf.bytesused == imagesize ||
782 ((cam->sensor.pix_format.pixelformat ==
783 V4L2_PIX_FMT_SN9C10X ||
784 cam->sensor.pix_format.pixelformat ==
785 V4L2_PIX_FMT_JPEG) && eof)) {
786 u32 b;
788 b = (*f)->buf.bytesused;
789 (*f)->state = F_DONE;
790 (*f)->buf.sequence= ++cam->frame_count;
792 spin_lock(&cam->queue_lock);
793 list_move_tail(&(*f)->frame,
794 &cam->outqueue);
795 if (!list_empty(&cam->inqueue))
796 (*f) = list_entry(
797 cam->inqueue.next,
798 struct sn9c102_frame_t,
799 frame );
800 else
801 (*f) = NULL;
802 spin_unlock(&cam->queue_lock);
804 memcpy(cam->sysfs.frame_header,
805 cam->sof.header, soflen);
807 DBG(3, "Video frame captured: %lu "
808 "bytes", (unsigned long)(b));
810 if (!(*f))
811 goto resubmit_urb;
813 } else if (eof) {
814 (*f)->state = F_ERROR;
815 DBG(3, "Not expected EOF after %lu "
816 "bytes of image data",
817 (unsigned long)
818 ((*f)->buf.bytesused));
821 if (sof) /* (1) */
822 goto start_of_frame;
824 } else if (eof) {
825 DBG(3, "EOF without SOF");
826 continue;
828 } else {
829 PDBGG("Ignoring pointless isochronous frame");
830 continue;
833 } else if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR) {
834 start_of_frame:
835 (*f)->state = F_GRABBING;
836 (*f)->buf.bytesused = 0;
837 len -= (sof - pos);
838 pos = sof;
839 if (cam->sensor.pix_format.pixelformat ==
840 V4L2_PIX_FMT_JPEG)
841 sn9c102_write_jpegheader(cam, (*f));
842 DBG(3, "SOF detected: new video frame");
843 if (len)
844 goto redo;
846 } else if ((*f)->state == F_GRABBING) {
847 eof = sn9c102_find_eof_header(cam, pos, len);
848 if (eof && eof < sof)
849 goto end_of_frame; /* (1) */
850 else {
851 if (cam->sensor.pix_format.pixelformat ==
852 V4L2_PIX_FMT_SN9C10X ||
853 cam->sensor.pix_format.pixelformat ==
854 V4L2_PIX_FMT_JPEG) {
855 if (sof - pos >= soflen) {
856 eof = sof - soflen;
857 } else { /* remove header */
858 eof = pos;
859 (*f)->buf.bytesused -=
860 (soflen - (sof - pos));
862 goto end_of_frame;
863 } else {
864 DBG(3, "SOF before expected EOF after "
865 "%lu bytes of image data",
866 (unsigned long)
867 ((*f)->buf.bytesused));
868 goto start_of_frame;
874 resubmit_urb:
875 urb->dev = cam->usbdev;
876 err = usb_submit_urb(urb, GFP_ATOMIC);
877 if (err < 0 && err != -EPERM) {
878 cam->state |= DEV_MISCONFIGURED;
879 DBG(1, "usb_submit_urb() failed");
882 wake_up_interruptible(&cam->wait_frame);
886 static int sn9c102_start_transfer(struct sn9c102_device* cam)
888 struct usb_device *udev = cam->usbdev;
889 struct urb* urb;
890 struct usb_host_interface* altsetting = usb_altnum_to_altsetting(
891 usb_ifnum_to_if(udev, 0),
892 SN9C102_ALTERNATE_SETTING);
893 const unsigned int psz = le16_to_cpu(altsetting->
894 endpoint[0].desc.wMaxPacketSize);
895 s8 i, j;
896 int err = 0;
898 for (i = 0; i < SN9C102_URBS; i++) {
899 cam->transfer_buffer[i] = kzalloc(SN9C102_ISO_PACKETS * psz,
900 GFP_KERNEL);
901 if (!cam->transfer_buffer[i]) {
902 err = -ENOMEM;
903 DBG(1, "Not enough memory");
904 goto free_buffers;
908 for (i = 0; i < SN9C102_URBS; i++) {
909 urb = usb_alloc_urb(SN9C102_ISO_PACKETS, GFP_KERNEL);
910 cam->urb[i] = urb;
911 if (!urb) {
912 err = -ENOMEM;
913 DBG(1, "usb_alloc_urb() failed");
914 goto free_urbs;
916 urb->dev = udev;
917 urb->context = cam;
918 urb->pipe = usb_rcvisocpipe(udev, 1);
919 urb->transfer_flags = URB_ISO_ASAP;
920 urb->number_of_packets = SN9C102_ISO_PACKETS;
921 urb->complete = sn9c102_urb_complete;
922 urb->transfer_buffer = cam->transfer_buffer[i];
923 urb->transfer_buffer_length = psz * SN9C102_ISO_PACKETS;
924 urb->interval = 1;
925 for (j = 0; j < SN9C102_ISO_PACKETS; j++) {
926 urb->iso_frame_desc[j].offset = psz * j;
927 urb->iso_frame_desc[j].length = psz;
931 /* Enable video */
932 if (!(cam->reg[0x01] & 0x04)) {
933 err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
934 if (err) {
935 err = -EIO;
936 DBG(1, "I/O hardware error");
937 goto free_urbs;
941 err = usb_set_interface(udev, 0, SN9C102_ALTERNATE_SETTING);
942 if (err) {
943 DBG(1, "usb_set_interface() failed");
944 goto free_urbs;
947 cam->frame_current = NULL;
948 cam->sof.bytesread = 0;
950 for (i = 0; i < SN9C102_URBS; i++) {
951 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
952 if (err) {
953 for (j = i-1; j >= 0; j--)
954 usb_kill_urb(cam->urb[j]);
955 DBG(1, "usb_submit_urb() failed, error %d", err);
956 goto free_urbs;
960 return 0;
962 free_urbs:
963 for (i = 0; (i < SN9C102_URBS) && cam->urb[i]; i++)
964 usb_free_urb(cam->urb[i]);
966 free_buffers:
967 for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
968 kfree(cam->transfer_buffer[i]);
970 return err;
974 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
976 struct usb_device *udev = cam->usbdev;
977 s8 i;
978 int err = 0;
980 if (cam->state & DEV_DISCONNECTED)
981 return 0;
983 for (i = SN9C102_URBS-1; i >= 0; i--) {
984 usb_kill_urb(cam->urb[i]);
985 usb_free_urb(cam->urb[i]);
986 kfree(cam->transfer_buffer[i]);
989 err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
990 if (err)
991 DBG(3, "usb_set_interface() failed");
993 return err;
997 static int sn9c102_stream_interrupt(struct sn9c102_device* cam)
999 cam->stream = STREAM_INTERRUPT;
1000 wait_event_timeout(cam->wait_stream,
1001 (cam->stream == STREAM_OFF) ||
1002 (cam->state & DEV_DISCONNECTED),
1003 SN9C102_URB_TIMEOUT);
1004 if (cam->state & DEV_DISCONNECTED)
1005 return -ENODEV;
1006 else if (cam->stream != STREAM_OFF) {
1007 cam->state |= DEV_MISCONFIGURED;
1008 DBG(1, "URB timeout reached. The camera is misconfigured. "
1009 "To use it, close and open %s again.",
1010 video_device_node_name(cam->v4ldev));
1011 return -EIO;
1014 return 0;
1017 /*****************************************************************************/
1019 #ifdef CONFIG_VIDEO_ADV_DEBUG
1020 static u16 sn9c102_strtou16(const char* buff, size_t len, ssize_t* count)
1022 char str[7];
1023 char* endp;
1024 unsigned long val;
1026 if (len < 6) {
1027 strncpy(str, buff, len);
1028 str[len] = '\0';
1029 } else {
1030 strncpy(str, buff, 6);
1031 str[6] = '\0';
1034 val = simple_strtoul(str, &endp, 0);
1036 *count = 0;
1037 if (val <= 0xffff)
1038 *count = (ssize_t)(endp - str);
1039 if ((*count) && (len == *count+1) && (buff[*count] == '\n'))
1040 *count += 1;
1042 return (u16)val;
1046 NOTE 1: being inside one of the following methods implies that the v4l
1047 device exists for sure (see kobjects and reference counters)
1048 NOTE 2: buffers are PAGE_SIZE long
1051 static ssize_t sn9c102_show_reg(struct device* cd,
1052 struct device_attribute *attr, char* buf)
1054 struct sn9c102_device* cam;
1055 ssize_t count;
1057 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1058 return -ERESTARTSYS;
1060 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1061 if (!cam) {
1062 mutex_unlock(&sn9c102_sysfs_lock);
1063 return -ENODEV;
1066 count = sprintf(buf, "%u\n", cam->sysfs.reg);
1068 mutex_unlock(&sn9c102_sysfs_lock);
1070 return count;
1074 static ssize_t
1075 sn9c102_store_reg(struct device* cd, struct device_attribute *attr,
1076 const char* buf, size_t len)
1078 struct sn9c102_device* cam;
1079 u16 index;
1080 ssize_t count;
1082 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1083 return -ERESTARTSYS;
1085 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1086 if (!cam) {
1087 mutex_unlock(&sn9c102_sysfs_lock);
1088 return -ENODEV;
1091 index = sn9c102_strtou16(buf, len, &count);
1092 if (index >= ARRAY_SIZE(cam->reg) || !count) {
1093 mutex_unlock(&sn9c102_sysfs_lock);
1094 return -EINVAL;
1097 cam->sysfs.reg = index;
1099 DBG(2, "Moved SN9C1XX register index to 0x%02X", cam->sysfs.reg);
1100 DBG(3, "Written bytes: %zd", count);
1102 mutex_unlock(&sn9c102_sysfs_lock);
1104 return count;
1108 static ssize_t sn9c102_show_val(struct device* cd,
1109 struct device_attribute *attr, char* buf)
1111 struct sn9c102_device* cam;
1112 ssize_t count;
1113 int val;
1115 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1116 return -ERESTARTSYS;
1118 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1119 if (!cam) {
1120 mutex_unlock(&sn9c102_sysfs_lock);
1121 return -ENODEV;
1124 if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
1125 mutex_unlock(&sn9c102_sysfs_lock);
1126 return -EIO;
1129 count = sprintf(buf, "%d\n", val);
1131 DBG(3, "Read bytes: %zd, value: %d", count, val);
1133 mutex_unlock(&sn9c102_sysfs_lock);
1135 return count;
1139 static ssize_t
1140 sn9c102_store_val(struct device* cd, struct device_attribute *attr,
1141 const char* buf, size_t len)
1143 struct sn9c102_device* cam;
1144 u16 value;
1145 ssize_t count;
1146 int err;
1148 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1149 return -ERESTARTSYS;
1151 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1152 if (!cam) {
1153 mutex_unlock(&sn9c102_sysfs_lock);
1154 return -ENODEV;
1157 value = sn9c102_strtou16(buf, len, &count);
1158 if (!count) {
1159 mutex_unlock(&sn9c102_sysfs_lock);
1160 return -EINVAL;
1163 err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
1164 if (err) {
1165 mutex_unlock(&sn9c102_sysfs_lock);
1166 return -EIO;
1169 DBG(2, "Written SN9C1XX reg. 0x%02X, val. 0x%02X",
1170 cam->sysfs.reg, value);
1171 DBG(3, "Written bytes: %zd", count);
1173 mutex_unlock(&sn9c102_sysfs_lock);
1175 return count;
1179 static ssize_t sn9c102_show_i2c_reg(struct device* cd,
1180 struct device_attribute *attr, char* buf)
1182 struct sn9c102_device* cam;
1183 ssize_t count;
1185 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1186 return -ERESTARTSYS;
1188 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1189 if (!cam) {
1190 mutex_unlock(&sn9c102_sysfs_lock);
1191 return -ENODEV;
1194 count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
1196 DBG(3, "Read bytes: %zd", count);
1198 mutex_unlock(&sn9c102_sysfs_lock);
1200 return count;
1204 static ssize_t
1205 sn9c102_store_i2c_reg(struct device* cd, struct device_attribute *attr,
1206 const char* buf, size_t len)
1208 struct sn9c102_device* cam;
1209 u16 index;
1210 ssize_t count;
1212 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1213 return -ERESTARTSYS;
1215 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1216 if (!cam) {
1217 mutex_unlock(&sn9c102_sysfs_lock);
1218 return -ENODEV;
1221 index = sn9c102_strtou16(buf, len, &count);
1222 if (!count) {
1223 mutex_unlock(&sn9c102_sysfs_lock);
1224 return -EINVAL;
1227 cam->sysfs.i2c_reg = index;
1229 DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg);
1230 DBG(3, "Written bytes: %zd", count);
1232 mutex_unlock(&sn9c102_sysfs_lock);
1234 return count;
1238 static ssize_t sn9c102_show_i2c_val(struct device* cd,
1239 struct device_attribute *attr, char* buf)
1241 struct sn9c102_device* cam;
1242 ssize_t count;
1243 int val;
1245 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1246 return -ERESTARTSYS;
1248 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1249 if (!cam) {
1250 mutex_unlock(&sn9c102_sysfs_lock);
1251 return -ENODEV;
1254 if (!(cam->sensor.sysfs_ops & SN9C102_I2C_READ)) {
1255 mutex_unlock(&sn9c102_sysfs_lock);
1256 return -ENOSYS;
1259 if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1260 mutex_unlock(&sn9c102_sysfs_lock);
1261 return -EIO;
1264 count = sprintf(buf, "%d\n", val);
1266 DBG(3, "Read bytes: %zd, value: %d", count, val);
1268 mutex_unlock(&sn9c102_sysfs_lock);
1270 return count;
1274 static ssize_t
1275 sn9c102_store_i2c_val(struct device* cd, struct device_attribute *attr,
1276 const char* buf, size_t len)
1278 struct sn9c102_device* cam;
1279 u16 value;
1280 ssize_t count;
1281 int err;
1283 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1284 return -ERESTARTSYS;
1286 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1287 if (!cam) {
1288 mutex_unlock(&sn9c102_sysfs_lock);
1289 return -ENODEV;
1292 if (!(cam->sensor.sysfs_ops & SN9C102_I2C_WRITE)) {
1293 mutex_unlock(&sn9c102_sysfs_lock);
1294 return -ENOSYS;
1297 value = sn9c102_strtou16(buf, len, &count);
1298 if (!count) {
1299 mutex_unlock(&sn9c102_sysfs_lock);
1300 return -EINVAL;
1303 err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1304 if (err) {
1305 mutex_unlock(&sn9c102_sysfs_lock);
1306 return -EIO;
1309 DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1310 cam->sysfs.i2c_reg, value);
1311 DBG(3, "Written bytes: %zd", count);
1313 mutex_unlock(&sn9c102_sysfs_lock);
1315 return count;
1319 static ssize_t
1320 sn9c102_store_green(struct device* cd, struct device_attribute *attr,
1321 const char* buf, size_t len)
1323 struct sn9c102_device* cam;
1324 enum sn9c102_bridge bridge;
1325 ssize_t res = 0;
1326 u16 value;
1327 ssize_t count;
1329 if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1330 return -ERESTARTSYS;
1332 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1333 if (!cam) {
1334 mutex_unlock(&sn9c102_sysfs_lock);
1335 return -ENODEV;
1338 bridge = cam->bridge;
1340 mutex_unlock(&sn9c102_sysfs_lock);
1342 value = sn9c102_strtou16(buf, len, &count);
1343 if (!count)
1344 return -EINVAL;
1346 switch (bridge) {
1347 case BRIDGE_SN9C101:
1348 case BRIDGE_SN9C102:
1349 if (value > 0x0f)
1350 return -EINVAL;
1351 if ((res = sn9c102_store_reg(cd, attr, "0x11", 4)) >= 0)
1352 res = sn9c102_store_val(cd, attr, buf, len);
1353 break;
1354 case BRIDGE_SN9C103:
1355 case BRIDGE_SN9C105:
1356 case BRIDGE_SN9C120:
1357 if (value > 0x7f)
1358 return -EINVAL;
1359 if ((res = sn9c102_store_reg(cd, attr, "0x07", 4)) >= 0)
1360 res = sn9c102_store_val(cd, attr, buf, len);
1361 break;
1364 return res;
1368 static ssize_t
1369 sn9c102_store_blue(struct device* cd, struct device_attribute *attr,
1370 const char* buf, size_t len)
1372 ssize_t res = 0;
1373 u16 value;
1374 ssize_t count;
1376 value = sn9c102_strtou16(buf, len, &count);
1377 if (!count || value > 0x7f)
1378 return -EINVAL;
1380 if ((res = sn9c102_store_reg(cd, attr, "0x06", 4)) >= 0)
1381 res = sn9c102_store_val(cd, attr, buf, len);
1383 return res;
1387 static ssize_t
1388 sn9c102_store_red(struct device* cd, struct device_attribute *attr,
1389 const char* buf, size_t len)
1391 ssize_t res = 0;
1392 u16 value;
1393 ssize_t count;
1395 value = sn9c102_strtou16(buf, len, &count);
1396 if (!count || value > 0x7f)
1397 return -EINVAL;
1399 if ((res = sn9c102_store_reg(cd, attr, "0x05", 4)) >= 0)
1400 res = sn9c102_store_val(cd, attr, buf, len);
1402 return res;
1406 static ssize_t sn9c102_show_frame_header(struct device* cd,
1407 struct device_attribute *attr,
1408 char* buf)
1410 struct sn9c102_device* cam;
1411 ssize_t count;
1413 cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1414 if (!cam)
1415 return -ENODEV;
1417 count = sizeof(cam->sysfs.frame_header);
1418 memcpy(buf, cam->sysfs.frame_header, count);
1420 DBG(3, "Frame header, read bytes: %zd", count);
1422 return count;
1426 static DEVICE_ATTR(reg, S_IRUGO | S_IWUSR, sn9c102_show_reg, sn9c102_store_reg);
1427 static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, sn9c102_show_val, sn9c102_store_val);
1428 static DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
1429 sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
1430 static DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
1431 sn9c102_show_i2c_val, sn9c102_store_i2c_val);
1432 static DEVICE_ATTR(green, S_IWUSR, NULL, sn9c102_store_green);
1433 static DEVICE_ATTR(blue, S_IWUSR, NULL, sn9c102_store_blue);
1434 static DEVICE_ATTR(red, S_IWUSR, NULL, sn9c102_store_red);
1435 static DEVICE_ATTR(frame_header, S_IRUGO, sn9c102_show_frame_header, NULL);
1438 static int sn9c102_create_sysfs(struct sn9c102_device* cam)
1440 struct device *dev = &(cam->v4ldev->dev);
1441 int err = 0;
1443 if ((err = device_create_file(dev, &dev_attr_reg)))
1444 goto err_out;
1445 if ((err = device_create_file(dev, &dev_attr_val)))
1446 goto err_reg;
1447 if ((err = device_create_file(dev, &dev_attr_frame_header)))
1448 goto err_val;
1450 if (cam->sensor.sysfs_ops) {
1451 if ((err = device_create_file(dev, &dev_attr_i2c_reg)))
1452 goto err_frame_header;
1453 if ((err = device_create_file(dev, &dev_attr_i2c_val)))
1454 goto err_i2c_reg;
1457 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
1458 if ((err = device_create_file(dev, &dev_attr_green)))
1459 goto err_i2c_val;
1460 } else {
1461 if ((err = device_create_file(dev, &dev_attr_blue)))
1462 goto err_i2c_val;
1463 if ((err = device_create_file(dev, &dev_attr_red)))
1464 goto err_blue;
1467 return 0;
1469 err_blue:
1470 device_remove_file(dev, &dev_attr_blue);
1471 err_i2c_val:
1472 if (cam->sensor.sysfs_ops)
1473 device_remove_file(dev, &dev_attr_i2c_val);
1474 err_i2c_reg:
1475 if (cam->sensor.sysfs_ops)
1476 device_remove_file(dev, &dev_attr_i2c_reg);
1477 err_frame_header:
1478 device_remove_file(dev, &dev_attr_frame_header);
1479 err_val:
1480 device_remove_file(dev, &dev_attr_val);
1481 err_reg:
1482 device_remove_file(dev, &dev_attr_reg);
1483 err_out:
1484 return err;
1486 #endif /* CONFIG_VIDEO_ADV_DEBUG */
1488 /*****************************************************************************/
1490 static int
1491 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
1493 int err = 0;
1495 if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
1496 pix->pixelformat == V4L2_PIX_FMT_JPEG) {
1497 switch (cam->bridge) {
1498 case BRIDGE_SN9C101:
1499 case BRIDGE_SN9C102:
1500 case BRIDGE_SN9C103:
1501 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1502 0x18);
1503 break;
1504 case BRIDGE_SN9C105:
1505 case BRIDGE_SN9C120:
1506 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1507 0x18);
1508 break;
1510 } else {
1511 switch (cam->bridge) {
1512 case BRIDGE_SN9C101:
1513 case BRIDGE_SN9C102:
1514 case BRIDGE_SN9C103:
1515 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1516 0x18);
1517 break;
1518 case BRIDGE_SN9C105:
1519 case BRIDGE_SN9C120:
1520 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1521 0x18);
1522 break;
1526 return err ? -EIO : 0;
1530 static int
1531 sn9c102_set_compression(struct sn9c102_device* cam,
1532 struct v4l2_jpegcompression* compression)
1534 int i, err = 0;
1536 switch (cam->bridge) {
1537 case BRIDGE_SN9C101:
1538 case BRIDGE_SN9C102:
1539 case BRIDGE_SN9C103:
1540 if (compression->quality == 0)
1541 err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01,
1542 0x17);
1543 else if (compression->quality == 1)
1544 err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe,
1545 0x17);
1546 break;
1547 case BRIDGE_SN9C105:
1548 case BRIDGE_SN9C120:
1549 if (compression->quality == 0) {
1550 for (i = 0; i <= 63; i++) {
1551 err += sn9c102_write_reg(cam,
1552 SN9C102_Y_QTABLE1[i],
1553 0x100 + i);
1554 err += sn9c102_write_reg(cam,
1555 SN9C102_UV_QTABLE1[i],
1556 0x140 + i);
1558 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0xbf,
1559 0x18);
1560 } else if (compression->quality == 1) {
1561 for (i = 0; i <= 63; i++) {
1562 err += sn9c102_write_reg(cam,
1563 SN9C102_Y_QTABLE1[i],
1564 0x100 + i);
1565 err += sn9c102_write_reg(cam,
1566 SN9C102_UV_QTABLE1[i],
1567 0x140 + i);
1569 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x40,
1570 0x18);
1572 break;
1575 return err ? -EIO : 0;
1579 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1581 u8 r = 0;
1582 int err = 0;
1584 if (scale == 1)
1585 r = cam->reg[0x18] & 0xcf;
1586 else if (scale == 2) {
1587 r = cam->reg[0x18] & 0xcf;
1588 r |= 0x10;
1589 } else if (scale == 4)
1590 r = cam->reg[0x18] | 0x20;
1592 err += sn9c102_write_reg(cam, r, 0x18);
1593 if (err)
1594 return -EIO;
1596 PDBGG("Scaling factor: %u", scale);
1598 return 0;
1602 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1604 struct sn9c102_sensor* s = &cam->sensor;
1605 u8 h_start = (u8)(rect->left - s->cropcap.bounds.left),
1606 v_start = (u8)(rect->top - s->cropcap.bounds.top),
1607 h_size = (u8)(rect->width / 16),
1608 v_size = (u8)(rect->height / 16);
1609 int err = 0;
1611 err += sn9c102_write_reg(cam, h_start, 0x12);
1612 err += sn9c102_write_reg(cam, v_start, 0x13);
1613 err += sn9c102_write_reg(cam, h_size, 0x15);
1614 err += sn9c102_write_reg(cam, v_size, 0x16);
1615 if (err)
1616 return -EIO;
1618 PDBGG("h_start, v_start, h_size, v_size, ho_size, vo_size "
1619 "%u %u %u %u", h_start, v_start, h_size, v_size);
1621 return 0;
1625 static int sn9c102_init(struct sn9c102_device* cam)
1627 struct sn9c102_sensor* s = &cam->sensor;
1628 struct v4l2_control ctrl;
1629 struct v4l2_queryctrl *qctrl;
1630 struct v4l2_rect* rect;
1631 u8 i = 0;
1632 int err = 0;
1634 if (!(cam->state & DEV_INITIALIZED)) {
1635 mutex_init(&cam->open_mutex);
1636 init_waitqueue_head(&cam->wait_open);
1637 qctrl = s->qctrl;
1638 rect = &(s->cropcap.defrect);
1639 } else { /* use current values */
1640 qctrl = s->_qctrl;
1641 rect = &(s->_rect);
1644 err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1645 err += sn9c102_set_crop(cam, rect);
1646 if (err)
1647 return err;
1649 if (s->init) {
1650 err = s->init(cam);
1651 if (err) {
1652 DBG(3, "Sensor initialization failed");
1653 return err;
1657 if (!(cam->state & DEV_INITIALIZED))
1658 if (cam->bridge == BRIDGE_SN9C101 ||
1659 cam->bridge == BRIDGE_SN9C102 ||
1660 cam->bridge == BRIDGE_SN9C103) {
1661 if (s->pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
1662 s->pix_format.pixelformat= V4L2_PIX_FMT_SBGGR8;
1663 cam->compression.quality = cam->reg[0x17] & 0x01 ?
1664 0 : 1;
1665 } else {
1666 if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
1667 s->pix_format.pixelformat = V4L2_PIX_FMT_JPEG;
1668 cam->compression.quality = cam->reg[0x18] & 0x40 ?
1669 0 : 1;
1670 err += sn9c102_set_compression(cam, &cam->compression);
1672 else
1673 err += sn9c102_set_compression(cam, &cam->compression);
1674 err += sn9c102_set_pix_format(cam, &s->pix_format);
1675 if (s->set_pix_format)
1676 err += s->set_pix_format(cam, &s->pix_format);
1677 if (err)
1678 return err;
1680 if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X ||
1681 s->pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
1682 DBG(3, "Compressed video format is active, quality %d",
1683 cam->compression.quality);
1684 else
1685 DBG(3, "Uncompressed video format is active");
1687 if (s->set_crop)
1688 if ((err = s->set_crop(cam, rect))) {
1689 DBG(3, "set_crop() failed");
1690 return err;
1693 if (s->set_ctrl) {
1694 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
1695 if (s->qctrl[i].id != 0 &&
1696 !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
1697 ctrl.id = s->qctrl[i].id;
1698 ctrl.value = qctrl[i].default_value;
1699 err = s->set_ctrl(cam, &ctrl);
1700 if (err) {
1701 DBG(3, "Set %s control failed",
1702 s->qctrl[i].name);
1703 return err;
1705 DBG(3, "Image sensor supports '%s' control",
1706 s->qctrl[i].name);
1710 if (!(cam->state & DEV_INITIALIZED)) {
1711 mutex_init(&cam->fileop_mutex);
1712 spin_lock_init(&cam->queue_lock);
1713 init_waitqueue_head(&cam->wait_frame);
1714 init_waitqueue_head(&cam->wait_stream);
1715 cam->nreadbuffers = 2;
1716 memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
1717 memcpy(&(s->_rect), &(s->cropcap.defrect),
1718 sizeof(struct v4l2_rect));
1719 cam->state |= DEV_INITIALIZED;
1722 DBG(2, "Initialization succeeded");
1723 return 0;
1726 /*****************************************************************************/
1728 static void sn9c102_release_resources(struct kref *kref)
1730 struct sn9c102_device *cam;
1732 mutex_lock(&sn9c102_sysfs_lock);
1734 cam = container_of(kref, struct sn9c102_device, kref);
1736 DBG(2, "V4L2 device %s deregistered",
1737 video_device_node_name(cam->v4ldev));
1738 video_set_drvdata(cam->v4ldev, NULL);
1739 video_unregister_device(cam->v4ldev);
1740 v4l2_device_unregister(&cam->v4l2_dev);
1741 usb_put_dev(cam->usbdev);
1742 kfree(cam->control_buffer);
1743 kfree(cam);
1745 mutex_unlock(&sn9c102_sysfs_lock);
1750 static int sn9c102_open(struct file *filp)
1752 struct sn9c102_device* cam;
1753 int err = 0;
1756 A read_trylock() in open() is the only safe way to prevent race
1757 conditions with disconnect(), one close() and multiple (not
1758 necessarily simultaneous) attempts to open(). For example, it
1759 prevents from waiting for a second access, while the device
1760 structure is being deallocated, after a possible disconnect() and
1761 during a following close() holding the write lock: given that, after
1762 this deallocation, no access will be possible anymore, using the
1763 non-trylock version would have let open() gain the access to the
1764 device structure improperly.
1765 For this reason the lock must also not be per-device.
1767 if (!down_read_trylock(&sn9c102_dev_lock))
1768 return -ERESTARTSYS;
1770 cam = video_drvdata(filp);
1772 if (wait_for_completion_interruptible(&cam->probe)) {
1773 up_read(&sn9c102_dev_lock);
1774 return -ERESTARTSYS;
1777 kref_get(&cam->kref);
1780 Make sure to isolate all the simultaneous opens.
1782 if (mutex_lock_interruptible(&cam->open_mutex)) {
1783 kref_put(&cam->kref, sn9c102_release_resources);
1784 up_read(&sn9c102_dev_lock);
1785 return -ERESTARTSYS;
1788 if (cam->state & DEV_DISCONNECTED) {
1789 DBG(1, "Device not present");
1790 err = -ENODEV;
1791 goto out;
1794 if (cam->users) {
1795 DBG(2, "Device %s is already in use",
1796 video_device_node_name(cam->v4ldev));
1797 DBG(3, "Simultaneous opens are not supported");
1799 open() must follow the open flags and should block
1800 eventually while the device is in use.
1802 if ((filp->f_flags & O_NONBLOCK) ||
1803 (filp->f_flags & O_NDELAY)) {
1804 err = -EWOULDBLOCK;
1805 goto out;
1807 DBG(2, "A blocking open() has been requested. Wait for the "
1808 "device to be released...");
1809 up_read(&sn9c102_dev_lock);
1811 We will not release the "open_mutex" lock, so that only one
1812 process can be in the wait queue below. This way the process
1813 will be sleeping while holding the lock, without losing its
1814 priority after any wake_up().
1816 err = wait_event_interruptible_exclusive(cam->wait_open,
1817 (cam->state & DEV_DISCONNECTED)
1818 || !cam->users);
1819 down_read(&sn9c102_dev_lock);
1820 if (err)
1821 goto out;
1822 if (cam->state & DEV_DISCONNECTED) {
1823 err = -ENODEV;
1824 goto out;
1828 if (cam->state & DEV_MISCONFIGURED) {
1829 err = sn9c102_init(cam);
1830 if (err) {
1831 DBG(1, "Initialization failed again. "
1832 "I will retry on next open().");
1833 goto out;
1835 cam->state &= ~DEV_MISCONFIGURED;
1838 if ((err = sn9c102_start_transfer(cam)))
1839 goto out;
1841 filp->private_data = cam;
1842 cam->users++;
1843 cam->io = IO_NONE;
1844 cam->stream = STREAM_OFF;
1845 cam->nbuffers = 0;
1846 cam->frame_count = 0;
1847 sn9c102_empty_framequeues(cam);
1849 DBG(3, "Video device %s is open", video_device_node_name(cam->v4ldev));
1851 out:
1852 mutex_unlock(&cam->open_mutex);
1853 if (err)
1854 kref_put(&cam->kref, sn9c102_release_resources);
1856 up_read(&sn9c102_dev_lock);
1857 return err;
1861 static int sn9c102_release(struct file *filp)
1863 struct sn9c102_device* cam;
1865 down_write(&sn9c102_dev_lock);
1867 cam = video_drvdata(filp);
1869 sn9c102_stop_transfer(cam);
1870 sn9c102_release_buffers(cam);
1871 cam->users--;
1872 wake_up_interruptible_nr(&cam->wait_open, 1);
1874 DBG(3, "Video device %s closed", video_device_node_name(cam->v4ldev));
1876 kref_put(&cam->kref, sn9c102_release_resources);
1878 up_write(&sn9c102_dev_lock);
1880 return 0;
1884 static ssize_t
1885 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1887 struct sn9c102_device *cam = video_drvdata(filp);
1888 struct sn9c102_frame_t* f, * i;
1889 unsigned long lock_flags;
1890 long timeout;
1891 int err = 0;
1893 if (mutex_lock_interruptible(&cam->fileop_mutex))
1894 return -ERESTARTSYS;
1896 if (cam->state & DEV_DISCONNECTED) {
1897 DBG(1, "Device not present");
1898 mutex_unlock(&cam->fileop_mutex);
1899 return -ENODEV;
1902 if (cam->state & DEV_MISCONFIGURED) {
1903 DBG(1, "The camera is misconfigured. Close and open it "
1904 "again.");
1905 mutex_unlock(&cam->fileop_mutex);
1906 return -EIO;
1909 if (cam->io == IO_MMAP) {
1910 DBG(3, "Close and open the device again to choose "
1911 "the read method");
1912 mutex_unlock(&cam->fileop_mutex);
1913 return -EBUSY;
1916 if (cam->io == IO_NONE) {
1917 if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
1918 DBG(1, "read() failed, not enough memory");
1919 mutex_unlock(&cam->fileop_mutex);
1920 return -ENOMEM;
1922 cam->io = IO_READ;
1923 cam->stream = STREAM_ON;
1926 if (list_empty(&cam->inqueue)) {
1927 if (!list_empty(&cam->outqueue))
1928 sn9c102_empty_framequeues(cam);
1929 sn9c102_queue_unusedframes(cam);
1932 if (!count) {
1933 mutex_unlock(&cam->fileop_mutex);
1934 return 0;
1937 if (list_empty(&cam->outqueue)) {
1938 if (filp->f_flags & O_NONBLOCK) {
1939 mutex_unlock(&cam->fileop_mutex);
1940 return -EAGAIN;
1942 if (!cam->module_param.frame_timeout) {
1943 err = wait_event_interruptible
1944 ( cam->wait_frame,
1945 (!list_empty(&cam->outqueue)) ||
1946 (cam->state & DEV_DISCONNECTED) ||
1947 (cam->state & DEV_MISCONFIGURED) );
1948 if (err) {
1949 mutex_unlock(&cam->fileop_mutex);
1950 return err;
1952 } else {
1953 timeout = wait_event_interruptible_timeout
1954 ( cam->wait_frame,
1955 (!list_empty(&cam->outqueue)) ||
1956 (cam->state & DEV_DISCONNECTED) ||
1957 (cam->state & DEV_MISCONFIGURED),
1958 msecs_to_jiffies(
1959 cam->module_param.frame_timeout * 1000
1962 if (timeout < 0) {
1963 mutex_unlock(&cam->fileop_mutex);
1964 return timeout;
1965 } else if (timeout == 0 &&
1966 !(cam->state & DEV_DISCONNECTED)) {
1967 DBG(1, "Video frame timeout elapsed");
1968 mutex_unlock(&cam->fileop_mutex);
1969 return -EIO;
1972 if (cam->state & DEV_DISCONNECTED) {
1973 mutex_unlock(&cam->fileop_mutex);
1974 return -ENODEV;
1976 if (cam->state & DEV_MISCONFIGURED) {
1977 mutex_unlock(&cam->fileop_mutex);
1978 return -EIO;
1982 f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1984 if (count > f->buf.bytesused)
1985 count = f->buf.bytesused;
1987 if (copy_to_user(buf, f->bufmem, count)) {
1988 err = -EFAULT;
1989 goto exit;
1991 *f_pos += count;
1993 exit:
1994 spin_lock_irqsave(&cam->queue_lock, lock_flags);
1995 list_for_each_entry(i, &cam->outqueue, frame)
1996 i->state = F_UNUSED;
1997 INIT_LIST_HEAD(&cam->outqueue);
1998 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2000 sn9c102_queue_unusedframes(cam);
2002 PDBGG("Frame #%lu, bytes read: %zu",
2003 (unsigned long)f->buf.index, count);
2005 mutex_unlock(&cam->fileop_mutex);
2007 return count;
2011 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
2013 struct sn9c102_device *cam = video_drvdata(filp);
2014 struct sn9c102_frame_t* f;
2015 unsigned long lock_flags;
2016 unsigned int mask = 0;
2018 if (mutex_lock_interruptible(&cam->fileop_mutex))
2019 return POLLERR;
2021 if (cam->state & DEV_DISCONNECTED) {
2022 DBG(1, "Device not present");
2023 goto error;
2026 if (cam->state & DEV_MISCONFIGURED) {
2027 DBG(1, "The camera is misconfigured. Close and open it "
2028 "again.");
2029 goto error;
2032 if (cam->io == IO_NONE) {
2033 if (!sn9c102_request_buffers(cam, cam->nreadbuffers,
2034 IO_READ)) {
2035 DBG(1, "poll() failed, not enough memory");
2036 goto error;
2038 cam->io = IO_READ;
2039 cam->stream = STREAM_ON;
2042 if (cam->io == IO_READ) {
2043 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2044 list_for_each_entry(f, &cam->outqueue, frame)
2045 f->state = F_UNUSED;
2046 INIT_LIST_HEAD(&cam->outqueue);
2047 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2048 sn9c102_queue_unusedframes(cam);
2051 poll_wait(filp, &cam->wait_frame, wait);
2053 if (!list_empty(&cam->outqueue))
2054 mask |= POLLIN | POLLRDNORM;
2056 mutex_unlock(&cam->fileop_mutex);
2058 return mask;
2060 error:
2061 mutex_unlock(&cam->fileop_mutex);
2062 return POLLERR;
2066 static void sn9c102_vm_open(struct vm_area_struct* vma)
2068 struct sn9c102_frame_t* f = vma->vm_private_data;
2069 f->vma_use_count++;
2073 static void sn9c102_vm_close(struct vm_area_struct* vma)
2075 /* NOTE: buffers are not freed here */
2076 struct sn9c102_frame_t* f = vma->vm_private_data;
2077 f->vma_use_count--;
2081 static const struct vm_operations_struct sn9c102_vm_ops = {
2082 .open = sn9c102_vm_open,
2083 .close = sn9c102_vm_close,
2087 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
2089 struct sn9c102_device *cam = video_drvdata(filp);
2090 unsigned long size = vma->vm_end - vma->vm_start,
2091 start = vma->vm_start;
2092 void *pos;
2093 u32 i;
2095 if (mutex_lock_interruptible(&cam->fileop_mutex))
2096 return -ERESTARTSYS;
2098 if (cam->state & DEV_DISCONNECTED) {
2099 DBG(1, "Device not present");
2100 mutex_unlock(&cam->fileop_mutex);
2101 return -ENODEV;
2104 if (cam->state & DEV_MISCONFIGURED) {
2105 DBG(1, "The camera is misconfigured. Close and open it "
2106 "again.");
2107 mutex_unlock(&cam->fileop_mutex);
2108 return -EIO;
2111 if (!(vma->vm_flags & (VM_WRITE | VM_READ))) {
2112 mutex_unlock(&cam->fileop_mutex);
2113 return -EACCES;
2116 if (cam->io != IO_MMAP ||
2117 size != PAGE_ALIGN(cam->frame[0].buf.length)) {
2118 mutex_unlock(&cam->fileop_mutex);
2119 return -EINVAL;
2122 for (i = 0; i < cam->nbuffers; i++) {
2123 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
2124 break;
2126 if (i == cam->nbuffers) {
2127 mutex_unlock(&cam->fileop_mutex);
2128 return -EINVAL;
2131 vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
2133 pos = cam->frame[i].bufmem;
2134 while (size > 0) { /* size is page-aligned */
2135 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
2136 mutex_unlock(&cam->fileop_mutex);
2137 return -EAGAIN;
2139 start += PAGE_SIZE;
2140 pos += PAGE_SIZE;
2141 size -= PAGE_SIZE;
2144 vma->vm_ops = &sn9c102_vm_ops;
2145 vma->vm_private_data = &cam->frame[i];
2146 sn9c102_vm_open(vma);
2148 mutex_unlock(&cam->fileop_mutex);
2150 return 0;
2153 /*****************************************************************************/
2155 static int
2156 sn9c102_vidioc_querycap(struct sn9c102_device* cam, void __user * arg)
2158 struct v4l2_capability cap = {
2159 .driver = "sn9c102",
2160 .version = LINUX_VERSION_CODE,
2161 .capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2162 V4L2_CAP_STREAMING,
2165 strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
2166 if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
2167 strlcpy(cap.bus_info, dev_name(&cam->usbdev->dev),
2168 sizeof(cap.bus_info));
2170 if (copy_to_user(arg, &cap, sizeof(cap)))
2171 return -EFAULT;
2173 return 0;
2177 static int
2178 sn9c102_vidioc_enuminput(struct sn9c102_device* cam, void __user * arg)
2180 struct v4l2_input i;
2182 if (copy_from_user(&i, arg, sizeof(i)))
2183 return -EFAULT;
2185 if (i.index)
2186 return -EINVAL;
2188 memset(&i, 0, sizeof(i));
2189 strcpy(i.name, "Camera");
2190 i.type = V4L2_INPUT_TYPE_CAMERA;
2191 i.capabilities = V4L2_IN_CAP_STD;
2193 if (copy_to_user(arg, &i, sizeof(i)))
2194 return -EFAULT;
2196 return 0;
2200 static int
2201 sn9c102_vidioc_g_input(struct sn9c102_device* cam, void __user * arg)
2203 int index = 0;
2205 if (copy_to_user(arg, &index, sizeof(index)))
2206 return -EFAULT;
2208 return 0;
2212 static int
2213 sn9c102_vidioc_s_input(struct sn9c102_device* cam, void __user * arg)
2215 int index;
2217 if (copy_from_user(&index, arg, sizeof(index)))
2218 return -EFAULT;
2220 if (index != 0)
2221 return -EINVAL;
2223 return 0;
2227 static int
2228 sn9c102_vidioc_query_ctrl(struct sn9c102_device* cam, void __user * arg)
2230 struct sn9c102_sensor* s = &cam->sensor;
2231 struct v4l2_queryctrl qc;
2232 u8 i;
2234 if (copy_from_user(&qc, arg, sizeof(qc)))
2235 return -EFAULT;
2237 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2238 if (qc.id && qc.id == s->qctrl[i].id) {
2239 memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
2240 if (copy_to_user(arg, &qc, sizeof(qc)))
2241 return -EFAULT;
2242 return 0;
2245 return -EINVAL;
2249 static int
2250 sn9c102_vidioc_g_ctrl(struct sn9c102_device* cam, void __user * arg)
2252 struct sn9c102_sensor* s = &cam->sensor;
2253 struct v4l2_control ctrl;
2254 int err = 0;
2255 u8 i;
2257 if (!s->get_ctrl && !s->set_ctrl)
2258 return -EINVAL;
2260 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2261 return -EFAULT;
2263 if (!s->get_ctrl) {
2264 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2265 if (ctrl.id && ctrl.id == s->qctrl[i].id) {
2266 ctrl.value = s->_qctrl[i].default_value;
2267 goto exit;
2269 return -EINVAL;
2270 } else
2271 err = s->get_ctrl(cam, &ctrl);
2273 exit:
2274 if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
2275 return -EFAULT;
2277 PDBGG("VIDIOC_G_CTRL: id %lu, value %lu",
2278 (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2280 return err;
2284 static int
2285 sn9c102_vidioc_s_ctrl(struct sn9c102_device* cam, void __user * arg)
2287 struct sn9c102_sensor* s = &cam->sensor;
2288 struct v4l2_control ctrl;
2289 u8 i;
2290 int err = 0;
2292 if (!s->set_ctrl)
2293 return -EINVAL;
2295 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2296 return -EFAULT;
2298 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++) {
2299 if (ctrl.id == s->qctrl[i].id) {
2300 if (s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)
2301 return -EINVAL;
2302 if (ctrl.value < s->qctrl[i].minimum ||
2303 ctrl.value > s->qctrl[i].maximum)
2304 return -ERANGE;
2305 ctrl.value -= ctrl.value % s->qctrl[i].step;
2306 break;
2309 if (i == ARRAY_SIZE(s->qctrl))
2310 return -EINVAL;
2311 if ((err = s->set_ctrl(cam, &ctrl)))
2312 return err;
2314 s->_qctrl[i].default_value = ctrl.value;
2316 PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
2317 (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2319 return 0;
2323 static int
2324 sn9c102_vidioc_cropcap(struct sn9c102_device* cam, void __user * arg)
2326 struct v4l2_cropcap* cc = &(cam->sensor.cropcap);
2328 cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2329 cc->pixelaspect.numerator = 1;
2330 cc->pixelaspect.denominator = 1;
2332 if (copy_to_user(arg, cc, sizeof(*cc)))
2333 return -EFAULT;
2335 return 0;
2339 static int
2340 sn9c102_vidioc_g_crop(struct sn9c102_device* cam, void __user * arg)
2342 struct sn9c102_sensor* s = &cam->sensor;
2343 struct v4l2_crop crop = {
2344 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
2347 memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
2349 if (copy_to_user(arg, &crop, sizeof(crop)))
2350 return -EFAULT;
2352 return 0;
2356 static int
2357 sn9c102_vidioc_s_crop(struct sn9c102_device* cam, void __user * arg)
2359 struct sn9c102_sensor* s = &cam->sensor;
2360 struct v4l2_crop crop;
2361 struct v4l2_rect* rect;
2362 struct v4l2_rect* bounds = &(s->cropcap.bounds);
2363 struct v4l2_pix_format* pix_format = &(s->pix_format);
2364 u8 scale;
2365 const enum sn9c102_stream_state stream = cam->stream;
2366 const u32 nbuffers = cam->nbuffers;
2367 u32 i;
2368 int err = 0;
2370 if (copy_from_user(&crop, arg, sizeof(crop)))
2371 return -EFAULT;
2373 rect = &(crop.c);
2375 if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2376 return -EINVAL;
2378 if (cam->module_param.force_munmap)
2379 for (i = 0; i < cam->nbuffers; i++)
2380 if (cam->frame[i].vma_use_count) {
2381 DBG(3, "VIDIOC_S_CROP failed. "
2382 "Unmap the buffers first.");
2383 return -EBUSY;
2386 /* Preserve R,G or B origin */
2387 rect->left = (s->_rect.left & 1L) ? rect->left | 1L : rect->left & ~1L;
2388 rect->top = (s->_rect.top & 1L) ? rect->top | 1L : rect->top & ~1L;
2390 if (rect->width < 16)
2391 rect->width = 16;
2392 if (rect->height < 16)
2393 rect->height = 16;
2394 if (rect->width > bounds->width)
2395 rect->width = bounds->width;
2396 if (rect->height > bounds->height)
2397 rect->height = bounds->height;
2398 if (rect->left < bounds->left)
2399 rect->left = bounds->left;
2400 if (rect->top < bounds->top)
2401 rect->top = bounds->top;
2402 if (rect->left + rect->width > bounds->left + bounds->width)
2403 rect->left = bounds->left+bounds->width - rect->width;
2404 if (rect->top + rect->height > bounds->top + bounds->height)
2405 rect->top = bounds->top+bounds->height - rect->height;
2407 rect->width &= ~15L;
2408 rect->height &= ~15L;
2410 if (SN9C102_PRESERVE_IMGSCALE) {
2411 /* Calculate the actual scaling factor */
2412 u32 a, b;
2413 a = rect->width * rect->height;
2414 b = pix_format->width * pix_format->height;
2415 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2416 } else
2417 scale = 1;
2419 if (cam->stream == STREAM_ON)
2420 if ((err = sn9c102_stream_interrupt(cam)))
2421 return err;
2423 if (copy_to_user(arg, &crop, sizeof(crop))) {
2424 cam->stream = stream;
2425 return -EFAULT;
2428 if (cam->module_param.force_munmap || cam->io == IO_READ)
2429 sn9c102_release_buffers(cam);
2431 err = sn9c102_set_crop(cam, rect);
2432 if (s->set_crop)
2433 err += s->set_crop(cam, rect);
2434 err += sn9c102_set_scale(cam, scale);
2436 if (err) { /* atomic, no rollback in ioctl() */
2437 cam->state |= DEV_MISCONFIGURED;
2438 DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
2439 "use the camera, close and open %s again.",
2440 video_device_node_name(cam->v4ldev));
2441 return -EIO;
2444 s->pix_format.width = rect->width/scale;
2445 s->pix_format.height = rect->height/scale;
2446 memcpy(&(s->_rect), rect, sizeof(*rect));
2448 if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2449 nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2450 cam->state |= DEV_MISCONFIGURED;
2451 DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
2452 "use the camera, close and open %s again.",
2453 video_device_node_name(cam->v4ldev));
2454 return -ENOMEM;
2457 if (cam->io == IO_READ)
2458 sn9c102_empty_framequeues(cam);
2459 else if (cam->module_param.force_munmap)
2460 sn9c102_requeue_outqueue(cam);
2462 cam->stream = stream;
2464 return 0;
2468 static int
2469 sn9c102_vidioc_enum_framesizes(struct sn9c102_device* cam, void __user * arg)
2471 struct v4l2_frmsizeenum frmsize;
2473 if (copy_from_user(&frmsize, arg, sizeof(frmsize)))
2474 return -EFAULT;
2476 if (frmsize.index != 0)
2477 return -EINVAL;
2479 switch (cam->bridge) {
2480 case BRIDGE_SN9C101:
2481 case BRIDGE_SN9C102:
2482 case BRIDGE_SN9C103:
2483 if (frmsize.pixel_format != V4L2_PIX_FMT_SN9C10X &&
2484 frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2485 return -EINVAL;
2486 break;
2487 case BRIDGE_SN9C105:
2488 case BRIDGE_SN9C120:
2489 if (frmsize.pixel_format != V4L2_PIX_FMT_JPEG &&
2490 frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2491 return -EINVAL;
2492 break;
2495 frmsize.type = V4L2_FRMSIZE_TYPE_STEPWISE;
2496 frmsize.stepwise.min_width = frmsize.stepwise.step_width = 16;
2497 frmsize.stepwise.min_height = frmsize.stepwise.step_height = 16;
2498 frmsize.stepwise.max_width = cam->sensor.cropcap.bounds.width;
2499 frmsize.stepwise.max_height = cam->sensor.cropcap.bounds.height;
2500 memset(&frmsize.reserved, 0, sizeof(frmsize.reserved));
2502 if (copy_to_user(arg, &frmsize, sizeof(frmsize)))
2503 return -EFAULT;
2505 return 0;
2509 static int
2510 sn9c102_vidioc_enum_fmt(struct sn9c102_device* cam, void __user * arg)
2512 struct v4l2_fmtdesc fmtd;
2514 if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
2515 return -EFAULT;
2517 if (fmtd.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2518 return -EINVAL;
2520 if (fmtd.index == 0) {
2521 strcpy(fmtd.description, "bayer rgb");
2522 fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
2523 } else if (fmtd.index == 1) {
2524 switch (cam->bridge) {
2525 case BRIDGE_SN9C101:
2526 case BRIDGE_SN9C102:
2527 case BRIDGE_SN9C103:
2528 strcpy(fmtd.description, "compressed");
2529 fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
2530 break;
2531 case BRIDGE_SN9C105:
2532 case BRIDGE_SN9C120:
2533 strcpy(fmtd.description, "JPEG");
2534 fmtd.pixelformat = V4L2_PIX_FMT_JPEG;
2535 break;
2537 fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
2538 } else
2539 return -EINVAL;
2541 fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2542 memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
2544 if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
2545 return -EFAULT;
2547 return 0;
2551 static int
2552 sn9c102_vidioc_g_fmt(struct sn9c102_device* cam, void __user * arg)
2554 struct v4l2_format format;
2555 struct v4l2_pix_format* pfmt = &(cam->sensor.pix_format);
2557 if (copy_from_user(&format, arg, sizeof(format)))
2558 return -EFAULT;
2560 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2561 return -EINVAL;
2563 pfmt->colorspace = (pfmt->pixelformat == V4L2_PIX_FMT_JPEG) ?
2564 V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2565 pfmt->bytesperline = (pfmt->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2566 pfmt->pixelformat == V4L2_PIX_FMT_JPEG)
2567 ? 0 : (pfmt->width * pfmt->priv) / 8;
2568 pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
2569 pfmt->field = V4L2_FIELD_NONE;
2570 memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
2572 if (copy_to_user(arg, &format, sizeof(format)))
2573 return -EFAULT;
2575 return 0;
2579 static int
2580 sn9c102_vidioc_try_s_fmt(struct sn9c102_device* cam, unsigned int cmd,
2581 void __user * arg)
2583 struct sn9c102_sensor* s = &cam->sensor;
2584 struct v4l2_format format;
2585 struct v4l2_pix_format* pix;
2586 struct v4l2_pix_format* pfmt = &(s->pix_format);
2587 struct v4l2_rect* bounds = &(s->cropcap.bounds);
2588 struct v4l2_rect rect;
2589 u8 scale;
2590 const enum sn9c102_stream_state stream = cam->stream;
2591 const u32 nbuffers = cam->nbuffers;
2592 u32 i;
2593 int err = 0;
2595 if (copy_from_user(&format, arg, sizeof(format)))
2596 return -EFAULT;
2598 pix = &(format.fmt.pix);
2600 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2601 return -EINVAL;
2603 memcpy(&rect, &(s->_rect), sizeof(rect));
2605 { /* calculate the actual scaling factor */
2606 u32 a, b;
2607 a = rect.width * rect.height;
2608 b = pix->width * pix->height;
2609 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2612 rect.width = scale * pix->width;
2613 rect.height = scale * pix->height;
2615 if (rect.width < 16)
2616 rect.width = 16;
2617 if (rect.height < 16)
2618 rect.height = 16;
2619 if (rect.width > bounds->left + bounds->width - rect.left)
2620 rect.width = bounds->left + bounds->width - rect.left;
2621 if (rect.height > bounds->top + bounds->height - rect.top)
2622 rect.height = bounds->top + bounds->height - rect.top;
2624 rect.width &= ~15L;
2625 rect.height &= ~15L;
2627 { /* adjust the scaling factor */
2628 u32 a, b;
2629 a = rect.width * rect.height;
2630 b = pix->width * pix->height;
2631 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2634 pix->width = rect.width / scale;
2635 pix->height = rect.height / scale;
2637 switch (cam->bridge) {
2638 case BRIDGE_SN9C101:
2639 case BRIDGE_SN9C102:
2640 case BRIDGE_SN9C103:
2641 if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2642 pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2643 pix->pixelformat = pfmt->pixelformat;
2644 break;
2645 case BRIDGE_SN9C105:
2646 case BRIDGE_SN9C120:
2647 if (pix->pixelformat != V4L2_PIX_FMT_JPEG &&
2648 pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2649 pix->pixelformat = pfmt->pixelformat;
2650 break;
2652 pix->priv = pfmt->priv; /* bpp */
2653 pix->colorspace = (pix->pixelformat == V4L2_PIX_FMT_JPEG) ?
2654 V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2655 pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2656 pix->pixelformat == V4L2_PIX_FMT_JPEG)
2657 ? 0 : (pix->width * pix->priv) / 8;
2658 pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2659 pix->field = V4L2_FIELD_NONE;
2661 if (cmd == VIDIOC_TRY_FMT) {
2662 if (copy_to_user(arg, &format, sizeof(format)))
2663 return -EFAULT;
2664 return 0;
2667 if (cam->module_param.force_munmap)
2668 for (i = 0; i < cam->nbuffers; i++)
2669 if (cam->frame[i].vma_use_count) {
2670 DBG(3, "VIDIOC_S_FMT failed. Unmap the "
2671 "buffers first.");
2672 return -EBUSY;
2675 if (cam->stream == STREAM_ON)
2676 if ((err = sn9c102_stream_interrupt(cam)))
2677 return err;
2679 if (copy_to_user(arg, &format, sizeof(format))) {
2680 cam->stream = stream;
2681 return -EFAULT;
2684 if (cam->module_param.force_munmap || cam->io == IO_READ)
2685 sn9c102_release_buffers(cam);
2687 err += sn9c102_set_pix_format(cam, pix);
2688 err += sn9c102_set_crop(cam, &rect);
2689 if (s->set_pix_format)
2690 err += s->set_pix_format(cam, pix);
2691 if (s->set_crop)
2692 err += s->set_crop(cam, &rect);
2693 err += sn9c102_set_scale(cam, scale);
2695 if (err) { /* atomic, no rollback in ioctl() */
2696 cam->state |= DEV_MISCONFIGURED;
2697 DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
2698 "use the camera, close and open %s again.",
2699 video_device_node_name(cam->v4ldev));
2700 return -EIO;
2703 memcpy(pfmt, pix, sizeof(*pix));
2704 memcpy(&(s->_rect), &rect, sizeof(rect));
2706 if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2707 nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2708 cam->state |= DEV_MISCONFIGURED;
2709 DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
2710 "use the camera, close and open %s again.",
2711 video_device_node_name(cam->v4ldev));
2712 return -ENOMEM;
2715 if (cam->io == IO_READ)
2716 sn9c102_empty_framequeues(cam);
2717 else if (cam->module_param.force_munmap)
2718 sn9c102_requeue_outqueue(cam);
2720 cam->stream = stream;
2722 return 0;
2726 static int
2727 sn9c102_vidioc_g_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2729 if (copy_to_user(arg, &cam->compression, sizeof(cam->compression)))
2730 return -EFAULT;
2732 return 0;
2736 static int
2737 sn9c102_vidioc_s_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2739 struct v4l2_jpegcompression jc;
2740 const enum sn9c102_stream_state stream = cam->stream;
2741 int err = 0;
2743 if (copy_from_user(&jc, arg, sizeof(jc)))
2744 return -EFAULT;
2746 if (jc.quality != 0 && jc.quality != 1)
2747 return -EINVAL;
2749 if (cam->stream == STREAM_ON)
2750 if ((err = sn9c102_stream_interrupt(cam)))
2751 return err;
2753 err += sn9c102_set_compression(cam, &jc);
2754 if (err) { /* atomic, no rollback in ioctl() */
2755 cam->state |= DEV_MISCONFIGURED;
2756 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware problems. "
2757 "To use the camera, close and open %s again.",
2758 video_device_node_name(cam->v4ldev));
2759 return -EIO;
2762 cam->compression.quality = jc.quality;
2764 cam->stream = stream;
2766 return 0;
2770 static int
2771 sn9c102_vidioc_reqbufs(struct sn9c102_device* cam, void __user * arg)
2773 struct v4l2_requestbuffers rb;
2774 u32 i;
2775 int err;
2777 if (copy_from_user(&rb, arg, sizeof(rb)))
2778 return -EFAULT;
2780 if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2781 rb.memory != V4L2_MEMORY_MMAP)
2782 return -EINVAL;
2784 if (cam->io == IO_READ) {
2785 DBG(3, "Close and open the device again to choose the mmap "
2786 "I/O method");
2787 return -EBUSY;
2790 for (i = 0; i < cam->nbuffers; i++)
2791 if (cam->frame[i].vma_use_count) {
2792 DBG(3, "VIDIOC_REQBUFS failed. Previous buffers are "
2793 "still mapped.");
2794 return -EBUSY;
2797 if (cam->stream == STREAM_ON)
2798 if ((err = sn9c102_stream_interrupt(cam)))
2799 return err;
2801 sn9c102_empty_framequeues(cam);
2803 sn9c102_release_buffers(cam);
2804 if (rb.count)
2805 rb.count = sn9c102_request_buffers(cam, rb.count, IO_MMAP);
2807 if (copy_to_user(arg, &rb, sizeof(rb))) {
2808 sn9c102_release_buffers(cam);
2809 cam->io = IO_NONE;
2810 return -EFAULT;
2813 cam->io = rb.count ? IO_MMAP : IO_NONE;
2815 return 0;
2819 static int
2820 sn9c102_vidioc_querybuf(struct sn9c102_device* cam, void __user * arg)
2822 struct v4l2_buffer b;
2824 if (copy_from_user(&b, arg, sizeof(b)))
2825 return -EFAULT;
2827 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2828 b.index >= cam->nbuffers || cam->io != IO_MMAP)
2829 return -EINVAL;
2831 b = cam->frame[b.index].buf;
2833 if (cam->frame[b.index].vma_use_count)
2834 b.flags |= V4L2_BUF_FLAG_MAPPED;
2836 if (cam->frame[b.index].state == F_DONE)
2837 b.flags |= V4L2_BUF_FLAG_DONE;
2838 else if (cam->frame[b.index].state != F_UNUSED)
2839 b.flags |= V4L2_BUF_FLAG_QUEUED;
2841 if (copy_to_user(arg, &b, sizeof(b)))
2842 return -EFAULT;
2844 return 0;
2848 static int
2849 sn9c102_vidioc_qbuf(struct sn9c102_device* cam, void __user * arg)
2851 struct v4l2_buffer b;
2852 unsigned long lock_flags;
2854 if (copy_from_user(&b, arg, sizeof(b)))
2855 return -EFAULT;
2857 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2858 b.index >= cam->nbuffers || cam->io != IO_MMAP)
2859 return -EINVAL;
2861 if (cam->frame[b.index].state != F_UNUSED)
2862 return -EINVAL;
2864 cam->frame[b.index].state = F_QUEUED;
2866 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2867 list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2868 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2870 PDBGG("Frame #%lu queued", (unsigned long)b.index);
2872 return 0;
2876 static int
2877 sn9c102_vidioc_dqbuf(struct sn9c102_device* cam, struct file* filp,
2878 void __user * arg)
2880 struct v4l2_buffer b;
2881 struct sn9c102_frame_t *f;
2882 unsigned long lock_flags;
2883 long timeout;
2884 int err = 0;
2886 if (copy_from_user(&b, arg, sizeof(b)))
2887 return -EFAULT;
2889 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2890 return -EINVAL;
2892 if (list_empty(&cam->outqueue)) {
2893 if (cam->stream == STREAM_OFF)
2894 return -EINVAL;
2895 if (filp->f_flags & O_NONBLOCK)
2896 return -EAGAIN;
2897 if (!cam->module_param.frame_timeout) {
2898 err = wait_event_interruptible
2899 ( cam->wait_frame,
2900 (!list_empty(&cam->outqueue)) ||
2901 (cam->state & DEV_DISCONNECTED) ||
2902 (cam->state & DEV_MISCONFIGURED) );
2903 if (err)
2904 return err;
2905 } else {
2906 timeout = wait_event_interruptible_timeout
2907 ( cam->wait_frame,
2908 (!list_empty(&cam->outqueue)) ||
2909 (cam->state & DEV_DISCONNECTED) ||
2910 (cam->state & DEV_MISCONFIGURED),
2911 cam->module_param.frame_timeout *
2912 1000 * msecs_to_jiffies(1) );
2913 if (timeout < 0)
2914 return timeout;
2915 else if (timeout == 0 &&
2916 !(cam->state & DEV_DISCONNECTED)) {
2917 DBG(1, "Video frame timeout elapsed");
2918 return -EIO;
2921 if (cam->state & DEV_DISCONNECTED)
2922 return -ENODEV;
2923 if (cam->state & DEV_MISCONFIGURED)
2924 return -EIO;
2927 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2928 f = list_entry(cam->outqueue.next, struct sn9c102_frame_t, frame);
2929 list_del(cam->outqueue.next);
2930 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2932 f->state = F_UNUSED;
2934 b = f->buf;
2935 if (f->vma_use_count)
2936 b.flags |= V4L2_BUF_FLAG_MAPPED;
2938 if (copy_to_user(arg, &b, sizeof(b)))
2939 return -EFAULT;
2941 PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index);
2943 return 0;
2947 static int
2948 sn9c102_vidioc_streamon(struct sn9c102_device* cam, void __user * arg)
2950 int type;
2952 if (copy_from_user(&type, arg, sizeof(type)))
2953 return -EFAULT;
2955 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2956 return -EINVAL;
2958 cam->stream = STREAM_ON;
2960 DBG(3, "Stream on");
2962 return 0;
2966 static int
2967 sn9c102_vidioc_streamoff(struct sn9c102_device* cam, void __user * arg)
2969 int type, err;
2971 if (copy_from_user(&type, arg, sizeof(type)))
2972 return -EFAULT;
2974 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2975 return -EINVAL;
2977 if (cam->stream == STREAM_ON)
2978 if ((err = sn9c102_stream_interrupt(cam)))
2979 return err;
2981 sn9c102_empty_framequeues(cam);
2983 DBG(3, "Stream off");
2985 return 0;
2989 static int
2990 sn9c102_vidioc_g_parm(struct sn9c102_device* cam, void __user * arg)
2992 struct v4l2_streamparm sp;
2994 if (copy_from_user(&sp, arg, sizeof(sp)))
2995 return -EFAULT;
2997 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2998 return -EINVAL;
3000 sp.parm.capture.extendedmode = 0;
3001 sp.parm.capture.readbuffers = cam->nreadbuffers;
3003 if (copy_to_user(arg, &sp, sizeof(sp)))
3004 return -EFAULT;
3006 return 0;
3010 static int
3011 sn9c102_vidioc_s_parm(struct sn9c102_device* cam, void __user * arg)
3013 struct v4l2_streamparm sp;
3015 if (copy_from_user(&sp, arg, sizeof(sp)))
3016 return -EFAULT;
3018 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
3019 return -EINVAL;
3021 sp.parm.capture.extendedmode = 0;
3023 if (sp.parm.capture.readbuffers == 0)
3024 sp.parm.capture.readbuffers = cam->nreadbuffers;
3026 if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
3027 sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
3029 if (copy_to_user(arg, &sp, sizeof(sp)))
3030 return -EFAULT;
3032 cam->nreadbuffers = sp.parm.capture.readbuffers;
3034 return 0;
3038 static int
3039 sn9c102_vidioc_enumaudio(struct sn9c102_device* cam, void __user * arg)
3041 struct v4l2_audio audio;
3043 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3044 return -EINVAL;
3046 if (copy_from_user(&audio, arg, sizeof(audio)))
3047 return -EFAULT;
3049 if (audio.index != 0)
3050 return -EINVAL;
3052 strcpy(audio.name, "Microphone");
3053 audio.capability = 0;
3054 audio.mode = 0;
3056 if (copy_to_user(arg, &audio, sizeof(audio)))
3057 return -EFAULT;
3059 return 0;
3063 static int
3064 sn9c102_vidioc_g_audio(struct sn9c102_device* cam, void __user * arg)
3066 struct v4l2_audio audio;
3068 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3069 return -EINVAL;
3071 if (copy_from_user(&audio, arg, sizeof(audio)))
3072 return -EFAULT;
3074 memset(&audio, 0, sizeof(audio));
3075 strcpy(audio.name, "Microphone");
3077 if (copy_to_user(arg, &audio, sizeof(audio)))
3078 return -EFAULT;
3080 return 0;
3084 static int
3085 sn9c102_vidioc_s_audio(struct sn9c102_device* cam, void __user * arg)
3087 struct v4l2_audio audio;
3089 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3090 return -EINVAL;
3092 if (copy_from_user(&audio, arg, sizeof(audio)))
3093 return -EFAULT;
3095 if (audio.index != 0)
3096 return -EINVAL;
3098 return 0;
3102 static long sn9c102_ioctl_v4l2(struct file *filp,
3103 unsigned int cmd, void __user *arg)
3105 struct sn9c102_device *cam = video_drvdata(filp);
3107 switch (cmd) {
3109 case VIDIOC_QUERYCAP:
3110 return sn9c102_vidioc_querycap(cam, arg);
3112 case VIDIOC_ENUMINPUT:
3113 return sn9c102_vidioc_enuminput(cam, arg);
3115 case VIDIOC_G_INPUT:
3116 return sn9c102_vidioc_g_input(cam, arg);
3118 case VIDIOC_S_INPUT:
3119 return sn9c102_vidioc_s_input(cam, arg);
3121 case VIDIOC_QUERYCTRL:
3122 return sn9c102_vidioc_query_ctrl(cam, arg);
3124 case VIDIOC_G_CTRL:
3125 return sn9c102_vidioc_g_ctrl(cam, arg);
3127 case VIDIOC_S_CTRL:
3128 return sn9c102_vidioc_s_ctrl(cam, arg);
3130 case VIDIOC_CROPCAP:
3131 return sn9c102_vidioc_cropcap(cam, arg);
3133 case VIDIOC_G_CROP:
3134 return sn9c102_vidioc_g_crop(cam, arg);
3136 case VIDIOC_S_CROP:
3137 return sn9c102_vidioc_s_crop(cam, arg);
3139 case VIDIOC_ENUM_FRAMESIZES:
3140 return sn9c102_vidioc_enum_framesizes(cam, arg);
3142 case VIDIOC_ENUM_FMT:
3143 return sn9c102_vidioc_enum_fmt(cam, arg);
3145 case VIDIOC_G_FMT:
3146 return sn9c102_vidioc_g_fmt(cam, arg);
3148 case VIDIOC_TRY_FMT:
3149 case VIDIOC_S_FMT:
3150 return sn9c102_vidioc_try_s_fmt(cam, cmd, arg);
3152 case VIDIOC_G_JPEGCOMP:
3153 return sn9c102_vidioc_g_jpegcomp(cam, arg);
3155 case VIDIOC_S_JPEGCOMP:
3156 return sn9c102_vidioc_s_jpegcomp(cam, arg);
3158 case VIDIOC_REQBUFS:
3159 return sn9c102_vidioc_reqbufs(cam, arg);
3161 case VIDIOC_QUERYBUF:
3162 return sn9c102_vidioc_querybuf(cam, arg);
3164 case VIDIOC_QBUF:
3165 return sn9c102_vidioc_qbuf(cam, arg);
3167 case VIDIOC_DQBUF:
3168 return sn9c102_vidioc_dqbuf(cam, filp, arg);
3170 case VIDIOC_STREAMON:
3171 return sn9c102_vidioc_streamon(cam, arg);
3173 case VIDIOC_STREAMOFF:
3174 return sn9c102_vidioc_streamoff(cam, arg);
3176 case VIDIOC_G_PARM:
3177 return sn9c102_vidioc_g_parm(cam, arg);
3179 case VIDIOC_S_PARM:
3180 return sn9c102_vidioc_s_parm(cam, arg);
3182 case VIDIOC_ENUMAUDIO:
3183 return sn9c102_vidioc_enumaudio(cam, arg);
3185 case VIDIOC_G_AUDIO:
3186 return sn9c102_vidioc_g_audio(cam, arg);
3188 case VIDIOC_S_AUDIO:
3189 return sn9c102_vidioc_s_audio(cam, arg);
3191 default:
3192 return -ENOTTY;
3198 static long sn9c102_ioctl(struct file *filp,
3199 unsigned int cmd, unsigned long arg)
3201 struct sn9c102_device *cam = video_drvdata(filp);
3202 int err = 0;
3204 if (mutex_lock_interruptible(&cam->fileop_mutex))
3205 return -ERESTARTSYS;
3207 if (cam->state & DEV_DISCONNECTED) {
3208 DBG(1, "Device not present");
3209 mutex_unlock(&cam->fileop_mutex);
3210 return -ENODEV;
3213 if (cam->state & DEV_MISCONFIGURED) {
3214 DBG(1, "The camera is misconfigured. Close and open it "
3215 "again.");
3216 mutex_unlock(&cam->fileop_mutex);
3217 return -EIO;
3220 V4LDBG(3, "sn9c102", cmd);
3222 err = sn9c102_ioctl_v4l2(filp, cmd, (void __user *)arg);
3224 mutex_unlock(&cam->fileop_mutex);
3226 return err;
3229 /*****************************************************************************/
3231 static const struct v4l2_file_operations sn9c102_fops = {
3232 .owner = THIS_MODULE,
3233 .open = sn9c102_open,
3234 .release = sn9c102_release,
3235 .unlocked_ioctl = sn9c102_ioctl,
3236 .read = sn9c102_read,
3237 .poll = sn9c102_poll,
3238 .mmap = sn9c102_mmap,
3241 /*****************************************************************************/
3243 /* It exists a single interface only. We do not need to validate anything. */
3244 static int
3245 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
3247 struct usb_device *udev = interface_to_usbdev(intf);
3248 struct sn9c102_device* cam;
3249 static unsigned int dev_nr;
3250 unsigned int i;
3251 int err = 0, r;
3253 if (!(cam = kzalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
3254 return -ENOMEM;
3256 cam->usbdev = udev;
3258 /* register v4l2_device early so it can be used for printks */
3259 if (v4l2_device_register(&intf->dev, &cam->v4l2_dev)) {
3260 dev_err(&intf->dev, "v4l2_device_register failed\n");
3261 err = -ENOMEM;
3262 goto fail;
3265 if (!(cam->control_buffer = kzalloc(8, GFP_KERNEL))) {
3266 DBG(1, "kzalloc() failed");
3267 err = -ENOMEM;
3268 goto fail;
3271 if (!(cam->v4ldev = video_device_alloc())) {
3272 DBG(1, "video_device_alloc() failed");
3273 err = -ENOMEM;
3274 goto fail;
3277 r = sn9c102_read_reg(cam, 0x00);
3278 if (r < 0 || (r != 0x10 && r != 0x11 && r != 0x12)) {
3279 DBG(1, "Sorry, this is not a SN9C1xx-based camera "
3280 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3281 err = -ENODEV;
3282 goto fail;
3285 cam->bridge = id->driver_info;
3286 switch (cam->bridge) {
3287 case BRIDGE_SN9C101:
3288 case BRIDGE_SN9C102:
3289 DBG(2, "SN9C10[12] PC Camera Controller detected "
3290 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3291 break;
3292 case BRIDGE_SN9C103:
3293 DBG(2, "SN9C103 PC Camera Controller detected "
3294 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3295 break;
3296 case BRIDGE_SN9C105:
3297 DBG(2, "SN9C105 PC Camera Controller detected "
3298 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3299 break;
3300 case BRIDGE_SN9C120:
3301 DBG(2, "SN9C120 PC Camera Controller detected "
3302 "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3303 break;
3306 for (i = 0; i < ARRAY_SIZE(sn9c102_sensor_table); i++) {
3307 err = sn9c102_sensor_table[i](cam);
3308 if (!err)
3309 break;
3312 if (!err) {
3313 DBG(2, "%s image sensor detected", cam->sensor.name);
3314 DBG(3, "Support for %s maintained by %s",
3315 cam->sensor.name, cam->sensor.maintainer);
3316 } else {
3317 DBG(1, "No supported image sensor detected for this bridge");
3318 err = -ENODEV;
3319 goto fail;
3322 if (!(cam->bridge & cam->sensor.supported_bridge)) {
3323 DBG(1, "Bridge not supported");
3324 err = -ENODEV;
3325 goto fail;
3328 if (sn9c102_init(cam)) {
3329 DBG(1, "Initialization failed. I will retry on open().");
3330 cam->state |= DEV_MISCONFIGURED;
3333 strcpy(cam->v4ldev->name, "SN9C1xx PC Camera");
3334 cam->v4ldev->fops = &sn9c102_fops;
3335 cam->v4ldev->release = video_device_release;
3336 cam->v4ldev->v4l2_dev = &cam->v4l2_dev;
3338 init_completion(&cam->probe);
3340 err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3341 video_nr[dev_nr]);
3342 if (err) {
3343 DBG(1, "V4L2 device registration failed");
3344 if (err == -ENFILE && video_nr[dev_nr] == -1)
3345 DBG(1, "Free /dev/videoX node not found");
3346 video_nr[dev_nr] = -1;
3347 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3348 complete_all(&cam->probe);
3349 goto fail;
3352 DBG(2, "V4L2 device registered as %s",
3353 video_device_node_name(cam->v4ldev));
3355 video_set_drvdata(cam->v4ldev, cam);
3356 cam->module_param.force_munmap = force_munmap[dev_nr];
3357 cam->module_param.frame_timeout = frame_timeout[dev_nr];
3359 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3361 #ifdef CONFIG_VIDEO_ADV_DEBUG
3362 err = sn9c102_create_sysfs(cam);
3363 if (!err)
3364 DBG(2, "Optional device control through 'sysfs' "
3365 "interface ready");
3366 else
3367 DBG(2, "Failed to create optional 'sysfs' interface for "
3368 "device controlling. Error #%d", err);
3369 #else
3370 DBG(2, "Optional device control through 'sysfs' interface disabled");
3371 DBG(3, "Compile the kernel with the 'CONFIG_VIDEO_ADV_DEBUG' "
3372 "configuration option to enable it.");
3373 #endif
3375 usb_set_intfdata(intf, cam);
3376 kref_init(&cam->kref);
3377 usb_get_dev(cam->usbdev);
3379 complete_all(&cam->probe);
3381 return 0;
3383 fail:
3384 if (cam) {
3385 kfree(cam->control_buffer);
3386 if (cam->v4ldev)
3387 video_device_release(cam->v4ldev);
3388 v4l2_device_unregister(&cam->v4l2_dev);
3389 kfree(cam);
3391 return err;
3395 static void sn9c102_usb_disconnect(struct usb_interface* intf)
3397 struct sn9c102_device* cam;
3399 down_write(&sn9c102_dev_lock);
3401 cam = usb_get_intfdata(intf);
3403 DBG(2, "Disconnecting %s...", cam->v4ldev->name);
3405 if (cam->users) {
3406 DBG(2, "Device %s is open! Deregistration and memory "
3407 "deallocation are deferred.",
3408 video_device_node_name(cam->v4ldev));
3409 cam->state |= DEV_MISCONFIGURED;
3410 sn9c102_stop_transfer(cam);
3411 cam->state |= DEV_DISCONNECTED;
3412 wake_up_interruptible(&cam->wait_frame);
3413 wake_up(&cam->wait_stream);
3414 } else
3415 cam->state |= DEV_DISCONNECTED;
3417 wake_up_interruptible_all(&cam->wait_open);
3419 v4l2_device_disconnect(&cam->v4l2_dev);
3421 kref_put(&cam->kref, sn9c102_release_resources);
3423 up_write(&sn9c102_dev_lock);
3427 static struct usb_driver sn9c102_usb_driver = {
3428 .name = "sn9c102",
3429 .id_table = sn9c102_id_table,
3430 .probe = sn9c102_usb_probe,
3431 .disconnect = sn9c102_usb_disconnect,
3434 module_usb_driver(sn9c102_usb_driver);