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