1 /***************************************************************************
2 * V4L2 driver for SN9C10x PC Camera Controllers *
3 * *
4 * Copyright (C) 2004-2005 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/moduleparam.h>
26 #include <linux/errno.h>
27 #include <linux/slab.h>
28 #include <linux/string.h>
29 #include <linux/device.h>
30 #include <linux/fs.h>
31 #include <linux/delay.h>
32 #include <linux/stddef.h>
33 #include <linux/compiler.h>
34 #include <linux/ioctl.h>
35 #include <linux/poll.h>
36 #include <linux/stat.h>
37 #include <linux/mm.h>
38 #include <linux/vmalloc.h>
39 #include <linux/page-flags.h>
40 #include <linux/byteorder/generic.h>
41 #include <asm/page.h>
42 #include <asm/uaccess.h>
43
44 #include "sn9c102.h"
45
46 /*****************************************************************************/
47
48 MODULE_DEVICE_TABLE(usb, sn9c102_id_table);
49
50 MODULE_AUTHOR(SN9C102_MODULE_AUTHOR " " SN9C102_AUTHOR_EMAIL);
51 MODULE_DESCRIPTION(SN9C102_MODULE_NAME);
52 MODULE_VERSION(SN9C102_MODULE_VERSION);
53 MODULE_LICENSE(SN9C102_MODULE_LICENSE);
54
55 static short video_nr[] = {[0 ... SN9C102_MAX_DEVICES-1] = -1};
56 module_param_array(video_nr, short, NULL, 0444);
57 MODULE_PARM_DESC(video_nr,
58 "\n<-1|n[,...]> Specify V4L2 minor mode number."
59 "\n -1 = use next available (default)"
60 "\n n = use minor number n (integer >= 0)"
61 "\nYou can specify up to "__MODULE_STRING(SN9C102_MAX_DEVICES)
62 " cameras this way."
63 "\nFor example:"
64 "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
65 "\nthe second camera and use auto for the first"
66 "\none and for every other camera."
67 "\n");
68
69 static short force_munmap[] = {[0 ... SN9C102_MAX_DEVICES-1] =
70 SN9C102_FORCE_MUNMAP};
71 module_param_array(force_munmap, bool, NULL, 0444);
72 MODULE_PARM_DESC(force_munmap,
73 "\n<0|1[,...]> Force the application to unmap previously "
74 "\nmapped buffer memory before calling any VIDIOC_S_CROP or "
75 "\nVIDIOC_S_FMT ioctl's. Not all the applications support "
76 "\nthis feature. This parameter is specific for each "
77 "\ndetected camera."
78 "\n 0 = do not force memory unmapping"
79 "\n 1 = force memory unmapping (save memory)"
80 "\nDefault value is "__MODULE_STRING(SN9C102_FORCE_MUNMAP)"."
81 "\n");
82
83 #ifdef SN9C102_DEBUG
84 static unsigned short debug = SN9C102_DEBUG_LEVEL;
85 module_param(debug, ushort, 0644);
86 MODULE_PARM_DESC(debug,
87 "\n<n> Debugging information level, from 0 to 3:"
88 "\n0 = none (use carefully)"
89 "\n1 = critical errors"
90 "\n2 = significant informations"
91 "\n3 = more verbose messages"
92 "\nLevel 3 is useful for testing only, when only "
93 "one device is used."
94 "\nDefault value is "__MODULE_STRING(SN9C102_DEBUG_LEVEL)"."
95 "\n");
96 #endif
97
98 /*****************************************************************************/
99
100 static sn9c102_sof_header_t sn9c102_sof_header[] = {
101 {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96, 0x00},
102 {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96, 0x01},
103 };
104
105
106 static sn9c102_eof_header_t sn9c102_eof_header[] = {
107 {0x00, 0x00, 0x00, 0x00},
108 {0x40, 0x00, 0x00, 0x00},
109 {0x80, 0x00, 0x00, 0x00},
110 {0xc0, 0x00, 0x00, 0x00},
111 };
112
113 /*****************************************************************************/
114
115 static void* rvmalloc(size_t size)
116 {
117 void* mem;
118 unsigned long adr;
119
120 size = PAGE_ALIGN(size);
121
122 mem = vmalloc_32((unsigned long)size);
123 if (!mem)
124 return NULL;
125
126 memset(mem, 0, size);
127
128 adr = (unsigned long)mem;
129 while (size > 0) {
130 SetPageReserved(vmalloc_to_page((void *)adr));
131 adr += PAGE_SIZE;
132 size -= PAGE_SIZE;
133 }
134
135 return mem;
136 }
137
138
139 static void rvfree(void* mem, size_t size)
140 {
141 unsigned long adr;
142
143 if (!mem)
144 return;
145
146 size = PAGE_ALIGN(size);
147
148 adr = (unsigned long)mem;
149 while (size > 0) {
150 ClearPageReserved(vmalloc_to_page((void *)adr));
151 adr += PAGE_SIZE;
152 size -= PAGE_SIZE;
153 }
154
155 vfree(mem);
156 }
157
158
159 static u32
160 sn9c102_request_buffers(struct sn9c102_device* cam, u32 count,
161 enum sn9c102_io_method io)
162 {
163 struct v4l2_pix_format* p = &(cam->sensor->pix_format);
164 struct v4l2_rect* r = &(cam->sensor->cropcap.bounds);
165 const size_t imagesize = cam->module_param.force_munmap ||
166 io == IO_READ ?
167 (p->width * p->height * p->priv)/8 :
168 (r->width * r->height * p->priv)/8;
169 void* buff = NULL;
170 u32 i;
171
172 if (count > SN9C102_MAX_FRAMES)
173 count = SN9C102_MAX_FRAMES;
174
175 cam->nbuffers = count;
176 while (cam->nbuffers > 0) {
177 if ((buff = rvmalloc(cam->nbuffers * PAGE_ALIGN(imagesize))))
178 break;
179 cam->nbuffers--;
180 }
181
182 for (i = 0; i < cam->nbuffers; i++) {
183 cam->frame[i].bufmem = buff + i*PAGE_ALIGN(imagesize);
184 cam->frame[i].buf.index = i;
185 cam->frame[i].buf.m.offset = i*PAGE_ALIGN(imagesize);
186 cam->frame[i].buf.length = imagesize;
187 cam->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
188 cam->frame[i].buf.sequence = 0;
189 cam->frame[i].buf.field = V4L2_FIELD_NONE;
190 cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
191 cam->frame[i].buf.flags = 0;
192 }
193
194 return cam->nbuffers;
195 }
196
197
198 static void sn9c102_release_buffers(struct sn9c102_device* cam)
199 {
200 if (cam->nbuffers) {
201 rvfree(cam->frame[0].bufmem,
202 cam->nbuffers * cam->frame[0].buf.length);
203 cam->nbuffers = 0;
204 }
205 }
206
207
208 static void sn9c102_empty_framequeues(struct sn9c102_device* cam)
209 {
210 u32 i;
211
212 INIT_LIST_HEAD(&cam->inqueue);
213 INIT_LIST_HEAD(&cam->outqueue);
214
215 for (i = 0; i < SN9C102_MAX_FRAMES; i++) {
216 cam->frame[i].state = F_UNUSED;
217 cam->frame[i].buf.bytesused = 0;
218 }
219 }
220
221
222 static void sn9c102_queue_unusedframes(struct sn9c102_device* cam)
223 {
224 unsigned long lock_flags;
225 u32 i;
226
227 for (i = 0; i < cam->nbuffers; i++)
228 if (cam->frame[i].state == F_UNUSED) {
229 cam->frame[i].state = F_QUEUED;
230 spin_lock_irqsave(&cam->queue_lock, lock_flags);
231 list_add_tail(&cam->frame[i].frame, &cam->inqueue);
232 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
233 }
234 }
235
236 /*****************************************************************************/
237
238 int sn9c102_write_reg(struct sn9c102_device* cam, u8 value, u16 index)
239 {
240 struct usb_device* udev = cam->usbdev;
241 u8* buff = cam->control_buffer;
242 int res;
243
244 *buff = value;
245
246 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
247 index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
248 if (res < 0) {
249 DBG(3, "Failed to write a register (value 0x%02X, index "
250 "0x%02X, error %d)", value, index, res)
251 return -1;
252 }
253
254 cam->reg[index] = value;
255
256 return 0;
257 }
258
259
260 /* NOTE: reading some registers always returns 0 */
261 static int sn9c102_read_reg(struct sn9c102_device* cam, u16 index)
262 {
263 struct usb_device* udev = cam->usbdev;
264 u8* buff = cam->control_buffer;
265 int res;
266
267 res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
268 index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
269 if (res < 0)
270 DBG(3, "Failed to read a register (index 0x%02X, error %d)",
271 index, res)
272
273 return (res >= 0) ? (int)(*buff) : -1;
274 }
275
276
277 int sn9c102_pread_reg(struct sn9c102_device* cam, u16 index)
278 {
279 if (index > 0x1f)
280 return -EINVAL;
281
282 return cam->reg[index];
283 }
284
285
286 static int
287 sn9c102_i2c_wait(struct sn9c102_device* cam, struct sn9c102_sensor* sensor)
288 {
289 int i, r;
290
291 for (i = 1; i <= 5; i++) {
292 r = sn9c102_read_reg(cam, 0x08);
293 if (r < 0)
294 return -EIO;
295 if (r & 0x04)
296 return 0;
297 if (sensor->frequency & SN9C102_I2C_400KHZ)
298 udelay(5*16);
299 else
300 udelay(16*16);
301 }
302 return -EBUSY;
303 }
304
305
306 static int
307 sn9c102_i2c_detect_read_error(struct sn9c102_device* cam,
308 struct sn9c102_sensor* sensor)
309 {
310 int r;
311 r = sn9c102_read_reg(cam, 0x08);
312 return (r < 0 || (r >= 0 && !(r & 0x08))) ? -EIO : 0;
313 }
314
315
316 static int
317 sn9c102_i2c_detect_write_error(struct sn9c102_device* cam,
318 struct sn9c102_sensor* sensor)
319 {
320 int r;
321 r = sn9c102_read_reg(cam, 0x08);
322 return (r < 0 || (r >= 0 && (r & 0x08))) ? -EIO : 0;
323 }
324
325
326 int
327 sn9c102_i2c_try_raw_read(struct sn9c102_device* cam,
328 struct sn9c102_sensor* sensor, u8 data0, u8 data1,
329 u8 n, u8 buffer[])
330 {
331 struct usb_device* udev = cam->usbdev;
332 u8* data = cam->control_buffer;
333 int err = 0, res;
334
335 /* Write cycle */
336 data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
337 ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) | 0x10;
338 data[1] = data0; /* I2C slave id */
339 data[2] = data1; /* address */
340 data[7] = 0x10;
341 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
342 0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
343 if (res < 0)
344 err += res;
345
346 err += sn9c102_i2c_wait(cam, sensor);
347
348 /* Read cycle - n bytes */
349 data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
350 ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) |
351 (n << 4) | 0x02;
352 data[1] = data0;
353 data[7] = 0x10;
354 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
355 0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
356 if (res < 0)
357 err += res;
358
359 err += sn9c102_i2c_wait(cam, sensor);
360
361 /* The first read byte will be placed in data[4] */
362 res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
363 0x0a, 0, data, 5, SN9C102_CTRL_TIMEOUT);
364 if (res < 0)
365 err += res;
366
367 err += sn9c102_i2c_detect_read_error(cam, sensor);
368
369 PDBGG("I2C read: address 0x%02X, first read byte: 0x%02X", data1,
370 data[4])
371
372 if (err) {
373 DBG(3, "I2C read failed for %s image sensor", sensor->name)
374 return -1;
375 }
376
377 if (buffer)
378 memcpy(buffer, data, sizeof(buffer));
379
380 return (int)data[4];
381 }
382
383
384 int
385 sn9c102_i2c_try_raw_write(struct sn9c102_device* cam,
386 struct sn9c102_sensor* sensor, u8 n, u8 data0,
387 u8 data1, u8 data2, u8 data3, u8 data4, u8 data5)
388 {
389 struct usb_device* udev = cam->usbdev;
390 u8* data = cam->control_buffer;
391 int err = 0, res;
392
393 /* Write cycle. It usually is address + value */
394 data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
395 ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0)
396 | ((n - 1) << 4);
397 data[1] = data0;
398 data[2] = data1;
399 data[3] = data2;
400 data[4] = data3;
401 data[5] = data4;
402 data[6] = data5;
403 data[7] = 0x14;
404 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
405 0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
406 if (res < 0)
407 err += res;
408
409 err += sn9c102_i2c_wait(cam, sensor);
410 err += sn9c102_i2c_detect_write_error(cam, sensor);
411
412 if (err)
413 DBG(3, "I2C write failed for %s image sensor", sensor->name)
414
415 PDBGG("I2C raw write: %u bytes, data0 = 0x%02X, data1 = 0x%02X, "
416 "data2 = 0x%02X, data3 = 0x%02X, data4 = 0x%02X, data5 = 0x%02X",
417 n, data0, data1, data2, data3, data4, data5)
418
419 return err ? -1 : 0;
420 }
421
422
423 int
424 sn9c102_i2c_try_read(struct sn9c102_device* cam,
425 struct sn9c102_sensor* sensor, u8 address)
426 {
427 return sn9c102_i2c_try_raw_read(cam, sensor, sensor->i2c_slave_id,
428 address, 1, NULL);
429 }
430
431
432 int
433 sn9c102_i2c_try_write(struct sn9c102_device* cam,
434 struct sn9c102_sensor* sensor, u8 address, u8 value)
435 {
436 return sn9c102_i2c_try_raw_write(cam, sensor, 3,
437 sensor->i2c_slave_id, address,
438 value, 0, 0, 0);
439 }
440
441
442 int sn9c102_i2c_read(struct sn9c102_device* cam, u8 address)
443 {
444 if (!cam->sensor)
445 return -1;
446
447 return sn9c102_i2c_try_read(cam, cam->sensor, address);
448 }
449
450
451 int sn9c102_i2c_write(struct sn9c102_device* cam, u8 address, u8 value)
452 {
453 if (!cam->sensor)
454 return -1;
455
456 return sn9c102_i2c_try_write(cam, cam->sensor, address, value);
457 }
458
459 /*****************************************************************************/
460
461 static void*
462 sn9c102_find_sof_header(struct sn9c102_device* cam, void* mem, size_t len)
463 {
464 size_t soflen = sizeof(sn9c102_sof_header_t), i;
465 u8 j, n = sizeof(sn9c102_sof_header) / soflen;
466
467 for (i = 0; (len >= soflen) && (i <= len - soflen); i++)
468 for (j = 0; j < n; j++)
469 /* It's enough to compare 7 bytes */
470 if (!memcmp(mem + i, sn9c102_sof_header[j], 7)) {
471 memcpy(cam->sof_header, mem + i, soflen);
472 /* Skip the header */
473 return mem + i + soflen;
474 }
475
476 return NULL;
477 }
478
479
480 static void*
481 sn9c102_find_eof_header(struct sn9c102_device* cam, void* mem, size_t len)
482 {
483 size_t eoflen = sizeof(sn9c102_eof_header_t), i;
484 unsigned j, n = sizeof(sn9c102_eof_header) / eoflen;
485
486 if (cam->sensor->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
487 return NULL; /* EOF header does not exist in compressed data */
488
489 for (i = 0; (len >= eoflen) && (i <= len - eoflen); i++)
490 for (j = 0; j < n; j++)
491 if (!memcmp(mem + i, sn9c102_eof_header[j], eoflen))
492 return mem + i;
493
494 return NULL;
495 }
496
497
498 static void sn9c102_urb_complete(struct urb *urb, struct pt_regs* regs)
499 {
500 struct sn9c102_device* cam = urb->context;
501 struct sn9c102_frame_t** f;
502 unsigned long lock_flags;
503 u8 i;
504 int err = 0;
505
506 if (urb->status == -ENOENT)
507 return;
508
509 f = &cam->frame_current;
510
511 if (cam->stream == STREAM_INTERRUPT) {
512 cam->stream = STREAM_OFF;
513 if ((*f))
514 (*f)->state = F_QUEUED;
515 DBG(3, "Stream interrupted")
516 wake_up_interruptible(&cam->wait_stream);
517 }
518
519 if ((cam->state & DEV_DISCONNECTED)||(cam->state & DEV_MISCONFIGURED))
520 return;
521
522 if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
523 goto resubmit_urb;
524
525 if (!(*f))
526 (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
527 frame);
528
529 for (i = 0; i < urb->number_of_packets; i++) {
530 unsigned int img, len, status;
531 void *pos, *sof, *eof;
532
533 len = urb->iso_frame_desc[i].actual_length;
534 status = urb->iso_frame_desc[i].status;
535 pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
536
537 if (status) {
538 DBG(3, "Error in isochronous frame")
539 (*f)->state = F_ERROR;
540 continue;
541 }
542
543 PDBGG("Isochrnous frame: length %u, #%u i", len, i)
544
545 /*
546 NOTE: It is probably correct to assume that SOF and EOF
547 headers do not occur between two consecutive packets,
548 but who knows..Whatever is the truth, this assumption
549 doesn't introduce bugs.
550 */
551
552 redo:
553 sof = sn9c102_find_sof_header(cam, pos, len);
554 if (!sof) {
555 eof = sn9c102_find_eof_header(cam, pos, len);
556 if ((*f)->state == F_GRABBING) {
557 end_of_frame:
558 img = len;
559
560 if (eof)
561 img = (eof > pos) ? eof - pos - 1 : 0;
562
563 if ((*f)->buf.bytesused+img>(*f)->buf.length) {
564 u32 b = (*f)->buf.bytesused + img -
565 (*f)->buf.length;
566 img = (*f)->buf.length -
567 (*f)->buf.bytesused;
568 DBG(3, "Expected EOF not found: "
569 "video frame cut")
570 if (eof)
571 DBG(3, "Exceeded limit: +%u "
572 "bytes", (unsigned)(b))
573 }
574
575 memcpy((*f)->bufmem + (*f)->buf.bytesused, pos,
576 img);
577
578 if ((*f)->buf.bytesused == 0)
579 do_gettimeofday(&(*f)->buf.timestamp);
580
581 (*f)->buf.bytesused += img;
582
583 if ((*f)->buf.bytesused == (*f)->buf.length ||
584 (cam->sensor->pix_format.pixelformat ==
585 V4L2_PIX_FMT_SN9C10X && eof)) {
586 u32 b = (*f)->buf.bytesused;
587 (*f)->state = F_DONE;
588 (*f)->buf.sequence= ++cam->frame_count;
589 spin_lock_irqsave(&cam->queue_lock,
590 lock_flags);
591 list_move_tail(&(*f)->frame,
592 &cam->outqueue);
593 if (!list_empty(&cam->inqueue))
594 (*f) = list_entry(
595 cam->inqueue.next,
596 struct sn9c102_frame_t,
597 frame );
598 else
599 (*f) = NULL;
600 spin_unlock_irqrestore(&cam->queue_lock
601 , lock_flags);
602 memcpy(cam->sysfs.frame_header,
603 cam->sof_header,
604 sizeof(sn9c102_sof_header_t));
605 DBG(3, "Video frame captured: "
606 "%lu bytes", (unsigned long)(b))
607
608 if (!(*f))
609 goto resubmit_urb;
610
611 } else if (eof) {
612 (*f)->state = F_ERROR;
613 DBG(3, "Not expected EOF after %lu "
614 "bytes of image data",
615 (unsigned long)((*f)->buf.bytesused))
616 }
617
618 if (sof) /* (1) */
619 goto start_of_frame;
620
621 } else if (eof) {
622 DBG(3, "EOF without SOF")
623 continue;
624
625 } else {
626 PDBGG("Ignoring pointless isochronous frame")
627 continue;
628 }
629
630 } else if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR) {
631 start_of_frame:
632 (*f)->state = F_GRABBING;
633 (*f)->buf.bytesused = 0;
634 len -= (sof - pos);
635 pos = sof;
636 DBG(3, "SOF detected: new video frame")
637 if (len)
638 goto redo;
639
640 } else if ((*f)->state == F_GRABBING) {
641 eof = sn9c102_find_eof_header(cam, pos, len);
642 if (eof && eof < sof)
643 goto end_of_frame; /* (1) */
644 else {
645 if (cam->sensor->pix_format.pixelformat ==
646 V4L2_PIX_FMT_SN9C10X) {
647 eof = sof-sizeof(sn9c102_sof_header_t);
648 goto end_of_frame;
649 } else {
650 DBG(3, "SOF before expected EOF after "
651 "%lu bytes of image data",
652 (unsigned long)((*f)->buf.bytesused))
653 goto start_of_frame;
654 }
655 }
656 }
657 }
658
659 resubmit_urb:
660 urb->dev = cam->usbdev;
661 err = usb_submit_urb(urb, GFP_ATOMIC);
662 if (err < 0 && err != -EPERM) {
663 cam->state |= DEV_MISCONFIGURED;
664 DBG(1, "usb_submit_urb() failed")
665 }
666
667 wake_up_interruptible(&cam->wait_frame);
668 }
669
670
671 static int sn9c102_start_transfer(struct sn9c102_device* cam)
672 {
673 struct usb_device *udev = cam->usbdev;
674 struct urb* urb;
675 const unsigned int wMaxPacketSize[] = {0, 128, 256, 384, 512,
676 680, 800, 900, 1023};
677 const unsigned int psz = wMaxPacketSize[SN9C102_ALTERNATE_SETTING];
678 s8 i, j;
679 int err = 0;
680
681 for (i = 0; i < SN9C102_URBS; i++) {
682 cam->transfer_buffer[i] = kmalloc(SN9C102_ISO_PACKETS * psz,
683 GFP_KERNEL);
684 if (!cam->transfer_buffer[i]) {
685 err = -ENOMEM;
686 DBG(1, "Not enough memory")
687 goto free_buffers;
688 }
689 }
690
691 for (i = 0; i < SN9C102_URBS; i++) {
692 urb = usb_alloc_urb(SN9C102_ISO_PACKETS, GFP_KERNEL);
693 cam->urb[i] = urb;
694 if (!urb) {
695 err = -ENOMEM;
696 DBG(1, "usb_alloc_urb() failed")
697 goto free_urbs;
698 }
699 urb->dev = udev;
700 urb->context = cam;
701 urb->pipe = usb_rcvisocpipe(udev, 1);
702 urb->transfer_flags = URB_ISO_ASAP;
703 urb->number_of_packets = SN9C102_ISO_PACKETS;
704 urb->complete = sn9c102_urb_complete;
705 urb->transfer_buffer = cam->transfer_buffer[i];
706 urb->transfer_buffer_length = psz * SN9C102_ISO_PACKETS;
707 urb->interval = 1;
708 for (j = 0; j < SN9C102_ISO_PACKETS; j++) {
709 urb->iso_frame_desc[j].offset = psz * j;
710 urb->iso_frame_desc[j].length = psz;
711 }
712 }
713
714 /* Enable video */
715 if (!(cam->reg[0x01] & 0x04)) {
716 err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
717 if (err) {
718 err = -EIO;
719 DBG(1, "I/O hardware error")
720 goto free_urbs;
721 }
722 }
723
724 err = usb_set_interface(udev, 0, SN9C102_ALTERNATE_SETTING);
725 if (err) {
726 DBG(1, "usb_set_interface() failed")
727 goto free_urbs;
728 }
729
730 cam->frame_current = NULL;
731
732 for (i = 0; i < SN9C102_URBS; i++) {
733 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
734 if (err) {
735 for (j = i-1; j >= 0; j--)
736 usb_kill_urb(cam->urb[j]);
737 DBG(1, "usb_submit_urb() failed, error %d", err)
738 goto free_urbs;
739 }
740 }
741
742 return 0;
743
744 free_urbs:
745 for (i = 0; (i < SN9C102_URBS) && cam->urb[i]; i++)
746 usb_free_urb(cam->urb[i]);
747
748 free_buffers:
749 for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
750 kfree(cam->transfer_buffer[i]);
751
752 return err;
753 }
754
755
756 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
757 {
758 struct usb_device *udev = cam->usbdev;
759 s8 i;
760 int err = 0;
761
762 if (cam->state & DEV_DISCONNECTED)
763 return 0;
764
765 for (i = SN9C102_URBS-1; i >= 0; i--) {
766 usb_kill_urb(cam->urb[i]);
767 usb_free_urb(cam->urb[i]);
768 kfree(cam->transfer_buffer[i]);
769 }
770
771 err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
772 if (err)
773 DBG(3, "usb_set_interface() failed")
774
775 return err;
776 }
777
778
779 int sn9c102_stream_interrupt(struct sn9c102_device* cam)
780 {
781 int err = 0;
782
783 cam->stream = STREAM_INTERRUPT;
784 err = wait_event_timeout(cam->wait_stream,
785 (cam->stream == STREAM_OFF) ||
786 (cam->state & DEV_DISCONNECTED),
787 SN9C102_URB_TIMEOUT);
788 if (cam->state & DEV_DISCONNECTED)
789 return -ENODEV;
790 else if (err) {
791 cam->state |= DEV_MISCONFIGURED;
792 DBG(1, "The camera is misconfigured. To use it, close and "
793 "open /dev/video%d again.", cam->v4ldev->minor)
794 return err;
795 }
796
797 return 0;
798 }
799
800 /*****************************************************************************/
801
802 static u8 sn9c102_strtou8(const char* buff, size_t len, ssize_t* count)
803 {
804 char str[5];
805 char* endp;
806 unsigned long val;
807
808 if (len < 4) {
809 strncpy(str, buff, len);
810 str[len+1] = '\0';
811 } else {
812 strncpy(str, buff, 4);
813 str[4] = '\0';
814 }
815
816 val = simple_strtoul(str, &endp, 0);
817
818 *count = 0;
819 if (val <= 0xff)
820 *count = (ssize_t)(endp - str);
821 if ((*count) && (len == *count+1) && (buff[*count] == '\n'))
822 *count += 1;
823
824 return (u8)val;
825 }
826
827 /*
828 NOTE 1: being inside one of the following methods implies that the v4l
829 device exists for sure (see kobjects and reference counters)
830 NOTE 2: buffers are PAGE_SIZE long
831 */
832
833 static ssize_t sn9c102_show_reg(struct class_device* cd, char* buf)
834 {
835 struct sn9c102_device* cam;
836 ssize_t count;
837
838 if (down_interruptible(&sn9c102_sysfs_lock))
839 return -ERESTARTSYS;
840
841 cam = video_get_drvdata(to_video_device(cd));
842 if (!cam) {
843 up(&sn9c102_sysfs_lock);
844 return -ENODEV;
845 }
846
847 count = sprintf(buf, "%u\n", cam->sysfs.reg);
848
849 up(&sn9c102_sysfs_lock);
850
851 return count;
852 }
853
854
855 static ssize_t
856 sn9c102_store_reg(struct class_device* cd, const char* buf, size_t len)
857 {
858 struct sn9c102_device* cam;
859 u8 index;
860 ssize_t count;
861
862 if (down_interruptible(&sn9c102_sysfs_lock))
863 return -ERESTARTSYS;
864
865 cam = video_get_drvdata(to_video_device(cd));
866 if (!cam) {
867 up(&sn9c102_sysfs_lock);
868 return -ENODEV;
869 }
870
871 index = sn9c102_strtou8(buf, len, &count);
872 if (index > 0x1f || !count) {
873 up(&sn9c102_sysfs_lock);
874 return -EINVAL;
875 }
876
877 cam->sysfs.reg = index;
878
879 DBG(2, "Moved SN9C10X register index to 0x%02X", cam->sysfs.reg)
880 DBG(3, "Written bytes: %zd", count)
881
882 up(&sn9c102_sysfs_lock);
883
884 return count;
885 }
886
887
888 static ssize_t sn9c102_show_val(struct class_device* cd, char* buf)
889 {
890 struct sn9c102_device* cam;
891 ssize_t count;
892 int val;
893
894 if (down_interruptible(&sn9c102_sysfs_lock))
895 return -ERESTARTSYS;
896
897 cam = video_get_drvdata(to_video_device(cd));
898 if (!cam) {
899 up(&sn9c102_sysfs_lock);
900 return -ENODEV;
901 }
902
903 if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
904 up(&sn9c102_sysfs_lock);
905 return -EIO;
906 }
907
908 count = sprintf(buf, "%d\n", val);
909
910 DBG(3, "Read bytes: %zd", count)
911
912 up(&sn9c102_sysfs_lock);
913
914 return count;
915 }
916
917
918 static ssize_t
919 sn9c102_store_val(struct class_device* cd, const char* buf, size_t len)
920 {
921 struct sn9c102_device* cam;
922 u8 value;
923 ssize_t count;
924 int err;
925
926 if (down_interruptible(&sn9c102_sysfs_lock))
927 return -ERESTARTSYS;
928
929 cam = video_get_drvdata(to_video_device(cd));
930 if (!cam) {
931 up(&sn9c102_sysfs_lock);
932 return -ENODEV;
933 }
934
935 value = sn9c102_strtou8(buf, len, &count);
936 if (!count) {
937 up(&sn9c102_sysfs_lock);
938 return -EINVAL;
939 }
940
941 err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
942 if (err) {
943 up(&sn9c102_sysfs_lock);
944 return -EIO;
945 }
946
947 DBG(2, "Written SN9C10X reg. 0x%02X, val. 0x%02X",
948 cam->sysfs.reg, value)
949 DBG(3, "Written bytes: %zd", count)
950
951 up(&sn9c102_sysfs_lock);
952
953 return count;
954 }
955
956
957 static ssize_t sn9c102_show_i2c_reg(struct class_device* cd, char* buf)
958 {
959 struct sn9c102_device* cam;
960 ssize_t count;
961
962 if (down_interruptible(&sn9c102_sysfs_lock))
963 return -ERESTARTSYS;
964
965 cam = video_get_drvdata(to_video_device(cd));
966 if (!cam) {
967 up(&sn9c102_sysfs_lock);
968 return -ENODEV;
969 }
970
971 count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
972
973 DBG(3, "Read bytes: %zd", count)
974
975 up(&sn9c102_sysfs_lock);
976
977 return count;
978 }
979
980
981 static ssize_t
982 sn9c102_store_i2c_reg(struct class_device* cd, const char* buf, size_t len)
983 {
984 struct sn9c102_device* cam;
985 u8 index;
986 ssize_t count;
987
988 if (down_interruptible(&sn9c102_sysfs_lock))
989 return -ERESTARTSYS;
990
991 cam = video_get_drvdata(to_video_device(cd));
992 if (!cam) {
993 up(&sn9c102_sysfs_lock);
994 return -ENODEV;
995 }
996
997 index = sn9c102_strtou8(buf, len, &count);
998 if (!count) {
999 up(&sn9c102_sysfs_lock);
1000 return -EINVAL;
1001 }
1002
1003 cam->sysfs.i2c_reg = index;
1004
1005 DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg)
1006 DBG(3, "Written bytes: %zd", count)
1007
1008 up(&sn9c102_sysfs_lock);
1009
1010 return count;
1011 }
1012
1013
1014 static ssize_t sn9c102_show_i2c_val(struct class_device* cd, char* buf)
1015 {
1016 struct sn9c102_device* cam;
1017 ssize_t count;
1018 int val;
1019
1020 if (down_interruptible(&sn9c102_sysfs_lock))
1021 return -ERESTARTSYS;
1022
1023 cam = video_get_drvdata(to_video_device(cd));
1024 if (!cam) {
1025 up(&sn9c102_sysfs_lock);
1026 return -ENODEV;
1027 }
1028
1029 if (!(cam->sensor->sysfs_ops & SN9C102_I2C_READ)) {
1030 up(&sn9c102_sysfs_lock);
1031 return -ENOSYS;
1032 }
1033
1034 if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1035 up(&sn9c102_sysfs_lock);
1036 return -EIO;
1037 }
1038
1039 count = sprintf(buf, "%d\n", val);
1040
1041 DBG(3, "Read bytes: %zd", count)
1042
1043 up(&sn9c102_sysfs_lock);
1044
1045 return count;
1046 }
1047
1048
1049 static ssize_t
1050 sn9c102_store_i2c_val(struct class_device* cd, const char* buf, size_t len)
1051 {
1052 struct sn9c102_device* cam;
1053 u8 value;
1054 ssize_t count;
1055 int err;
1056
1057 if (down_interruptible(&sn9c102_sysfs_lock))
1058 return -ERESTARTSYS;
1059
1060 cam = video_get_drvdata(to_video_device(cd));
1061 if (!cam) {
1062 up(&sn9c102_sysfs_lock);
1063 return -ENODEV;
1064 }
1065
1066 if (!(cam->sensor->sysfs_ops & SN9C102_I2C_WRITE)) {
1067 up(&sn9c102_sysfs_lock);
1068 return -ENOSYS;
1069 }
1070
1071 value = sn9c102_strtou8(buf, len, &count);
1072 if (!count) {
1073 up(&sn9c102_sysfs_lock);
1074 return -EINVAL;
1075 }
1076
1077 err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1078 if (err) {
1079 up(&sn9c102_sysfs_lock);
1080 return -EIO;
1081 }
1082
1083 DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1084 cam->sysfs.i2c_reg, value)
1085 DBG(3, "Written bytes: %zd", count)
1086
1087 up(&sn9c102_sysfs_lock);
1088
1089 return count;
1090 }
1091
1092
1093 static ssize_t
1094 sn9c102_store_green(struct class_device* cd, const char* buf, size_t len)
1095 {
1096 struct sn9c102_device* cam;
1097 enum sn9c102_bridge bridge;
1098 ssize_t res = 0;
1099 u8 value;
1100 ssize_t count;
1101
1102 if (down_interruptible(&sn9c102_sysfs_lock))
1103 return -ERESTARTSYS;
1104
1105 cam = video_get_drvdata(to_video_device(cd));
1106 if (!cam) {
1107 up(&sn9c102_sysfs_lock);
1108 return -ENODEV;
1109 }
1110
1111 bridge = cam->bridge;
1112
1113 up(&sn9c102_sysfs_lock);
1114
1115 value = sn9c102_strtou8(buf, len, &count);
1116 if (!count)
1117 return -EINVAL;
1118
1119 switch (bridge) {
1120 case BRIDGE_SN9C101:
1121 case BRIDGE_SN9C102:
1122 if (value > 0x0f)
1123 return -EINVAL;
1124 if ((res = sn9c102_store_reg(cd, "0x11", 4)) >= 0)
1125 res = sn9c102_store_val(cd, buf, len);
1126 break;
1127 case BRIDGE_SN9C103:
1128 if (value > 0x7f)
1129 return -EINVAL;
1130 if ((res = sn9c102_store_reg(cd, "0x04", 4)) >= 0)
1131 res = sn9c102_store_val(cd, buf, len);
1132 break;
1133 }
1134
1135 return res;
1136 }
1137
1138
1139 static ssize_t
1140 sn9c102_store_blue(struct class_device* cd, const char* buf, size_t len)
1141 {
1142 ssize_t res = 0;
1143 u8 value;
1144 ssize_t count;
1145
1146 value = sn9c102_strtou8(buf, len, &count);
1147 if (!count || value > 0x7f)
1148 return -EINVAL;
1149
1150 if ((res = sn9c102_store_reg(cd, "0x06", 4)) >= 0)
1151 res = sn9c102_store_val(cd, buf, len);
1152
1153 return res;
1154 }
1155
1156
1157 static ssize_t
1158 sn9c102_store_red(struct class_device* cd, const char* buf, size_t len)
1159 {
1160 ssize_t res = 0;
1161 u8 value;
1162 ssize_t count;
1163
1164 value = sn9c102_strtou8(buf, len, &count);
1165 if (!count || value > 0x7f)
1166 return -EINVAL;
1167
1168 if ((res = sn9c102_store_reg(cd, "0x05", 4)) >= 0)
1169 res = sn9c102_store_val(cd, buf, len);
1170
1171 return res;
1172 }
1173
1174
1175 static ssize_t sn9c102_show_frame_header(struct class_device* cd, char* buf)
1176 {
1177 struct sn9c102_device* cam;
1178 ssize_t count;
1179
1180 cam = video_get_drvdata(to_video_device(cd));
1181 if (!cam)
1182 return -ENODEV;
1183
1184 count = sizeof(cam->sysfs.frame_header);
1185 memcpy(buf, cam->sysfs.frame_header, count);
1186
1187 DBG(3, "Frame header, read bytes: %zd", count)
1188
1189 return count;
1190 }
1191
1192
1193 static CLASS_DEVICE_ATTR(reg, S_IRUGO | S_IWUSR,
1194 sn9c102_show_reg, sn9c102_store_reg);
1195 static CLASS_DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
1196 sn9c102_show_val, sn9c102_store_val);
1197 static CLASS_DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
1198 sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
1199 static CLASS_DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
1200 sn9c102_show_i2c_val, sn9c102_store_i2c_val);
1201 static CLASS_DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
1202 static CLASS_DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
1203 static CLASS_DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
1204 static CLASS_DEVICE_ATTR(frame_header, S_IRUGO,
1205 sn9c102_show_frame_header, NULL);
1206
1207
1208 static void sn9c102_create_sysfs(struct sn9c102_device* cam)
1209 {
1210 struct video_device *v4ldev = cam->v4ldev;
1211
1212 video_device_create_file(v4ldev, &class_device_attr_reg);
1213 video_device_create_file(v4ldev, &class_device_attr_val);
1214 video_device_create_file(v4ldev, &class_device_attr_frame_header);
1215 if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
1216 video_device_create_file(v4ldev, &class_device_attr_green);
1217 else if (cam->bridge == BRIDGE_SN9C103) {
1218 video_device_create_file(v4ldev, &class_device_attr_blue);
1219 video_device_create_file(v4ldev, &class_device_attr_red);
1220 }
1221 if (cam->sensor->sysfs_ops) {
1222 video_device_create_file(v4ldev, &class_device_attr_i2c_reg);
1223 video_device_create_file(v4ldev, &class_device_attr_i2c_val);
1224 }
1225 }
1226
1227 /*****************************************************************************/
1228
1229 static int
1230 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
1231 {
1232 int err = 0;
1233
1234 if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X)
1235 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80, 0x18);
1236 else
1237 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f, 0x18);
1238
1239 return err ? -EIO : 0;
1240 }
1241
1242
1243 static int
1244 sn9c102_set_compression(struct sn9c102_device* cam,
1245 struct v4l2_jpegcompression* compression)
1246 {
1247 int err = 0;
1248
1249 if (compression->quality == 0)
1250 err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01, 0x17);
1251 else if (compression->quality == 1)
1252 err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe, 0x17);
1253
1254 return err ? -EIO : 0;
1255 }
1256
1257
1258 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1259 {
1260 u8 r = 0;
1261 int err = 0;
1262
1263 if (scale == 1)
1264 r = cam->reg[0x18] & 0xcf;
1265 else if (scale == 2) {
1266 r = cam->reg[0x18] & 0xcf;
1267 r |= 0x10;
1268 } else if (scale == 4)
1269 r = cam->reg[0x18] | 0x20;
1270
1271 err += sn9c102_write_reg(cam, r, 0x18);
1272 if (err)
1273 return -EIO;
1274
1275 PDBGG("Scaling factor: %u", scale)
1276
1277 return 0;
1278 }
1279
1280
1281 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1282 {
1283 struct sn9c102_sensor* s = cam->sensor;
1284 u8 h_start = (u8)(rect->left - s->cropcap.bounds.left),
1285 v_start = (u8)(rect->top - s->cropcap.bounds.top),
1286 h_size = (u8)(rect->width / 16),
1287 v_size = (u8)(rect->height / 16);
1288 int err = 0;
1289
1290 err += sn9c102_write_reg(cam, h_start, 0x12);
1291 err += sn9c102_write_reg(cam, v_start, 0x13);
1292 err += sn9c102_write_reg(cam, h_size, 0x15);
1293 err += sn9c102_write_reg(cam, v_size, 0x16);
1294 if (err)
1295 return -EIO;
1296
1297 PDBGG("h_start, v_start, h_size, v_size, ho_size, vo_size "
1298 "%u %u %u %u", h_start, v_start, h_size, v_size)
1299
1300 return 0;
1301 }
1302
1303
1304 static int sn9c102_init(struct sn9c102_device* cam)
1305 {
1306 struct sn9c102_sensor* s = cam->sensor;
1307 struct v4l2_control ctrl;
1308 struct v4l2_queryctrl *qctrl;
1309 struct v4l2_rect* rect;
1310 u8 i = 0, n = 0;
1311 int err = 0;
1312
1313 if (!(cam->state & DEV_INITIALIZED)) {
1314 init_waitqueue_head(&cam->open);
1315 qctrl = s->qctrl;
1316 rect = &(s->cropcap.defrect);
1317 } else { /* use current values */
1318 qctrl = s->_qctrl;
1319 rect = &(s->_rect);
1320 }
1321
1322 err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1323 err += sn9c102_set_crop(cam, rect);
1324 if (err)
1325 return err;
1326
1327 if (s->init) {
1328 err = s->init(cam);
1329 if (err) {
1330 DBG(3, "Sensor initialization failed")
1331 return err;
1332 }
1333 }
1334
1335 if (!(cam->state & DEV_INITIALIZED))
1336 cam->compression.quality = cam->reg[0x17] & 0x01 ? 0 : 1;
1337 else
1338 err += sn9c102_set_compression(cam, &cam->compression);
1339 err += sn9c102_set_pix_format(cam, &s->pix_format);
1340 if (s->set_pix_format)
1341 err += s->set_pix_format(cam, &s->pix_format);
1342 if (err)
1343 return err;
1344
1345 if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
1346 DBG(3, "Compressed video format is active, quality %d",
1347 cam->compression.quality)
1348 else
1349 DBG(3, "Uncompressed video format is active")
1350
1351 if (s->set_crop)
1352 if ((err = s->set_crop(cam, rect))) {
1353 DBG(3, "set_crop() failed")
1354 return err;
1355 }
1356
1357 if (s->set_ctrl) {
1358 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1359 for (i = 0; i < n; i++)
1360 if (s->qctrl[i].id != 0 &&
1361 !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
1362 ctrl.id = s->qctrl[i].id;
1363 ctrl.value = qctrl[i].default_value;
1364 err = s->set_ctrl(cam, &ctrl);
1365 if (err) {
1366 DBG(3, "Set %s control failed",
1367 s->qctrl[i].name)
1368 return err;
1369 }
1370 DBG(3, "Image sensor supports '%s' control",
1371 s->qctrl[i].name)
1372 }
1373 }
1374
1375 if (!(cam->state & DEV_INITIALIZED)) {
1376 init_MUTEX(&cam->fileop_sem);
1377 spin_lock_init(&cam->queue_lock);
1378 init_waitqueue_head(&cam->wait_frame);
1379 init_waitqueue_head(&cam->wait_stream);
1380 cam->nreadbuffers = 2;
1381 memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
1382 memcpy(&(s->_rect), &(s->cropcap.defrect),
1383 sizeof(struct v4l2_rect));
1384 cam->state |= DEV_INITIALIZED;
1385 }
1386
1387 DBG(2, "Initialization succeeded")
1388 return 0;
1389 }
1390
1391
1392 static void sn9c102_release_resources(struct sn9c102_device* cam)
1393 {
1394 down(&sn9c102_sysfs_lock);
1395
1396 DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor)
1397 video_set_drvdata(cam->v4ldev, NULL);
1398 video_unregister_device(cam->v4ldev);
1399
1400 up(&sn9c102_sysfs_lock);
1401
1402 kfree(cam->control_buffer);
1403 }
1404
1405 /*****************************************************************************/
1406
1407 static int sn9c102_open(struct inode* inode, struct file* filp)
1408 {
1409 struct sn9c102_device* cam;
1410 int err = 0;
1411
1412 /*
1413 This is the only safe way to prevent race conditions with
1414 disconnect
1415 */
1416 if (!down_read_trylock(&sn9c102_disconnect))
1417 return -ERESTARTSYS;
1418
1419 cam = video_get_drvdata(video_devdata(filp));
1420
1421 if (down_interruptible(&cam->dev_sem)) {
1422 up_read(&sn9c102_disconnect);
1423 return -ERESTARTSYS;
1424 }
1425
1426 if (cam->users) {
1427 DBG(2, "Device /dev/video%d is busy...", cam->v4ldev->minor)
1428 if ((filp->f_flags & O_NONBLOCK) ||
1429 (filp->f_flags & O_NDELAY)) {
1430 err = -EWOULDBLOCK;
1431 goto out;
1432 }
1433 up(&cam->dev_sem);
1434 err = wait_event_interruptible_exclusive(cam->open,
1435 cam->state & DEV_DISCONNECTED
1436 || !cam->users);
1437 if (err) {
1438 up_read(&sn9c102_disconnect);
1439 return err;
1440 }
1441 if (cam->state & DEV_DISCONNECTED) {
1442 up_read(&sn9c102_disconnect);
1443 return -ENODEV;
1444 }
1445 down(&cam->dev_sem);
1446 }
1447
1448
1449 if (cam->state & DEV_MISCONFIGURED) {
1450 err = sn9c102_init(cam);
1451 if (err) {
1452 DBG(1, "Initialization failed again. "
1453 "I will retry on next open().")
1454 goto out;
1455 }
1456 cam->state &= ~DEV_MISCONFIGURED;
1457 }
1458
1459 if ((err = sn9c102_start_transfer(cam)))
1460 goto out;
1461
1462 filp->private_data = cam;
1463 cam->users++;
1464 cam->io = IO_NONE;
1465 cam->stream = STREAM_OFF;
1466 cam->nbuffers = 0;
1467 cam->frame_count = 0;
1468 sn9c102_empty_framequeues(cam);
1469
1470 DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor)
1471
1472 out:
1473 up(&cam->dev_sem);
1474 up_read(&sn9c102_disconnect);
1475 return err;
1476 }
1477
1478
1479 static int sn9c102_release(struct inode* inode, struct file* filp)
1480 {
1481 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1482
1483 down(&cam->dev_sem); /* prevent disconnect() to be called */
1484
1485 sn9c102_stop_transfer(cam);
1486
1487 sn9c102_release_buffers(cam);
1488
1489 if (cam->state & DEV_DISCONNECTED) {
1490 sn9c102_release_resources(cam);
1491 up(&cam->dev_sem);
1492 kfree(cam);
1493 return 0;
1494 }
1495
1496 cam->users--;
1497 wake_up_interruptible_nr(&cam->open, 1);
1498
1499 DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor)
1500
1501 up(&cam->dev_sem);
1502
1503 return 0;
1504 }
1505
1506
1507 static ssize_t
1508 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1509 {
1510 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1511 struct sn9c102_frame_t* f, * i;
1512 unsigned long lock_flags;
1513 int err = 0;
1514
1515 if (down_interruptible(&cam->fileop_sem))
1516 return -ERESTARTSYS;
1517
1518 if (cam->state & DEV_DISCONNECTED) {
1519 DBG(1, "Device not present")
1520 up(&cam->fileop_sem);
1521 return -ENODEV;
1522 }
1523
1524 if (cam->state & DEV_MISCONFIGURED) {
1525 DBG(1, "The camera is misconfigured. Close and open it again.")
1526 up(&cam->fileop_sem);
1527 return -EIO;
1528 }
1529
1530 if (cam->io == IO_MMAP) {
1531 DBG(3, "Close and open the device again to choose "
1532 "the read method")
1533 up(&cam->fileop_sem);
1534 return -EINVAL;
1535 }
1536
1537 if (cam->io == IO_NONE) {
1538 if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
1539 DBG(1, "read() failed, not enough memory")
1540 up(&cam->fileop_sem);
1541 return -ENOMEM;
1542 }
1543 cam->io = IO_READ;
1544 cam->stream = STREAM_ON;
1545 sn9c102_queue_unusedframes(cam);
1546 }
1547
1548 if (!count) {
1549 up(&cam->fileop_sem);
1550 return 0;
1551 }
1552
1553 if (list_empty(&cam->outqueue)) {
1554 if (filp->f_flags & O_NONBLOCK) {
1555 up(&cam->fileop_sem);
1556 return -EAGAIN;
1557 }
1558 err = wait_event_interruptible
1559 ( cam->wait_frame,
1560 (!list_empty(&cam->outqueue)) ||
1561 (cam->state & DEV_DISCONNECTED) );
1562 if (err) {
1563 up(&cam->fileop_sem);
1564 return err;
1565 }
1566 if (cam->state & DEV_DISCONNECTED) {
1567 up(&cam->fileop_sem);
1568 return -ENODEV;
1569 }
1570 }
1571
1572 f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1573
1574 spin_lock_irqsave(&cam->queue_lock, lock_flags);
1575 list_for_each_entry(i, &cam->outqueue, frame)
1576 i->state = F_UNUSED;
1577 INIT_LIST_HEAD(&cam->outqueue);
1578 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1579
1580 sn9c102_queue_unusedframes(cam);
1581
1582 if (count > f->buf.bytesused)
1583 count = f->buf.bytesused;
1584
1585 if (copy_to_user(buf, f->bufmem, count)) {
1586 up(&cam->fileop_sem);
1587 return -EFAULT;
1588 }
1589 *f_pos += count;
1590
1591 PDBGG("Frame #%lu, bytes read: %zu", (unsigned long)f->buf.index,count)
1592
1593 up(&cam->fileop_sem);
1594
1595 return count;
1596 }
1597
1598
1599 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
1600 {
1601 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1602 unsigned int mask = 0;
1603
1604 if (down_interruptible(&cam->fileop_sem))
1605 return POLLERR;
1606
1607 if (cam->state & DEV_DISCONNECTED) {
1608 DBG(1, "Device not present")
1609 goto error;
1610 }
1611
1612 if (cam->state & DEV_MISCONFIGURED) {
1613 DBG(1, "The camera is misconfigured. Close and open it again.")
1614 goto error;
1615 }
1616
1617 if (cam->io == IO_NONE) {
1618 if (!sn9c102_request_buffers(cam, 2, IO_READ)) {
1619 DBG(1, "poll() failed, not enough memory")
1620 goto error;
1621 }
1622 cam->io = IO_READ;
1623 cam->stream = STREAM_ON;
1624 }
1625
1626 if (cam->io == IO_READ)
1627 sn9c102_queue_unusedframes(cam);
1628
1629 poll_wait(filp, &cam->wait_frame, wait);
1630
1631 if (!list_empty(&cam->outqueue))
1632 mask |= POLLIN | POLLRDNORM;
1633
1634 up(&cam->fileop_sem);
1635
1636 return mask;
1637
1638 error:
1639 up(&cam->fileop_sem);
1640 return POLLERR;
1641 }
1642
1643
1644 static void sn9c102_vm_open(struct vm_area_struct* vma)
1645 {
1646 struct sn9c102_frame_t* f = vma->vm_private_data;
1647 f->vma_use_count++;
1648 }
1649
1650
1651 static void sn9c102_vm_close(struct vm_area_struct* vma)
1652 {
1653 /* NOTE: buffers are not freed here */
1654 struct sn9c102_frame_t* f = vma->vm_private_data;
1655 f->vma_use_count--;
1656 }
1657
1658
1659 static struct vm_operations_struct sn9c102_vm_ops = {
1660 .open = sn9c102_vm_open,
1661 .close = sn9c102_vm_close,
1662 };
1663
1664
1665 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
1666 {
1667 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1668 unsigned long size = vma->vm_end - vma->vm_start,
1669 start = vma->vm_start,
1670 pos,
1671 page;
1672 u32 i;
1673
1674 if (down_interruptible(&cam->fileop_sem))
1675 return -ERESTARTSYS;
1676
1677 if (cam->state & DEV_DISCONNECTED) {
1678 DBG(1, "Device not present")
1679 up(&cam->fileop_sem);
1680 return -ENODEV;
1681 }
1682
1683 if (cam->state & DEV_MISCONFIGURED) {
1684 DBG(1, "The camera is misconfigured. Close and open it again.")
1685 up(&cam->fileop_sem);
1686 return -EIO;
1687 }
1688
1689 if (cam->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
1690 size != PAGE_ALIGN(cam->frame[0].buf.length)) {
1691 up(&cam->fileop_sem);
1692 return -EINVAL;
1693 }
1694
1695 for (i = 0; i < cam->nbuffers; i++) {
1696 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
1697 break;
1698 }
1699 if (i == cam->nbuffers) {
1700 up(&cam->fileop_sem);
1701 return -EINVAL;
1702 }
1703
1704 /* VM_IO is eventually going to replace PageReserved altogether */
1705 vma->vm_flags |= VM_IO;
1706 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1707
1708 pos = (unsigned long)cam->frame[i].bufmem;
1709 while (size > 0) { /* size is page-aligned */
1710 page = vmalloc_to_pfn((void *)pos);
1711 if (remap_pfn_range(vma, start, page, PAGE_SIZE,
1712 vma->vm_page_prot)) {
1713 up(&cam->fileop_sem);
1714 return -EAGAIN;
1715 }
1716 start += PAGE_SIZE;
1717 pos += PAGE_SIZE;
1718 size -= PAGE_SIZE;
1719 }
1720
1721 vma->vm_ops = &sn9c102_vm_ops;
1722 vma->vm_private_data = &cam->frame[i];
1723
1724 sn9c102_vm_open(vma);
1725
1726 up(&cam->fileop_sem);
1727
1728 return 0;
1729 }
1730
1731
1732 static int sn9c102_v4l2_ioctl(struct inode* inode, struct file* filp,
1733 unsigned int cmd, void __user * arg)
1734 {
1735 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1736
1737 switch (cmd) {
1738
1739 case VIDIOC_QUERYCAP:
1740 {
1741 struct v4l2_capability cap = {
1742 .driver = "sn9c102",
1743 .version = SN9C102_MODULE_VERSION_CODE,
1744 .capabilities = V4L2_CAP_VIDEO_CAPTURE |
1745 V4L2_CAP_READWRITE |
1746 V4L2_CAP_STREAMING,
1747 };
1748
1749 strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
1750 if (usb_make_path(cam->usbdev, cap.bus_info,
1751 sizeof(cap.bus_info)) < 0)
1752 strlcpy(cap.bus_info, cam->dev.bus_id,
1753 sizeof(cap.bus_info));
1754
1755 if (copy_to_user(arg, &cap, sizeof(cap)))
1756 return -EFAULT;
1757
1758 return 0;
1759 }
1760
1761 case VIDIOC_ENUMINPUT:
1762 {
1763 struct v4l2_input i;
1764
1765 if (copy_from_user(&i, arg, sizeof(i)))
1766 return -EFAULT;
1767
1768 if (i.index)
1769 return -EINVAL;
1770
1771 memset(&i, 0, sizeof(i));
1772 strcpy(i.name, "USB");
1773
1774 if (copy_to_user(arg, &i, sizeof(i)))
1775 return -EFAULT;
1776
1777 return 0;
1778 }
1779
1780 case VIDIOC_G_INPUT:
1781 case VIDIOC_S_INPUT:
1782 {
1783 int index;
1784
1785 if (copy_from_user(&index, arg, sizeof(index)))
1786 return -EFAULT;
1787
1788 if (index != 0)
1789 return -EINVAL;
1790
1791 return 0;
1792 }
1793
1794 case VIDIOC_QUERYCTRL:
1795 {
1796 struct sn9c102_sensor* s = cam->sensor;
1797 struct v4l2_queryctrl qc;
1798 u8 i, n;
1799
1800 if (copy_from_user(&qc, arg, sizeof(qc)))
1801 return -EFAULT;
1802
1803 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1804 for (i = 0; i < n; i++)
1805 if (qc.id && qc.id == s->qctrl[i].id) {
1806 memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
1807 if (copy_to_user(arg, &qc, sizeof(qc)))
1808 return -EFAULT;
1809 return 0;
1810 }
1811
1812 return -EINVAL;
1813 }
1814
1815 case VIDIOC_G_CTRL:
1816 {
1817 struct sn9c102_sensor* s = cam->sensor;
1818 struct v4l2_control ctrl;
1819 int err = 0;
1820
1821 if (!s->get_ctrl)
1822 return -EINVAL;
1823
1824 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1825 return -EFAULT;
1826
1827 err = s->get_ctrl(cam, &ctrl);
1828
1829 if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
1830 return -EFAULT;
1831
1832 return err;
1833 }
1834
1835 case VIDIOC_S_CTRL_OLD:
1836 case VIDIOC_S_CTRL:
1837 {
1838 struct sn9c102_sensor* s = cam->sensor;
1839 struct v4l2_control ctrl;
1840 u8 i, n;
1841 int err = 0;
1842
1843 if (!s->set_ctrl)
1844 return -EINVAL;
1845
1846 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1847 return -EFAULT;
1848
1849 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1850 for (i = 0; i < n; i++)
1851 if (ctrl.id == s->qctrl[i].id) {
1852 if (ctrl.value < s->qctrl[i].minimum ||
1853 ctrl.value > s->qctrl[i].maximum)
1854 return -ERANGE;
1855 ctrl.value -= ctrl.value % s->qctrl[i].step;
1856 break;
1857 }
1858
1859 if ((err = s->set_ctrl(cam, &ctrl)))
1860 return err;
1861
1862 s->_qctrl[i].default_value = ctrl.value;
1863
1864 PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
1865 (unsigned long)ctrl.id, (unsigned long)ctrl.value)
1866
1867 return 0;
1868 }
1869
1870 case VIDIOC_CROPCAP:
1871 {
1872 struct v4l2_cropcap* cc = &(cam->sensor->cropcap);
1873
1874 cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1875 cc->pixelaspect.numerator = 1;
1876 cc->pixelaspect.denominator = 1;
1877
1878 if (copy_to_user(arg, cc, sizeof(*cc)))
1879 return -EFAULT;
1880
1881 return 0;
1882 }
1883
1884 case VIDIOC_G_CROP:
1885 {
1886 struct sn9c102_sensor* s = cam->sensor;
1887 struct v4l2_crop crop = {
1888 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
1889 };
1890
1891 memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
1892
1893 if (copy_to_user(arg, &crop, sizeof(crop)))
1894 return -EFAULT;
1895
1896 return 0;
1897 }
1898
1899 case VIDIOC_S_CROP:
1900 {
1901 struct sn9c102_sensor* s = cam->sensor;
1902 struct v4l2_crop crop;
1903 struct v4l2_rect* rect;
1904 struct v4l2_rect* bounds = &(s->cropcap.bounds);
1905 struct v4l2_pix_format* pix_format = &(s->pix_format);
1906 u8 scale;
1907 const enum sn9c102_stream_state stream = cam->stream;
1908 const u32 nbuffers = cam->nbuffers;
1909 u32 i;
1910 int err = 0;
1911
1912 if (copy_from_user(&crop, arg, sizeof(crop)))
1913 return -EFAULT;
1914
1915 rect = &(crop.c);
1916
1917 if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1918 return -EINVAL;
1919
1920 if (cam->module_param.force_munmap)
1921 for (i = 0; i < cam->nbuffers; i++)
1922 if (cam->frame[i].vma_use_count) {
1923 DBG(3, "VIDIOC_S_CROP failed. "
1924 "Unmap the buffers first.")
1925 return -EINVAL;
1926 }
1927
1928 /* Preserve R,G or B origin */
1929 rect->left = (s->_rect.left & 1L) ?
1930 rect->left | 1L : rect->left & ~1L;
1931 rect->top = (s->_rect.top & 1L) ?
1932 rect->top | 1L : rect->top & ~1L;
1933
1934 if (rect->width < 16)
1935 rect->width = 16;
1936 if (rect->height < 16)
1937 rect->height = 16;
1938 if (rect->width > bounds->width)
1939 rect->width = bounds->width;
1940 if (rect->height > bounds->height)
1941 rect->height = bounds->height;
1942 if (rect->left < bounds->left)
1943 rect->left = bounds->left;
1944 if (rect->top < bounds->top)
1945 rect->top = bounds->top;
1946 if (rect->left + rect->width > bounds->left + bounds->width)
1947 rect->left = bounds->left+bounds->width - rect->width;
1948 if (rect->top + rect->height > bounds->top + bounds->height)
1949 rect->top = bounds->top+bounds->height - rect->height;
1950
1951 rect->width &= ~15L;
1952 rect->height &= ~15L;
1953
1954 if (SN9C102_PRESERVE_IMGSCALE) {
1955 /* Calculate the actual scaling factor */
1956 u32 a, b;
1957 a = rect->width * rect->height;
1958 b = pix_format->width * pix_format->height;
1959 scale = b ? (u8)((a / b) < 4 ? 1 :
1960 ((a / b) < 16 ? 2 : 4)) : 1;
1961 } else
1962 scale = 1;
1963
1964 if (cam->stream == STREAM_ON)
1965 if ((err = sn9c102_stream_interrupt(cam)))
1966 return err;
1967
1968 if (copy_to_user(arg, &crop, sizeof(crop))) {
1969 cam->stream = stream;
1970 return -EFAULT;
1971 }
1972
1973 if (cam->module_param.force_munmap)
1974 sn9c102_release_buffers(cam);
1975
1976 err = sn9c102_set_crop(cam, rect);
1977 if (s->set_crop)
1978 err += s->set_crop(cam, rect);
1979 err += sn9c102_set_scale(cam, scale);
1980
1981 if (err) { /* atomic, no rollback in ioctl() */
1982 cam->state |= DEV_MISCONFIGURED;
1983 DBG(1, "VIDIOC_S_CROP failed because of hardware "
1984 "problems. To use the camera, close and open "
1985 "/dev/video%d again.", cam->v4ldev->minor)
1986 return -EIO;
1987 }
1988
1989 s->pix_format.width = rect->width/scale;
1990 s->pix_format.height = rect->height/scale;
1991 memcpy(&(s->_rect), rect, sizeof(*rect));
1992
1993 if (cam->module_param.force_munmap &&
1994 nbuffers != sn9c102_request_buffers(cam, nbuffers,
1995 cam->io)) {
1996 cam->state |= DEV_MISCONFIGURED;
1997 DBG(1, "VIDIOC_S_CROP failed because of not enough "
1998 "memory. To use the camera, close and open "
1999 "/dev/video%d again.", cam->v4ldev->minor)
2000 return -ENOMEM;
2001 }
2002
2003 cam->stream = stream;
2004
2005 return 0;
2006 }
2007
2008 case VIDIOC_ENUM_FMT:
2009 {
2010 struct v4l2_fmtdesc fmtd;
2011
2012 if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
2013 return -EFAULT;
2014
2015 if (fmtd.index == 0) {
2016 strcpy(fmtd.description, "bayer rgb");
2017 fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
2018 } else if (fmtd.index == 1) {
2019 strcpy(fmtd.description, "compressed");
2020 fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
2021 fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
2022 } else
2023 return -EINVAL;
2024
2025 fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2026 memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
2027
2028 if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
2029 return -EFAULT;
2030
2031 return 0;
2032 }
2033
2034 case VIDIOC_G_FMT:
2035 {
2036 struct v4l2_format format;
2037 struct v4l2_pix_format* pfmt = &(cam->sensor->pix_format);
2038
2039 if (copy_from_user(&format, arg, sizeof(format)))
2040 return -EFAULT;
2041
2042 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2043 return -EINVAL;
2044
2045 pfmt->bytesperline = (pfmt->pixelformat==V4L2_PIX_FMT_SN9C10X)
2046 ? 0 : (pfmt->width * pfmt->priv) / 8;
2047 pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
2048 pfmt->field = V4L2_FIELD_NONE;
2049 memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
2050
2051 if (copy_to_user(arg, &format, sizeof(format)))
2052 return -EFAULT;
2053
2054 return 0;
2055 }
2056
2057 case VIDIOC_TRY_FMT:
2058 case VIDIOC_S_FMT:
2059 {
2060 struct sn9c102_sensor* s = cam->sensor;
2061 struct v4l2_format format;
2062 struct v4l2_pix_format* pix;
2063 struct v4l2_pix_format* pfmt = &(s->pix_format);
2064 struct v4l2_rect* bounds = &(s->cropcap.bounds);
2065 struct v4l2_rect rect;
2066 u8 scale;
2067 const enum sn9c102_stream_state stream = cam->stream;
2068 const u32 nbuffers = cam->nbuffers;
2069 u32 i;
2070 int err = 0;
2071
2072 if (copy_from_user(&format, arg, sizeof(format)))
2073 return -EFAULT;
2074
2075 pix = &(format.fmt.pix);
2076
2077 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2078 return -EINVAL;
2079
2080 memcpy(&rect, &(s->_rect), sizeof(rect));
2081
2082 { /* calculate the actual scaling factor */
2083 u32 a, b;
2084 a = rect.width * rect.height;
2085 b = pix->width * pix->height;
2086 scale = b ? (u8)((a / b) < 4 ? 1 :
2087 ((a / b) < 16 ? 2 : 4)) : 1;
2088 }
2089
2090 rect.width = scale * pix->width;
2091 rect.height = scale * pix->height;
2092
2093 if (rect.width < 16)
2094 rect.width = 16;
2095 if (rect.height < 16)
2096 rect.height = 16;
2097 if (rect.width > bounds->left + bounds->width - rect.left)
2098 rect.width = bounds->left + bounds->width - rect.left;
2099 if (rect.height > bounds->top + bounds->height - rect.top)
2100 rect.height = bounds->top + bounds->height - rect.top;
2101
2102 rect.width &= ~15L;
2103 rect.height &= ~15L;
2104
2105 { /* adjust the scaling factor */
2106 u32 a, b;
2107 a = rect.width * rect.height;
2108 b = pix->width * pix->height;
2109 scale = b ? (u8)((a / b) < 4 ? 1 :
2110 ((a / b) < 16 ? 2 : 4)) : 1;
2111 }
2112
2113 pix->width = rect.width / scale;
2114 pix->height = rect.height / scale;
2115
2116 if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2117 pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2118 pix->pixelformat = pfmt->pixelformat;
2119 pix->priv = pfmt->priv; /* bpp */
2120 pix->colorspace = pfmt->colorspace;
2121 pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X)
2122 ? 0 : (pix->width * pix->priv) / 8;
2123 pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2124 pix->field = V4L2_FIELD_NONE;
2125
2126 if (cmd == VIDIOC_TRY_FMT) {
2127 if (copy_to_user(arg, &format, sizeof(format)))
2128 return -EFAULT;
2129 return 0;
2130 }
2131
2132 if (cam->module_param.force_munmap)
2133 for (i = 0; i < cam->nbuffers; i++)
2134 if (cam->frame[i].vma_use_count) {
2135 DBG(3, "VIDIOC_S_FMT failed. "
2136 "Unmap the buffers first.")
2137 return -EINVAL;
2138 }
2139
2140 if (cam->stream == STREAM_ON)
2141 if ((err = sn9c102_stream_interrupt(cam)))
2142 return err;
2143
2144 if (copy_to_user(arg, &format, sizeof(format))) {
2145 cam->stream = stream;
2146 return -EFAULT;
2147 }
2148
2149 if (cam->module_param.force_munmap)
2150 sn9c102_release_buffers(cam);
2151
2152 err += sn9c102_set_pix_format(cam, pix);
2153 err += sn9c102_set_crop(cam, &rect);
2154 if (s->set_pix_format)
2155 err += s->set_pix_format(cam, pix);
2156 if (s->set_crop)
2157 err += s->set_crop(cam, &rect);
2158 err += sn9c102_set_scale(cam, scale);
2159
2160 if (err) { /* atomic, no rollback in ioctl() */
2161 cam->state |= DEV_MISCONFIGURED;
2162 DBG(1, "VIDIOC_S_FMT failed because of hardware "
2163 "problems. To use the camera, close and open "
2164 "/dev/video%d again.", cam->v4ldev->minor)
2165 return -EIO;
2166 }
2167
2168 memcpy(pfmt, pix, sizeof(*pix));
2169 memcpy(&(s->_rect), &rect, sizeof(rect));
2170
2171 if (cam->module_param.force_munmap &&
2172 nbuffers != sn9c102_request_buffers(cam, nbuffers,
2173 cam->io)) {
2174 cam->state |= DEV_MISCONFIGURED;
2175 DBG(1, "VIDIOC_S_FMT failed because of not enough "
2176 "memory. To use the camera, close and open "
2177 "/dev/video%d again.", cam->v4ldev->minor)
2178 return -ENOMEM;
2179 }
2180
2181 cam->stream = stream;
2182
2183 return 0;
2184 }
2185
2186 case VIDIOC_G_JPEGCOMP:
2187 {
2188 if (copy_to_user(arg, &cam->compression,
2189 sizeof(cam->compression)))
2190 return -EFAULT;
2191
2192 return 0;
2193 }
2194
2195 case VIDIOC_S_JPEGCOMP:
2196 {
2197 struct v4l2_jpegcompression jc;
2198 const enum sn9c102_stream_state stream = cam->stream;
2199 int err = 0;
2200
2201 if (copy_from_user(&jc, arg, sizeof(jc)))
2202 return -EFAULT;
2203
2204 if (jc.quality != 0 && jc.quality != 1)
2205 return -EINVAL;
2206
2207 if (cam->stream == STREAM_ON)
2208 if ((err = sn9c102_stream_interrupt(cam)))
2209 return err;
2210
2211 err += sn9c102_set_compression(cam, &jc);
2212 if (err) { /* atomic, no rollback in ioctl() */
2213 cam->state |= DEV_MISCONFIGURED;
2214 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
2215 "problems. To use the camera, close and open "
2216 "/dev/video%d again.", cam->v4ldev->minor)
2217 return -EIO;
2218 }
2219
2220 cam->compression.quality = jc.quality;
2221
2222 cam->stream = stream;
2223
2224 return 0;
2225 }
2226
2227 case VIDIOC_REQBUFS:
2228 {
2229 struct v4l2_requestbuffers rb;
2230 u32 i;
2231 int err;
2232
2233 if (copy_from_user(&rb, arg, sizeof(rb)))
2234 return -EFAULT;
2235
2236 if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2237 rb.memory != V4L2_MEMORY_MMAP)
2238 return -EINVAL;
2239
2240 if (cam->io == IO_READ) {
2241 DBG(3, "Close and open the device again to choose "
2242 "the mmap I/O method")
2243 return -EINVAL;
2244 }
2245
2246 for (i = 0; i < cam->nbuffers; i++)
2247 if (cam->frame[i].vma_use_count) {
2248 DBG(3, "VIDIOC_REQBUFS failed. "
2249 "Previous buffers are still mapped.")
2250 return -EINVAL;
2251 }
2252
2253 if (cam->stream == STREAM_ON)
2254 if ((err = sn9c102_stream_interrupt(cam)))
2255 return err;
2256
2257 sn9c102_empty_framequeues(cam);
2258
2259 sn9c102_release_buffers(cam);
2260 if (rb.count)
2261 rb.count = sn9c102_request_buffers(cam, rb.count,
2262 IO_MMAP);
2263
2264 if (copy_to_user(arg, &rb, sizeof(rb))) {
2265 sn9c102_release_buffers(cam);
2266 cam->io = IO_NONE;
2267 return -EFAULT;
2268 }
2269
2270 cam->io = rb.count ? IO_MMAP : IO_NONE;
2271
2272 return 0;
2273 }
2274
2275 case VIDIOC_QUERYBUF:
2276 {
2277 struct v4l2_buffer b;
2278
2279 if (copy_from_user(&b, arg, sizeof(b)))
2280 return -EFAULT;
2281
2282 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2283 b.index >= cam->nbuffers || cam->io != IO_MMAP)
2284 return -EINVAL;
2285
2286 memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2287
2288 if (cam->frame[b.index].vma_use_count)
2289 b.flags |= V4L2_BUF_FLAG_MAPPED;
2290
2291 if (cam->frame[b.index].state == F_DONE)
2292 b.flags |= V4L2_BUF_FLAG_DONE;
2293 else if (cam->frame[b.index].state != F_UNUSED)
2294 b.flags |= V4L2_BUF_FLAG_QUEUED;
2295
2296 if (copy_to_user(arg, &b, sizeof(b)))
2297 return -EFAULT;
2298
2299 return 0;
2300 }
2301
2302 case VIDIOC_QBUF:
2303 {
2304 struct v4l2_buffer b;
2305 unsigned long lock_flags;
2306
2307 if (copy_from_user(&b, arg, sizeof(b)))
2308 return -EFAULT;
2309
2310 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2311 b.index >= cam->nbuffers || cam->io != IO_MMAP)
2312 return -EINVAL;
2313
2314 if (cam->frame[b.index].state != F_UNUSED)
2315 return -EINVAL;
2316
2317 cam->frame[b.index].state = F_QUEUED;
2318
2319 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2320 list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2321 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2322
2323 PDBGG("Frame #%lu queued", (unsigned long)b.index)
2324
2325 return 0;
2326 }
2327
2328 case VIDIOC_DQBUF:
2329 {
2330 struct v4l2_buffer b;
2331 struct sn9c102_frame_t *f;
2332 unsigned long lock_flags;
2333 int err = 0;
2334
2335 if (copy_from_user(&b, arg, sizeof(b)))
2336 return -EFAULT;
2337
2338 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io!= IO_MMAP)
2339 return -EINVAL;
2340
2341 if (list_empty(&cam->outqueue)) {
2342 if (cam->stream == STREAM_OFF)
2343 return -EINVAL;
2344 if (filp->f_flags & O_NONBLOCK)
2345 return -EAGAIN;
2346 err = wait_event_interruptible
2347 ( cam->wait_frame,
2348 (!list_empty(&cam->outqueue)) ||
2349 (cam->state & DEV_DISCONNECTED) );
2350 if (err)
2351 return err;
2352 if (cam->state & DEV_DISCONNECTED)
2353 return -ENODEV;
2354 }
2355
2356 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2357 f = list_entry(cam->outqueue.next, struct sn9c102_frame_t,
2358 frame);
2359 list_del(cam->outqueue.next);
2360 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2361
2362 f->state = F_UNUSED;
2363
2364 memcpy(&b, &f->buf, sizeof(b));
2365 if (f->vma_use_count)
2366 b.flags |= V4L2_BUF_FLAG_MAPPED;
2367
2368 if (copy_to_user(arg, &b, sizeof(b)))
2369 return -EFAULT;
2370
2371 PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index)
2372
2373 return 0;
2374 }
2375
2376 case VIDIOC_STREAMON:
2377 {
2378 int type;
2379
2380 if (copy_from_user(&type, arg, sizeof(type)))
2381 return -EFAULT;
2382
2383 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2384 return -EINVAL;
2385
2386 if (list_empty(&cam->inqueue))
2387 return -EINVAL;
2388
2389 cam->stream = STREAM_ON;
2390
2391 DBG(3, "Stream on")
2392
2393 return 0;
2394 }
2395
2396 case VIDIOC_STREAMOFF:
2397 {
2398 int type, err;
2399
2400 if (copy_from_user(&type, arg, sizeof(type)))
2401 return -EFAULT;
2402
2403 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2404 return -EINVAL;
2405
2406 if (cam->stream == STREAM_ON)
2407 if ((err = sn9c102_stream_interrupt(cam)))
2408 return err;
2409
2410 sn9c102_empty_framequeues(cam);
2411
2412 DBG(3, "Stream off")
2413
2414 return 0;
2415 }
2416
2417 case VIDIOC_G_PARM:
2418 {
2419 struct v4l2_streamparm sp;
2420
2421 if (copy_from_user(&sp, arg, sizeof(sp)))
2422 return -EFAULT;
2423
2424 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2425 return -EINVAL;
2426
2427 sp.parm.capture.extendedmode = 0;
2428 sp.parm.capture.readbuffers = cam->nreadbuffers;
2429
2430 if (copy_to_user(arg, &sp, sizeof(sp)))
2431 return -EFAULT;
2432
2433 return 0;
2434 }
2435
2436 case VIDIOC_S_PARM_OLD:
2437 case VIDIOC_S_PARM:
2438 {
2439 struct v4l2_streamparm sp;
2440
2441 if (copy_from_user(&sp, arg, sizeof(sp)))
2442 return -EFAULT;
2443
2444 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2445 return -EINVAL;
2446
2447 sp.parm.capture.extendedmode = 0;
2448
2449 if (sp.parm.capture.readbuffers == 0)
2450 sp.parm.capture.readbuffers = cam->nreadbuffers;
2451
2452 if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
2453 sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
2454
2455 if (copy_to_user(arg, &sp, sizeof(sp)))
2456 return -EFAULT;
2457
2458 cam->nreadbuffers = sp.parm.capture.readbuffers;
2459
2460 return 0;
2461 }
2462
2463 case VIDIOC_G_STD:
2464 case VIDIOC_S_STD:
2465 case VIDIOC_QUERYSTD:
2466 case VIDIOC_ENUMSTD:
2467 case VIDIOC_QUERYMENU:
2468 return -EINVAL;
2469
2470 default:
2471 return -EINVAL;
2472
2473 }
2474 }
2475
2476
2477 static int sn9c102_ioctl(struct inode* inode, struct file* filp,
2478 unsigned int cmd, unsigned long arg)
2479 {
2480 struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
2481 int err = 0;
2482
2483 if (down_interruptible(&cam->fileop_sem))
2484 return -ERESTARTSYS;
2485
2486 if (cam->state & DEV_DISCONNECTED) {
2487 DBG(1, "Device not present")
2488 up(&cam->fileop_sem);
2489 return -ENODEV;
2490 }
2491
2492 if (cam->state & DEV_MISCONFIGURED) {
2493 DBG(1, "The camera is misconfigured. Close and open it again.")
2494 up(&cam->fileop_sem);
2495 return -EIO;
2496 }
2497
2498 err = sn9c102_v4l2_ioctl(inode, filp, cmd, (void __user *)arg);
2499
2500 up(&cam->fileop_sem);
2501
2502 return err;
2503 }
2504
2505
2506 static struct file_operations sn9c102_fops = {
2507 .owner = THIS_MODULE,
2508 .open = sn9c102_open,
2509 .release = sn9c102_release,
2510 .ioctl = sn9c102_ioctl,
2511 .read = sn9c102_read,
2512 .poll = sn9c102_poll,
2513 .mmap = sn9c102_mmap,
2514 .llseek = no_llseek,
2515 };
2516
2517 /*****************************************************************************/
2518
2519 /* It exists a single interface only. We do not need to validate anything. */
2520 static int
2521 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
2522 {
2523 struct usb_device *udev = interface_to_usbdev(intf);
2524 struct sn9c102_device* cam;
2525 static unsigned int dev_nr = 0;
2526 unsigned int i, n;
2527 int err = 0, r;
2528
2529 n = sizeof(sn9c102_id_table)/sizeof(sn9c102_id_table[0]);
2530 for (i = 0; i < n-1; i++)
2531 if (le16_to_cpu(udev->descriptor.idVendor) ==
2532 sn9c102_id_table[i].idVendor &&
2533 le16_to_cpu(udev->descriptor.idProduct) ==
2534 sn9c102_id_table[i].idProduct)
2535 break;
2536 if (i == n-1)
2537 return -ENODEV;
2538
2539 if (!(cam = kmalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
2540 return -ENOMEM;
2541 memset(cam, 0, sizeof(*cam));
2542
2543 cam->usbdev = udev;
2544
2545 memcpy(&cam->dev, &udev->dev, sizeof(struct device));
2546
2547 if (!(cam->control_buffer = kmalloc(8, GFP_KERNEL))) {
2548 DBG(1, "kmalloc() failed")
2549 err = -ENOMEM;
2550 goto fail;
2551 }
2552 memset(cam->control_buffer, 0, 8);
2553
2554 if (!(cam->v4ldev = video_device_alloc())) {
2555 DBG(1, "video_device_alloc() failed")
2556 err = -ENOMEM;
2557 goto fail;
2558 }
2559
2560 init_MUTEX(&cam->dev_sem);
2561
2562 r = sn9c102_read_reg(cam, 0x00);
2563 if (r < 0 || r != 0x10) {
2564 DBG(1, "Sorry, this is not a SN9C10x based camera "
2565 "(vid/pid 0x%04X/0x%04X)",
2566 sn9c102_id_table[i].idVendor,sn9c102_id_table[i].idProduct)
2567 err = -ENODEV;
2568 goto fail;
2569 }
2570
2571 cam->bridge = (sn9c102_id_table[i].idProduct & 0xffc0) == 0x6080 ?
2572 BRIDGE_SN9C103 : BRIDGE_SN9C102;
2573 switch (cam->bridge) {
2574 case BRIDGE_SN9C101:
2575 case BRIDGE_SN9C102:
2576 DBG(2, "SN9C10[12] PC Camera Controller detected "
2577 "(vid/pid 0x%04X/0x%04X)", sn9c102_id_table[i].idVendor,
2578 sn9c102_id_table[i].idProduct)
2579 break;
2580 case BRIDGE_SN9C103:
2581 DBG(2, "SN9C103 PC Camera Controller detected "
2582 "(vid/pid 0x%04X/0x%04X)", sn9c102_id_table[i].idVendor,
2583 sn9c102_id_table[i].idProduct)
2584 break;
2585 }
2586
2587 for (i = 0; sn9c102_sensor_table[i]; i++) {
2588 err = sn9c102_sensor_table[i](cam);
2589 if (!err)
2590 break;
2591 }
2592
2593 if (!err && cam->sensor) {
2594 DBG(2, "%s image sensor detected", cam->sensor->name)
2595 DBG(3, "Support for %s maintained by %s",
2596 cam->sensor->name, cam->sensor->maintainer)
2597 } else {
2598 DBG(1, "No supported image sensor detected")
2599 err = -ENODEV;
2600 goto fail;
2601 }
2602
2603 if (sn9c102_init(cam)) {
2604 DBG(1, "Initialization failed. I will retry on open().")
2605 cam->state |= DEV_MISCONFIGURED;
2606 }
2607
2608 strcpy(cam->v4ldev->name, "SN9C10x PC Camera");
2609 cam->v4ldev->owner = THIS_MODULE;
2610 cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
2611 cam->v4ldev->hardware = VID_HARDWARE_SN9C102;
2612 cam->v4ldev->fops = &sn9c102_fops;
2613 cam->v4ldev->minor = video_nr[dev_nr];
2614 cam->v4ldev->release = video_device_release;
2615 video_set_drvdata(cam->v4ldev, cam);
2616
2617 down(&cam->dev_sem);
2618
2619 err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
2620 video_nr[dev_nr]);
2621 if (err) {
2622 DBG(1, "V4L2 device registration failed")
2623 if (err == -ENFILE && video_nr[dev_nr] == -1)
2624 DBG(1, "Free /dev/videoX node not found")
2625 video_nr[dev_nr] = -1;
2626 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
2627 up(&cam->dev_sem);
2628 goto fail;
2629 }
2630
2631 DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor)
2632
2633 cam->module_param.force_munmap = force_munmap[dev_nr];
2634
2635 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
2636
2637 sn9c102_create_sysfs(cam);
2638 DBG(2, "Optional device control through 'sysfs' interface ready")
2639
2640 usb_set_intfdata(intf, cam);
2641
2642 up(&cam->dev_sem);
2643
2644 return 0;
2645
2646 fail:
2647 if (cam) {
2648 kfree(cam->control_buffer);
2649 if (cam->v4ldev)
2650 video_device_release(cam->v4ldev);
2651 kfree(cam);
2652 }
2653 return err;
2654 }
2655
2656
2657 static void sn9c102_usb_disconnect(struct usb_interface* intf)
2658 {
2659 struct sn9c102_device* cam = usb_get_intfdata(intf);
2660
2661 if (!cam)
2662 return;
2663
2664 down_write(&sn9c102_disconnect);
2665
2666 down(&cam->dev_sem);
2667
2668 DBG(2, "Disconnecting %s...", cam->v4ldev->name)
2669
2670 wake_up_interruptible_all(&cam->open);
2671
2672 if (cam->users) {
2673 DBG(2, "Device /dev/video%d is open! Deregistration and "
2674 "memory deallocation are deferred on close.",
2675 cam->v4ldev->minor)
2676 cam->state |= DEV_MISCONFIGURED;
2677 sn9c102_stop_transfer(cam);
2678 cam->state |= DEV_DISCONNECTED;
2679 wake_up_interruptible(&cam->wait_frame);
2680 wake_up_interruptible(&cam->wait_stream);
2681 } else {
2682 cam->state |= DEV_DISCONNECTED;
2683 sn9c102_release_resources(cam);
2684 }
2685
2686 up(&cam->dev_sem);
2687
2688 if (!cam->users)
2689 kfree(cam);
2690
2691 up_write(&sn9c102_disconnect);
2692 }
2693
2694
2695 static struct usb_driver sn9c102_usb_driver = {
2696 .owner = THIS_MODULE,
2697 .name = "sn9c102",
2698 .id_table = sn9c102_id_table,
2699 .probe = sn9c102_usb_probe,
2700 .disconnect = sn9c102_usb_disconnect,
2701 };
2702
2703 /*****************************************************************************/
2704
2705 static int __init sn9c102_module_init(void)
2706 {
2707 int err = 0;
2708
2709 KDBG(2, SN9C102_MODULE_NAME " v" SN9C102_MODULE_VERSION)
2710 KDBG(3, SN9C102_MODULE_AUTHOR)
2711
2712 if ((err = usb_register(&sn9c102_usb_driver)))
2713 KDBG(1, "usb_register() failed")
2714
2715 return err;
2716 }
2717
2718
2719 static void __exit sn9c102_module_exit(void)
2720 {
2721 usb_deregister(&sn9c102_usb_driver);
2722 }
2723
2724
2725 module_init(sn9c102_module_init);
2726 module_exit(sn9c102_module_exit);
2727
|
This page was automatically generated by the
LXR engine.
|