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