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