?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tools: Don't clone maps from parent when synthesizing forks
[linux/fpc-iii.git] / drivers / media / usb / stkwebcam / stk-webcam.c
blob5accb52410720196b24181e18ee0620e68dbc223
1 /*
2 * stk-webcam.c : Driver for Syntek 1125 USB webcam controller
3 *
4 * Copyright (C) 2006 Nicolas VIVIEN
5 * Copyright 2007-2008 Jaime Velasco Juan <jsagarribay@gmail.com>
6 *
7 * Some parts are inspired from cafe_ccic.c
8 * Copyright 2006-2007 Jonathan Corbet
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 */
20
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/kernel.h>
26 #include <linux/errno.h>
27 #include <linux/slab.h>
28
29 #include <linux/dmi.h>
30 #include <linux/usb.h>
31 #include <linux/mm.h>
32 #include <linux/vmalloc.h>
33 #include <linux/videodev2.h>
34 #include <media/v4l2-common.h>
35 #include <media/v4l2-ioctl.h>
36 #include <media/v4l2-event.h>
37
38 #include "stk-webcam.h"
39
40
41 static int hflip = -1;
42 module_param(hflip, int, 0444);
43 MODULE_PARM_DESC(hflip, "Horizontal image flip (mirror). Defaults to 0");
44
45 static int vflip = -1;
46 module_param(vflip, int, 0444);
47 MODULE_PARM_DESC(vflip, "Vertical image flip. Defaults to 0");
48
49 static int debug;
50 module_param(debug, int, 0444);
51 MODULE_PARM_DESC(debug, "Debug v4l ioctls. Defaults to 0");
52
53 MODULE_LICENSE("GPL");
54 MODULE_AUTHOR("Jaime Velasco Juan <jsagarribay@gmail.com> and Nicolas VIVIEN");
55 MODULE_DESCRIPTION("Syntek DC1125 webcam driver");
56
57 /* Some cameras have audio interfaces, we aren't interested in those */
58 static const struct usb_device_id stkwebcam_table[] = {
59 { USB_DEVICE_AND_INTERFACE_INFO(0x174f, 0xa311, 0xff, 0xff, 0xff) },
60 { USB_DEVICE_AND_INTERFACE_INFO(0x05e1, 0x0501, 0xff, 0xff, 0xff) },
61 { }
62 };
63 MODULE_DEVICE_TABLE(usb, stkwebcam_table);
64
65 /*
66 * The stk webcam laptop module is mounted upside down in some laptops :(
67 *
68 * Some background information (thanks to Hans de Goede for providing this):
69 *
70 * 1) Once upon a time the stkwebcam driver was written
71 *
72 * 2) The webcam in question was used mostly in Asus laptop models, including
73 * the laptop of the original author of the driver, and in these models, in
74 * typical Asus fashion (see the long long list for uvc cams inside v4l-utils),
75 * they mounted the webcam-module the wrong way up. So the hflip and vflip
76 * module options were given a default value of 1 (the correct value for
77 * upside down mounted models)
78 *
79 * 3) Years later I got a bug report from a user with a laptop with stkwebcam,
80 * where the module was actually mounted the right way up, and thus showed
81 * upside down under Linux. So now I was facing the choice of 2 options:
82 *
83 * a) Add a not-upside-down list to stkwebcam, which overrules the default.
84 *
85 * b) Do it like all the other drivers do, and make the default right for
86 * cams mounted the proper way and add an upside-down model list, with
87 * models where we need to flip-by-default.
88 *
89 * Despite knowing that going b) would cause a period of pain where we were
90 * building the table I opted to go for option b), since a) is just too ugly,
91 * and worse different from how every other driver does it leading to
92 * confusion in the long run. This change was made in kernel 3.6.
93 *
94 * So for any user report about upside-down images since kernel 3.6 ask them
95 * to provide the output of 'sudo dmidecode' so the laptop can be added in
96 * the table below.
97 */
98 static const struct dmi_system_id stk_upside_down_dmi_table[] = {
99 {
100 .ident = "ASUS G1",
101 .matches = {
102 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
103 DMI_MATCH(DMI_PRODUCT_NAME, "G1")
104 }
105 }, {
106 .ident = "ASUS F3JC",
107 .matches = {
108 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
109 DMI_MATCH(DMI_PRODUCT_NAME, "F3JC")
110 }
111 },
112 {
113 .ident = "T12Rg-H",
114 .matches = {
115 DMI_MATCH(DMI_SYS_VENDOR, "HCL Infosystems Limited"),
116 DMI_MATCH(DMI_PRODUCT_NAME, "T12Rg-H")
117 }
118 },
119 {}
120 };
121
122
123 /*
124 * Basic stuff
125 */
126 int stk_camera_write_reg(struct stk_camera *dev, u16 index, u8 value)
127 {
128 struct usb_device *udev = dev->udev;
129 int ret;
130
131 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
132 0x01,
133 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
134 value,
135 index,
136 NULL,
137 0,
138 500);
139 if (ret < 0)
140 return ret;
141 else
142 return 0;
143 }
144
145 int stk_camera_read_reg(struct stk_camera *dev, u16 index, u8 *value)
146 {
147 struct usb_device *udev = dev->udev;
148 unsigned char *buf;
149 int ret;
150
151 buf = kmalloc(sizeof(u8), GFP_KERNEL);
152 if (!buf)
153 return -ENOMEM;
154
155 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
156 0x00,
157 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
158 0x00,
159 index,
160 buf,
161 sizeof(u8),
162 500);
163 if (ret >= 0)
164 *value = *buf;
165
166 kfree(buf);
167 return ret;
168 }
169
170 static int stk_start_stream(struct stk_camera *dev)
171 {
172 u8 value;
173 int i, ret;
174 u8 value_116, value_117;
175
176
177 if (!is_present(dev))
178 return -ENODEV;
179 if (!is_memallocd(dev) || !is_initialised(dev)) {
180 pr_err("FIXME: Buffers are not allocated\n");
181 return -EFAULT;
182 }
183 ret = usb_set_interface(dev->udev, 0, 5);
184
185 if (ret < 0)
186 pr_err("usb_set_interface failed !\n");
187 if (stk_sensor_wakeup(dev))
188 pr_err("error awaking the sensor\n");
189
190 stk_camera_read_reg(dev, 0x0116, &value_116);
191 stk_camera_read_reg(dev, 0x0117, &value_117);
192
193 stk_camera_write_reg(dev, 0x0116, 0x0000);
194 stk_camera_write_reg(dev, 0x0117, 0x0000);
195
196 stk_camera_read_reg(dev, 0x0100, &value);
197 stk_camera_write_reg(dev, 0x0100, value | 0x80);
198
199 stk_camera_write_reg(dev, 0x0116, value_116);
200 stk_camera_write_reg(dev, 0x0117, value_117);
201 for (i = 0; i < MAX_ISO_BUFS; i++) {
202 if (dev->isobufs[i].urb) {
203 ret = usb_submit_urb(dev->isobufs[i].urb, GFP_KERNEL);
204 atomic_inc(&dev->urbs_used);
205 if (ret)
206 return ret;
207 }
208 }
209 set_streaming(dev);
210 return 0;
211 }
212
213 static int stk_stop_stream(struct stk_camera *dev)
214 {
215 u8 value;
216 int i;
217 if (is_present(dev)) {
218 stk_camera_read_reg(dev, 0x0100, &value);
219 stk_camera_write_reg(dev, 0x0100, value & ~0x80);
220 if (dev->isobufs != NULL) {
221 for (i = 0; i < MAX_ISO_BUFS; i++) {
222 if (dev->isobufs[i].urb)
223 usb_kill_urb(dev->isobufs[i].urb);
224 }
225 }
226 unset_streaming(dev);
227
228 if (usb_set_interface(dev->udev, 0, 0))
229 pr_err("usb_set_interface failed !\n");
230 if (stk_sensor_sleep(dev))
231 pr_err("error suspending the sensor\n");
232 }
233 return 0;
234 }
235
236 /*
237 * This seems to be the shortest init sequence we
238 * must do in order to find the sensor
239 * Bit 5 of reg. 0x0000 here is important, when reset to 0 the sensor
240 * is also reset. Maybe powers down it?
241 * Rest of values don't make a difference
242 */
243
244 static struct regval stk1125_initvals[] = {
245 /*TODO: What means this sequence? */
246 {0x0000, 0x24},
247 {0x0100, 0x21},
248 {0x0002, 0x68},
249 {0x0003, 0x80},
250 {0x0005, 0x00},
251 {0x0007, 0x03},
252 {0x000d, 0x00},
253 {0x000f, 0x02},
254 {0x0300, 0x12},
255 {0x0350, 0x41},
256 {0x0351, 0x00},
257 {0x0352, 0x00},
258 {0x0353, 0x00},
259 {0x0018, 0x10},
260 {0x0019, 0x00},
261 {0x001b, 0x0e},
262 {0x001c, 0x46},
263 {0x0300, 0x80},
264 {0x001a, 0x04},
265 {0x0110, 0x00},
266 {0x0111, 0x00},
267 {0x0112, 0x00},
268 {0x0113, 0x00},
269
270 {0xffff, 0xff},
271 };
272
273
274 static int stk_initialise(struct stk_camera *dev)
275 {
276 struct regval *rv;
277 int ret;
278 if (!is_present(dev))
279 return -ENODEV;
280 if (is_initialised(dev))
281 return 0;
282 rv = stk1125_initvals;
283 while (rv->reg != 0xffff) {
284 ret = stk_camera_write_reg(dev, rv->reg, rv->val);
285 if (ret)
286 return ret;
287 rv++;
288 }
289 if (stk_sensor_init(dev) == 0) {
290 set_initialised(dev);
291 return 0;
292 } else
293 return -1;
294 }
295
296 /* *********************************************** */
297 /*
298 * This function is called as an URB transfert is complete (Isochronous pipe).
299 * So, the traitement is done in interrupt time, so it has be fast, not crash,
300 * and not stall. Neat.
301 */
302 static void stk_isoc_handler(struct urb *urb)
303 {
304 int i;
305 int ret;
306 int framelen;
307 unsigned long flags;
308
309 unsigned char *fill = NULL;
310 unsigned char *iso_buf = NULL;
311
312 struct stk_camera *dev;
313 struct stk_sio_buffer *fb;
314
315 dev = (struct stk_camera *) urb->context;
316
317 if (dev == NULL) {
318 pr_err("isoc_handler called with NULL device !\n");
319 return;
320 }
321
322 if (urb->status == -ENOENT || urb->status == -ECONNRESET
323 || urb->status == -ESHUTDOWN) {
324 atomic_dec(&dev->urbs_used);
325 return;
326 }
327
328 spin_lock_irqsave(&dev->spinlock, flags);
329
330 if (urb->status != -EINPROGRESS && urb->status != 0) {
331 pr_err("isoc_handler: urb->status == %d\n", urb->status);
332 goto resubmit;
333 }
334
335 if (list_empty(&dev->sio_avail)) {
336 /*FIXME Stop streaming after a while */
337 pr_err_ratelimited("isoc_handler without available buffer!\n");
338 goto resubmit;
339 }
340 fb = list_first_entry(&dev->sio_avail,
341 struct stk_sio_buffer, list);
342 fill = fb->buffer + fb->v4lbuf.bytesused;
343
344 for (i = 0; i < urb->number_of_packets; i++) {
345 if (urb->iso_frame_desc[i].status != 0) {
346 if (urb->iso_frame_desc[i].status != -EXDEV)
347 pr_err("Frame %d has error %d\n",
348 i, urb->iso_frame_desc[i].status);
349 continue;
350 }
351 framelen = urb->iso_frame_desc[i].actual_length;
352 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
353
354 if (framelen <= 4)
355 continue; /* no data */
356
357 /*
358 * we found something informational from there
359 * the isoc frames have to type of headers
360 * type1: 00 xx 00 00 or 20 xx 00 00
361 * type2: 80 xx 00 00 00 00 00 00 or a0 xx 00 00 00 00 00 00
362 * xx is a sequencer which has never been seen over 0x3f
363 * imho data written down looks like bayer, i see similarities
364 * after every 640 bytes
365 */
366 if (*iso_buf & 0x80) {
367 framelen -= 8;
368 iso_buf += 8;
369 /* This marks a new frame */
370 if (fb->v4lbuf.bytesused != 0
371 && fb->v4lbuf.bytesused != dev->frame_size) {
372 pr_err_ratelimited("frame %d, bytesused=%d, skipping\n",
373 i, fb->v4lbuf.bytesused);
374 fb->v4lbuf.bytesused = 0;
375 fill = fb->buffer;
376 } else if (fb->v4lbuf.bytesused == dev->frame_size) {
377 if (list_is_singular(&dev->sio_avail)) {
378 /* Always reuse the last buffer */
379 fb->v4lbuf.bytesused = 0;
380 fill = fb->buffer;
381 } else {
382 list_move_tail(dev->sio_avail.next,
383 &dev->sio_full);
384 wake_up(&dev->wait_frame);
385 fb = list_first_entry(&dev->sio_avail,
386 struct stk_sio_buffer, list);
387 fb->v4lbuf.bytesused = 0;
388 fill = fb->buffer;
389 }
390 }
391 } else {
392 framelen -= 4;
393 iso_buf += 4;
394 }
395
396 /* Our buffer is full !!! */
397 if (framelen + fb->v4lbuf.bytesused > dev->frame_size) {
398 pr_err_ratelimited("Frame buffer overflow, lost sync\n");
399 /*FIXME Do something here? */
400 continue;
401 }
402 spin_unlock_irqrestore(&dev->spinlock, flags);
403 memcpy(fill, iso_buf, framelen);
404 spin_lock_irqsave(&dev->spinlock, flags);
405 fill += framelen;
406
407 /* New size of our buffer */
408 fb->v4lbuf.bytesused += framelen;
409 }
410
411 resubmit:
412 spin_unlock_irqrestore(&dev->spinlock, flags);
413 urb->dev = dev->udev;
414 ret = usb_submit_urb(urb, GFP_ATOMIC);
415 if (ret != 0) {
416 pr_err("Error (%d) re-submitting urb in stk_isoc_handler\n",
417 ret);
418 }
419 }
420
421 /* -------------------------------------------- */
422
423 static int stk_prepare_iso(struct stk_camera *dev)
424 {
425 void *kbuf;
426 int i, j;
427 struct urb *urb;
428 struct usb_device *udev;
429
430 if (dev == NULL)
431 return -ENXIO;
432 udev = dev->udev;
433
434 if (dev->isobufs)
435 pr_err("isobufs already allocated. Bad\n");
436 else
437 dev->isobufs = kcalloc(MAX_ISO_BUFS, sizeof(*dev->isobufs),
438 GFP_KERNEL);
439 if (dev->isobufs == NULL) {
440 pr_err("Unable to allocate iso buffers\n");
441 return -ENOMEM;
442 }
443 for (i = 0; i < MAX_ISO_BUFS; i++) {
444 if (dev->isobufs[i].data == NULL) {
445 kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
446 if (kbuf == NULL) {
447 pr_err("Failed to allocate iso buffer %d\n", i);
448 goto isobufs_out;
449 }
450 dev->isobufs[i].data = kbuf;
451 } else
452 pr_err("isobuf data already allocated\n");
453 if (dev->isobufs[i].urb == NULL) {
454 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
455 if (urb == NULL)
456 goto isobufs_out;
457 dev->isobufs[i].urb = urb;
458 } else {
459 pr_err("Killing URB\n");
460 usb_kill_urb(dev->isobufs[i].urb);
461 urb = dev->isobufs[i].urb;
462 }
463 urb->interval = 1;
464 urb->dev = udev;
465 urb->pipe = usb_rcvisocpipe(udev, dev->isoc_ep);
466 urb->transfer_flags = URB_ISO_ASAP;
467 urb->transfer_buffer = dev->isobufs[i].data;
468 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
469 urb->complete = stk_isoc_handler;
470 urb->context = dev;
471 urb->start_frame = 0;
472 urb->number_of_packets = ISO_FRAMES_PER_DESC;
473
474 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
475 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
476 urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
477 }
478 }
479 set_memallocd(dev);
480 return 0;
481
482 isobufs_out:
483 for (i = 0; i < MAX_ISO_BUFS && dev->isobufs[i].data; i++)
484 kfree(dev->isobufs[i].data);
485 for (i = 0; i < MAX_ISO_BUFS && dev->isobufs[i].urb; i++)
486 usb_free_urb(dev->isobufs[i].urb);
487 kfree(dev->isobufs);
488 dev->isobufs = NULL;
489 return -ENOMEM;
490 }
491
492 static void stk_clean_iso(struct stk_camera *dev)
493 {
494 int i;
495
496 if (dev == NULL || dev->isobufs == NULL)
497 return;
498
499 for (i = 0; i < MAX_ISO_BUFS; i++) {
500 struct urb *urb;
501
502 urb = dev->isobufs[i].urb;
503 if (urb) {
504 if (atomic_read(&dev->urbs_used) && is_present(dev))
505 usb_kill_urb(urb);
506 usb_free_urb(urb);
507 }
508 kfree(dev->isobufs[i].data);
509 }
510 kfree(dev->isobufs);
511 dev->isobufs = NULL;
512 unset_memallocd(dev);
513 }
514
515 static int stk_setup_siobuf(struct stk_camera *dev, int index)
516 {
517 struct stk_sio_buffer *buf = dev->sio_bufs + index;
518 INIT_LIST_HEAD(&buf->list);
519 buf->v4lbuf.length = PAGE_ALIGN(dev->frame_size);
520 buf->buffer = vmalloc_user(buf->v4lbuf.length);
521 if (buf->buffer == NULL)
522 return -ENOMEM;
523 buf->mapcount = 0;
524 buf->dev = dev;
525 buf->v4lbuf.index = index;
526 buf->v4lbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
527 buf->v4lbuf.flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
528 buf->v4lbuf.field = V4L2_FIELD_NONE;
529 buf->v4lbuf.memory = V4L2_MEMORY_MMAP;
530 buf->v4lbuf.m.offset = 2*index*buf->v4lbuf.length;
531 return 0;
532 }
533
534 static int stk_free_sio_buffers(struct stk_camera *dev)
535 {
536 int i;
537 int nbufs;
538 unsigned long flags;
539 if (dev->n_sbufs == 0 || dev->sio_bufs == NULL)
540 return 0;
541 /*
542 * If any buffers are mapped, we cannot free them at all.
543 */
544 for (i = 0; i < dev->n_sbufs; i++) {
545 if (dev->sio_bufs[i].mapcount > 0)
546 return -EBUSY;
547 }
548 /*
549 * OK, let's do it.
550 */
551 spin_lock_irqsave(&dev->spinlock, flags);
552 INIT_LIST_HEAD(&dev->sio_avail);
553 INIT_LIST_HEAD(&dev->sio_full);
554 nbufs = dev->n_sbufs;
555 dev->n_sbufs = 0;
556 spin_unlock_irqrestore(&dev->spinlock, flags);
557 for (i = 0; i < nbufs; i++)
558 vfree(dev->sio_bufs[i].buffer);
559 kfree(dev->sio_bufs);
560 dev->sio_bufs = NULL;
561 return 0;
562 }
563
564 static int stk_prepare_sio_buffers(struct stk_camera *dev, unsigned n_sbufs)
565 {
566 int i;
567 if (dev->sio_bufs != NULL)
568 pr_err("sio_bufs already allocated\n");
569 else {
570 dev->sio_bufs = kcalloc(n_sbufs,
571 sizeof(struct stk_sio_buffer),
572 GFP_KERNEL);
573 if (dev->sio_bufs == NULL)
574 return -ENOMEM;
575 for (i = 0; i < n_sbufs; i++) {
576 if (stk_setup_siobuf(dev, i))
577 return (dev->n_sbufs > 1 ? 0 : -ENOMEM);
578 dev->n_sbufs = i+1;
579 }
580 }
581 return 0;
582 }
583
584 static int stk_allocate_buffers(struct stk_camera *dev, unsigned n_sbufs)
585 {
586 int err;
587 err = stk_prepare_iso(dev);
588 if (err) {
589 stk_clean_iso(dev);
590 return err;
591 }
592 err = stk_prepare_sio_buffers(dev, n_sbufs);
593 if (err) {
594 stk_free_sio_buffers(dev);
595 return err;
596 }
597 return 0;
598 }
599
600 static void stk_free_buffers(struct stk_camera *dev)
601 {
602 stk_clean_iso(dev);
603 stk_free_sio_buffers(dev);
604 }
605 /* -------------------------------------------- */
606
607 /* v4l file operations */
608
609 static int v4l_stk_open(struct file *fp)
610 {
611 struct stk_camera *dev = video_drvdata(fp);
612 int err;
613
614 if (dev == NULL || !is_present(dev))
615 return -ENXIO;
616
617 if (mutex_lock_interruptible(&dev->lock))
618 return -ERESTARTSYS;
619 if (!dev->first_init)
620 stk_camera_write_reg(dev, 0x0, 0x24);
621 else
622 dev->first_init = 0;
623
624 err = v4l2_fh_open(fp);
625 if (!err)
626 usb_autopm_get_interface(dev->interface);
627 mutex_unlock(&dev->lock);
628 return err;
629 }
630
631 static int v4l_stk_release(struct file *fp)
632 {
633 struct stk_camera *dev = video_drvdata(fp);
634
635 mutex_lock(&dev->lock);
636 if (dev->owner == fp) {
637 stk_stop_stream(dev);
638 stk_free_buffers(dev);
639 stk_camera_write_reg(dev, 0x0, 0x49); /* turn off the LED */
640 unset_initialised(dev);
641 dev->owner = NULL;
642 }
643
644 if (is_present(dev))
645 usb_autopm_put_interface(dev->interface);
646 mutex_unlock(&dev->lock);
647 return v4l2_fh_release(fp);
648 }
649
650 static ssize_t stk_read(struct file *fp, char __user *buf,
651 size_t count, loff_t *f_pos)
652 {
653 int i;
654 int ret;
655 unsigned long flags;
656 struct stk_sio_buffer *sbuf;
657 struct stk_camera *dev = video_drvdata(fp);
658
659 if (!is_present(dev))
660 return -EIO;
661 if (dev->owner && (!dev->reading || dev->owner != fp))
662 return -EBUSY;
663 dev->owner = fp;
664 if (!is_streaming(dev)) {
665 if (stk_initialise(dev)
666 || stk_allocate_buffers(dev, 3)
667 || stk_start_stream(dev))
668 return -ENOMEM;
669 dev->reading = 1;
670 spin_lock_irqsave(&dev->spinlock, flags);
671 for (i = 0; i < dev->n_sbufs; i++) {
672 list_add_tail(&dev->sio_bufs[i].list, &dev->sio_avail);
673 dev->sio_bufs[i].v4lbuf.flags = V4L2_BUF_FLAG_QUEUED;
674 }
675 spin_unlock_irqrestore(&dev->spinlock, flags);
676 }
677 if (*f_pos == 0) {
678 if (fp->f_flags & O_NONBLOCK && list_empty(&dev->sio_full))
679 return -EWOULDBLOCK;
680 ret = wait_event_interruptible(dev->wait_frame,
681 !list_empty(&dev->sio_full) || !is_present(dev));
682 if (ret)
683 return ret;
684 if (!is_present(dev))
685 return -EIO;
686 }
687 if (count + *f_pos > dev->frame_size)
688 count = dev->frame_size - *f_pos;
689 spin_lock_irqsave(&dev->spinlock, flags);
690 if (list_empty(&dev->sio_full)) {
691 spin_unlock_irqrestore(&dev->spinlock, flags);
692 pr_err("BUG: No siobufs ready\n");
693 return 0;
694 }
695 sbuf = list_first_entry(&dev->sio_full, struct stk_sio_buffer, list);
696 spin_unlock_irqrestore(&dev->spinlock, flags);
697
698 if (copy_to_user(buf, sbuf->buffer + *f_pos, count))
699 return -EFAULT;
700
701 *f_pos += count;
702
703 if (*f_pos >= dev->frame_size) {
704 *f_pos = 0;
705 spin_lock_irqsave(&dev->spinlock, flags);
706 list_move_tail(&sbuf->list, &dev->sio_avail);
707 spin_unlock_irqrestore(&dev->spinlock, flags);
708 }
709 return count;
710 }
711
712 static ssize_t v4l_stk_read(struct file *fp, char __user *buf,
713 size_t count, loff_t *f_pos)
714 {
715 struct stk_camera *dev = video_drvdata(fp);
716 int ret;
717
718 if (mutex_lock_interruptible(&dev->lock))
719 return -ERESTARTSYS;
720 ret = stk_read(fp, buf, count, f_pos);
721 mutex_unlock(&dev->lock);
722 return ret;
723 }
724
725 static __poll_t v4l_stk_poll(struct file *fp, poll_table *wait)
726 {
727 struct stk_camera *dev = video_drvdata(fp);
728 __poll_t res = v4l2_ctrl_poll(fp, wait);
729
730 poll_wait(fp, &dev->wait_frame, wait);
731
732 if (!is_present(dev))
733 return EPOLLERR;
734
735 if (!list_empty(&dev->sio_full))
736 return res | EPOLLIN | EPOLLRDNORM;
737
738 return res;
739 }
740
741
742 static void stk_v4l_vm_open(struct vm_area_struct *vma)
743 {
744 struct stk_sio_buffer *sbuf = vma->vm_private_data;
745 sbuf->mapcount++;
746 }
747 static void stk_v4l_vm_close(struct vm_area_struct *vma)
748 {
749 struct stk_sio_buffer *sbuf = vma->vm_private_data;
750 sbuf->mapcount--;
751 if (sbuf->mapcount == 0)
752 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_MAPPED;
753 }
754 static const struct vm_operations_struct stk_v4l_vm_ops = {
755 .open = stk_v4l_vm_open,
756 .close = stk_v4l_vm_close
757 };
758
759 static int v4l_stk_mmap(struct file *fp, struct vm_area_struct *vma)
760 {
761 unsigned int i;
762 int ret;
763 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
764 struct stk_camera *dev = video_drvdata(fp);
765 struct stk_sio_buffer *sbuf = NULL;
766
767 if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED))
768 return -EINVAL;
769
770 for (i = 0; i < dev->n_sbufs; i++) {
771 if (dev->sio_bufs[i].v4lbuf.m.offset == offset) {
772 sbuf = dev->sio_bufs + i;
773 break;
774 }
775 }
776 if (sbuf == NULL)
777 return -EINVAL;
778 ret = remap_vmalloc_range(vma, sbuf->buffer, 0);
779 if (ret)
780 return ret;
781 vma->vm_flags |= VM_DONTEXPAND;
782 vma->vm_private_data = sbuf;
783 vma->vm_ops = &stk_v4l_vm_ops;
784 sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_MAPPED;
785 stk_v4l_vm_open(vma);
786 return 0;
787 }
788
789 /* v4l ioctl handlers */
790
791 static int stk_vidioc_querycap(struct file *filp,
792 void *priv, struct v4l2_capability *cap)
793 {
794 struct stk_camera *dev = video_drvdata(filp);
795
796 strcpy(cap->driver, "stk");
797 strcpy(cap->card, "stk");
798 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
799
800 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE
801 | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
802 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
803 return 0;
804 }
805
806 static int stk_vidioc_enum_input(struct file *filp,
807 void *priv, struct v4l2_input *input)
808 {
809 if (input->index != 0)
810 return -EINVAL;
811
812 strcpy(input->name, "Syntek USB Camera");
813 input->type = V4L2_INPUT_TYPE_CAMERA;
814 return 0;
815 }
816
817
818 static int stk_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
819 {
820 *i = 0;
821 return 0;
822 }
823
824 static int stk_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
825 {
826 return i ? -EINVAL : 0;
827 }
828
829 static int stk_s_ctrl(struct v4l2_ctrl *ctrl)
830 {
831 struct stk_camera *dev =
832 container_of(ctrl->handler, struct stk_camera, hdl);
833
834 switch (ctrl->id) {
835 case V4L2_CID_BRIGHTNESS:
836 return stk_sensor_set_brightness(dev, ctrl->val);
837 case V4L2_CID_HFLIP:
838 if (dmi_check_system(stk_upside_down_dmi_table))
839 dev->vsettings.hflip = !ctrl->val;
840 else
841 dev->vsettings.hflip = ctrl->val;
842 return 0;
843 case V4L2_CID_VFLIP:
844 if (dmi_check_system(stk_upside_down_dmi_table))
845 dev->vsettings.vflip = !ctrl->val;
846 else
847 dev->vsettings.vflip = ctrl->val;
848 return 0;
849 default:
850 return -EINVAL;
851 }
852 return 0;
853 }
854
855
856 static int stk_vidioc_enum_fmt_vid_cap(struct file *filp,
857 void *priv, struct v4l2_fmtdesc *fmtd)
858 {
859 switch (fmtd->index) {
860 case 0:
861 fmtd->pixelformat = V4L2_PIX_FMT_RGB565;
862 strcpy(fmtd->description, "r5g6b5");
863 break;
864 case 1:
865 fmtd->pixelformat = V4L2_PIX_FMT_RGB565X;
866 strcpy(fmtd->description, "r5g6b5BE");
867 break;
868 case 2:
869 fmtd->pixelformat = V4L2_PIX_FMT_UYVY;
870 strcpy(fmtd->description, "yuv4:2:2");
871 break;
872 case 3:
873 fmtd->pixelformat = V4L2_PIX_FMT_SBGGR8;
874 strcpy(fmtd->description, "Raw bayer");
875 break;
876 case 4:
877 fmtd->pixelformat = V4L2_PIX_FMT_YUYV;
878 strcpy(fmtd->description, "yuv4:2:2");
879 break;
880 default:
881 return -EINVAL;
882 }
883 return 0;
884 }
885
886 static struct stk_size {
887 unsigned w;
888 unsigned h;
889 enum stk_mode m;
890 } stk_sizes[] = {
891 { .w = 1280, .h = 1024, .m = MODE_SXGA, },
892 { .w = 640, .h = 480, .m = MODE_VGA, },
893 { .w = 352, .h = 288, .m = MODE_CIF, },
894 { .w = 320, .h = 240, .m = MODE_QVGA, },
895 { .w = 176, .h = 144, .m = MODE_QCIF, },
896 };
897
898 static int stk_vidioc_g_fmt_vid_cap(struct file *filp,
899 void *priv, struct v4l2_format *f)
900 {
901 struct v4l2_pix_format *pix_format = &f->fmt.pix;
902 struct stk_camera *dev = video_drvdata(filp);
903 int i;
904
905 for (i = 0; i < ARRAY_SIZE(stk_sizes) &&
906 stk_sizes[i].m != dev->vsettings.mode; i++)
907 ;
908 if (i == ARRAY_SIZE(stk_sizes)) {
909 pr_err("ERROR: mode invalid\n");
910 return -EINVAL;
911 }
912 pix_format->width = stk_sizes[i].w;
913 pix_format->height = stk_sizes[i].h;
914 pix_format->field = V4L2_FIELD_NONE;
915 pix_format->colorspace = V4L2_COLORSPACE_SRGB;
916 pix_format->pixelformat = dev->vsettings.palette;
917 if (dev->vsettings.palette == V4L2_PIX_FMT_SBGGR8)
918 pix_format->bytesperline = pix_format->width;
919 else
920 pix_format->bytesperline = 2 * pix_format->width;
921 pix_format->sizeimage = pix_format->bytesperline
922 * pix_format->height;
923 return 0;
924 }
925
926 static int stk_try_fmt_vid_cap(struct file *filp,
927 struct v4l2_format *fmtd, int *idx)
928 {
929 int i;
930 switch (fmtd->fmt.pix.pixelformat) {
931 case V4L2_PIX_FMT_RGB565:
932 case V4L2_PIX_FMT_RGB565X:
933 case V4L2_PIX_FMT_UYVY:
934 case V4L2_PIX_FMT_YUYV:
935 case V4L2_PIX_FMT_SBGGR8:
936 break;
937 default:
938 return -EINVAL;
939 }
940 for (i = 1; i < ARRAY_SIZE(stk_sizes); i++) {
941 if (fmtd->fmt.pix.width > stk_sizes[i].w)
942 break;
943 }
944 if (i == ARRAY_SIZE(stk_sizes)
945 || (abs(fmtd->fmt.pix.width - stk_sizes[i-1].w)
946 < abs(fmtd->fmt.pix.width - stk_sizes[i].w))) {
947 fmtd->fmt.pix.height = stk_sizes[i-1].h;
948 fmtd->fmt.pix.width = stk_sizes[i-1].w;
949 if (idx)
950 *idx = i - 1;
951 } else {
952 fmtd->fmt.pix.height = stk_sizes[i].h;
953 fmtd->fmt.pix.width = stk_sizes[i].w;
954 if (idx)
955 *idx = i;
956 }
957
958 fmtd->fmt.pix.field = V4L2_FIELD_NONE;
959 fmtd->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
960 if (fmtd->fmt.pix.pixelformat == V4L2_PIX_FMT_SBGGR8)
961 fmtd->fmt.pix.bytesperline = fmtd->fmt.pix.width;
962 else
963 fmtd->fmt.pix.bytesperline = 2 * fmtd->fmt.pix.width;
964 fmtd->fmt.pix.sizeimage = fmtd->fmt.pix.bytesperline
965 * fmtd->fmt.pix.height;
966 return 0;
967 }
968
969 static int stk_vidioc_try_fmt_vid_cap(struct file *filp,
970 void *priv, struct v4l2_format *fmtd)
971 {
972 return stk_try_fmt_vid_cap(filp, fmtd, NULL);
973 }
974
975 static int stk_setup_format(struct stk_camera *dev)
976 {
977 int i = 0;
978 int depth;
979 if (dev->vsettings.palette == V4L2_PIX_FMT_SBGGR8)
980 depth = 1;
981 else
982 depth = 2;
983 while (i < ARRAY_SIZE(stk_sizes) &&
984 stk_sizes[i].m != dev->vsettings.mode)
985 i++;
986 if (i == ARRAY_SIZE(stk_sizes)) {
987 pr_err("Something is broken in %s\n", __func__);
988 return -EFAULT;
989 }
990 /* This registers controls some timings, not sure of what. */
991 stk_camera_write_reg(dev, 0x001b, 0x0e);
992 if (dev->vsettings.mode == MODE_SXGA)
993 stk_camera_write_reg(dev, 0x001c, 0x0e);
994 else
995 stk_camera_write_reg(dev, 0x001c, 0x46);
996 /*
997 * Registers 0x0115 0x0114 are the size of each line (bytes),
998 * regs 0x0117 0x0116 are the heigth of the image.
999 */
1000 stk_camera_write_reg(dev, 0x0115,
1001 ((stk_sizes[i].w * depth) >> 8) & 0xff);
1002 stk_camera_write_reg(dev, 0x0114,
1003 (stk_sizes[i].w * depth) & 0xff);
1004 stk_camera_write_reg(dev, 0x0117,
1005 (stk_sizes[i].h >> 8) & 0xff);
1006 stk_camera_write_reg(dev, 0x0116,
1007 stk_sizes[i].h & 0xff);
1008 return stk_sensor_configure(dev);
1009 }
1010
1011 static int stk_vidioc_s_fmt_vid_cap(struct file *filp,
1012 void *priv, struct v4l2_format *fmtd)
1013 {
1014 int ret;
1015 int idx;
1016 struct stk_camera *dev = video_drvdata(filp);
1017
1018 if (dev == NULL)
1019 return -ENODEV;
1020 if (!is_present(dev))
1021 return -ENODEV;
1022 if (is_streaming(dev))
1023 return -EBUSY;
1024 if (dev->owner)
1025 return -EBUSY;
1026 ret = stk_try_fmt_vid_cap(filp, fmtd, &idx);
1027 if (ret)
1028 return ret;
1029
1030 dev->vsettings.palette = fmtd->fmt.pix.pixelformat;
1031 stk_free_buffers(dev);
1032 dev->frame_size = fmtd->fmt.pix.sizeimage;
1033 dev->vsettings.mode = stk_sizes[idx].m;
1034
1035 stk_initialise(dev);
1036 return stk_setup_format(dev);
1037 }
1038
1039 static int stk_vidioc_reqbufs(struct file *filp,
1040 void *priv, struct v4l2_requestbuffers *rb)
1041 {
1042 struct stk_camera *dev = video_drvdata(filp);
1043
1044 if (dev == NULL)
1045 return -ENODEV;
1046 if (rb->memory != V4L2_MEMORY_MMAP)
1047 return -EINVAL;
1048 if (is_streaming(dev)
1049 || (dev->owner && dev->owner != filp))
1050 return -EBUSY;
1051 stk_free_buffers(dev);
1052 if (rb->count == 0) {
1053 stk_camera_write_reg(dev, 0x0, 0x49); /* turn off the LED */
1054 unset_initialised(dev);
1055 dev->owner = NULL;
1056 return 0;
1057 }
1058 dev->owner = filp;
1059
1060 /*FIXME If they ask for zero, we must stop streaming and free */
1061 if (rb->count < 3)
1062 rb->count = 3;
1063 /* Arbitrary limit */
1064 else if (rb->count > 5)
1065 rb->count = 5;
1066
1067 stk_allocate_buffers(dev, rb->count);
1068 rb->count = dev->n_sbufs;
1069 return 0;
1070 }
1071
1072 static int stk_vidioc_querybuf(struct file *filp,
1073 void *priv, struct v4l2_buffer *buf)
1074 {
1075 struct stk_camera *dev = video_drvdata(filp);
1076 struct stk_sio_buffer *sbuf;
1077
1078 if (buf->index >= dev->n_sbufs)
1079 return -EINVAL;
1080 sbuf = dev->sio_bufs + buf->index;
1081 *buf = sbuf->v4lbuf;
1082 return 0;
1083 }
1084
1085 static int stk_vidioc_qbuf(struct file *filp,
1086 void *priv, struct v4l2_buffer *buf)
1087 {
1088 struct stk_camera *dev = video_drvdata(filp);
1089 struct stk_sio_buffer *sbuf;
1090 unsigned long flags;
1091
1092 if (buf->memory != V4L2_MEMORY_MMAP)
1093 return -EINVAL;
1094
1095 if (buf->index >= dev->n_sbufs)
1096 return -EINVAL;
1097 sbuf = dev->sio_bufs + buf->index;
1098 if (sbuf->v4lbuf.flags & V4L2_BUF_FLAG_QUEUED)
1099 return 0;
1100 sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_QUEUED;
1101 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_DONE;
1102 spin_lock_irqsave(&dev->spinlock, flags);
1103 list_add_tail(&sbuf->list, &dev->sio_avail);
1104 *buf = sbuf->v4lbuf;
1105 spin_unlock_irqrestore(&dev->spinlock, flags);
1106 return 0;
1107 }
1108
1109 static int stk_vidioc_dqbuf(struct file *filp,
1110 void *priv, struct v4l2_buffer *buf)
1111 {
1112 struct stk_camera *dev = video_drvdata(filp);
1113 struct stk_sio_buffer *sbuf;
1114 unsigned long flags;
1115 int ret;
1116
1117 if (!is_streaming(dev))
1118 return -EINVAL;
1119
1120 if (filp->f_flags & O_NONBLOCK && list_empty(&dev->sio_full))
1121 return -EWOULDBLOCK;
1122 ret = wait_event_interruptible(dev->wait_frame,
1123 !list_empty(&dev->sio_full) || !is_present(dev));
1124 if (ret)
1125 return ret;
1126 if (!is_present(dev))
1127 return -EIO;
1128
1129 spin_lock_irqsave(&dev->spinlock, flags);
1130 sbuf = list_first_entry(&dev->sio_full, struct stk_sio_buffer, list);
1131 list_del_init(&sbuf->list);
1132 spin_unlock_irqrestore(&dev->spinlock, flags);
1133 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
1134 sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_DONE;
1135 sbuf->v4lbuf.sequence = ++dev->sequence;
1136 v4l2_get_timestamp(&sbuf->v4lbuf.timestamp);
1137
1138 *buf = sbuf->v4lbuf;
1139 return 0;
1140 }
1141
1142 static int stk_vidioc_streamon(struct file *filp,
1143 void *priv, enum v4l2_buf_type type)
1144 {
1145 struct stk_camera *dev = video_drvdata(filp);
1146 if (is_streaming(dev))
1147 return 0;
1148 if (dev->sio_bufs == NULL)
1149 return -EINVAL;
1150 dev->sequence = 0;
1151 return stk_start_stream(dev);
1152 }
1153
1154 static int stk_vidioc_streamoff(struct file *filp,
1155 void *priv, enum v4l2_buf_type type)
1156 {
1157 struct stk_camera *dev = video_drvdata(filp);
1158 unsigned long flags;
1159 int i;
1160 stk_stop_stream(dev);
1161 spin_lock_irqsave(&dev->spinlock, flags);
1162 INIT_LIST_HEAD(&dev->sio_avail);
1163 INIT_LIST_HEAD(&dev->sio_full);
1164 for (i = 0; i < dev->n_sbufs; i++) {
1165 INIT_LIST_HEAD(&dev->sio_bufs[i].list);
1166 dev->sio_bufs[i].v4lbuf.flags = 0;
1167 }
1168 spin_unlock_irqrestore(&dev->spinlock, flags);
1169 return 0;
1170 }
1171
1172
1173 static int stk_vidioc_g_parm(struct file *filp,
1174 void *priv, struct v4l2_streamparm *sp)
1175 {
1176 /*FIXME This is not correct */
1177 sp->parm.capture.timeperframe.numerator = 1;
1178 sp->parm.capture.timeperframe.denominator = 30;
1179 sp->parm.capture.readbuffers = 2;
1180 return 0;
1181 }
1182
1183 static int stk_vidioc_enum_framesizes(struct file *filp,
1184 void *priv, struct v4l2_frmsizeenum *frms)
1185 {
1186 if (frms->index >= ARRAY_SIZE(stk_sizes))
1187 return -EINVAL;
1188 switch (frms->pixel_format) {
1189 case V4L2_PIX_FMT_RGB565:
1190 case V4L2_PIX_FMT_RGB565X:
1191 case V4L2_PIX_FMT_UYVY:
1192 case V4L2_PIX_FMT_YUYV:
1193 case V4L2_PIX_FMT_SBGGR8:
1194 frms->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1195 frms->discrete.width = stk_sizes[frms->index].w;
1196 frms->discrete.height = stk_sizes[frms->index].h;
1197 return 0;
1198 default: return -EINVAL;
1199 }
1200 }
1201
1202 static const struct v4l2_ctrl_ops stk_ctrl_ops = {
1203 .s_ctrl = stk_s_ctrl,
1204 };
1205
1206 static const struct v4l2_file_operations v4l_stk_fops = {
1207 .owner = THIS_MODULE,
1208 .open = v4l_stk_open,
1209 .release = v4l_stk_release,
1210 .read = v4l_stk_read,
1211 .poll = v4l_stk_poll,
1212 .mmap = v4l_stk_mmap,
1213 .unlocked_ioctl = video_ioctl2,
1214 };
1215
1216 static const struct v4l2_ioctl_ops v4l_stk_ioctl_ops = {
1217 .vidioc_querycap = stk_vidioc_querycap,
1218 .vidioc_enum_fmt_vid_cap = stk_vidioc_enum_fmt_vid_cap,
1219 .vidioc_try_fmt_vid_cap = stk_vidioc_try_fmt_vid_cap,
1220 .vidioc_s_fmt_vid_cap = stk_vidioc_s_fmt_vid_cap,
1221 .vidioc_g_fmt_vid_cap = stk_vidioc_g_fmt_vid_cap,
1222 .vidioc_enum_input = stk_vidioc_enum_input,
1223 .vidioc_s_input = stk_vidioc_s_input,
1224 .vidioc_g_input = stk_vidioc_g_input,
1225 .vidioc_reqbufs = stk_vidioc_reqbufs,
1226 .vidioc_querybuf = stk_vidioc_querybuf,
1227 .vidioc_qbuf = stk_vidioc_qbuf,
1228 .vidioc_dqbuf = stk_vidioc_dqbuf,
1229 .vidioc_streamon = stk_vidioc_streamon,
1230 .vidioc_streamoff = stk_vidioc_streamoff,
1231 .vidioc_g_parm = stk_vidioc_g_parm,
1232 .vidioc_enum_framesizes = stk_vidioc_enum_framesizes,
1233 .vidioc_log_status = v4l2_ctrl_log_status,
1234 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1235 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1236 };
1237
1238 static void stk_v4l_dev_release(struct video_device *vd)
1239 {
1240 struct stk_camera *dev = vdev_to_camera(vd);
1241
1242 if (dev->sio_bufs != NULL || dev->isobufs != NULL)
1243 pr_err("We are leaking memory\n");
1244 usb_put_intf(dev->interface);
1245 }
1246
1247 static const struct video_device stk_v4l_data = {
1248 .name = "stkwebcam",
1249 .fops = &v4l_stk_fops,
1250 .ioctl_ops = &v4l_stk_ioctl_ops,
1251 .release = stk_v4l_dev_release,
1252 };
1253
1254
1255 static int stk_register_video_device(struct stk_camera *dev)
1256 {
1257 int err;
1258
1259 dev->vdev = stk_v4l_data;
1260 dev->vdev.lock = &dev->lock;
1261 dev->vdev.v4l2_dev = &dev->v4l2_dev;
1262 video_set_drvdata(&dev->vdev, dev);
1263 err = video_register_device(&dev->vdev, VFL_TYPE_GRABBER, -1);
1264 if (err)
1265 pr_err("v4l registration failed\n");
1266 else
1267 pr_info("Syntek USB2.0 Camera is now controlling device %s\n",
1268 video_device_node_name(&dev->vdev));
1269 return err;
1270 }
1271
1272
1273 /* USB Stuff */
1274
1275 static int stk_camera_probe(struct usb_interface *interface,
1276 const struct usb_device_id *id)
1277 {
1278 struct v4l2_ctrl_handler *hdl;
1279 int err = 0;
1280 int i;
1281
1282 struct stk_camera *dev = NULL;
1283 struct usb_device *udev = interface_to_usbdev(interface);
1284 struct usb_host_interface *iface_desc;
1285 struct usb_endpoint_descriptor *endpoint;
1286
1287 dev = kzalloc(sizeof(struct stk_camera), GFP_KERNEL);
1288 if (dev == NULL) {
1289 pr_err("Out of memory !\n");
1290 return -ENOMEM;
1291 }
1292 err = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
1293 if (err < 0) {
1294 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1295 kfree(dev);
1296 return err;
1297 }
1298 hdl = &dev->hdl;
1299 v4l2_ctrl_handler_init(hdl, 3);
1300 v4l2_ctrl_new_std(hdl, &stk_ctrl_ops,
1301 V4L2_CID_BRIGHTNESS, 0, 0xff, 0x1, 0x60);
1302 v4l2_ctrl_new_std(hdl, &stk_ctrl_ops,
1303 V4L2_CID_HFLIP, 0, 1, 1, 1);
1304 v4l2_ctrl_new_std(hdl, &stk_ctrl_ops,
1305 V4L2_CID_VFLIP, 0, 1, 1, 1);
1306 if (hdl->error) {
1307 err = hdl->error;
1308 dev_err(&udev->dev, "couldn't register control\n");
1309 goto error;
1310 }
1311 dev->v4l2_dev.ctrl_handler = hdl;
1312
1313 spin_lock_init(&dev->spinlock);
1314 mutex_init(&dev->lock);
1315 init_waitqueue_head(&dev->wait_frame);
1316 dev->first_init = 1; /* webcam LED management */
1317
1318 dev->udev = udev;
1319 dev->interface = interface;
1320 usb_get_intf(interface);
1321
1322 if (hflip != -1)
1323 dev->vsettings.hflip = hflip;
1324 else if (dmi_check_system(stk_upside_down_dmi_table))
1325 dev->vsettings.hflip = 1;
1326 else
1327 dev->vsettings.hflip = 0;
1328 if (vflip != -1)
1329 dev->vsettings.vflip = vflip;
1330 else if (dmi_check_system(stk_upside_down_dmi_table))
1331 dev->vsettings.vflip = 1;
1332 else
1333 dev->vsettings.vflip = 0;
1334 dev->n_sbufs = 0;
1335 set_present(dev);
1336
1337 /* Set up the endpoint information
1338 * use only the first isoc-in endpoint
1339 * for the current alternate setting */
1340 iface_desc = interface->cur_altsetting;
1341
1342 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1343 endpoint = &iface_desc->endpoint[i].desc;
1344
1345 if (!dev->isoc_ep
1346 && usb_endpoint_is_isoc_in(endpoint)) {
1347 /* we found an isoc in endpoint */
1348 dev->isoc_ep = usb_endpoint_num(endpoint);
1349 break;
1350 }
1351 }
1352 if (!dev->isoc_ep) {
1353 pr_err("Could not find isoc-in endpoint\n");
1354 err = -ENODEV;
1355 goto error;
1356 }
1357 dev->vsettings.palette = V4L2_PIX_FMT_RGB565;
1358 dev->vsettings.mode = MODE_VGA;
1359 dev->frame_size = 640 * 480 * 2;
1360
1361 INIT_LIST_HEAD(&dev->sio_avail);
1362 INIT_LIST_HEAD(&dev->sio_full);
1363
1364 usb_set_intfdata(interface, dev);
1365
1366 err = stk_register_video_device(dev);
1367 if (err)
1368 goto error;
1369
1370 return 0;
1371
1372 error:
1373 v4l2_ctrl_handler_free(hdl);
1374 v4l2_device_unregister(&dev->v4l2_dev);
1375 kfree(dev);
1376 return err;
1377 }
1378
1379 static void stk_camera_disconnect(struct usb_interface *interface)
1380 {
1381 struct stk_camera *dev = usb_get_intfdata(interface);
1382
1383 usb_set_intfdata(interface, NULL);
1384 unset_present(dev);
1385
1386 wake_up_interruptible(&dev->wait_frame);
1387
1388 pr_info("Syntek USB2.0 Camera release resources device %s\n",
1389 video_device_node_name(&dev->vdev));
1390
1391 video_unregister_device(&dev->vdev);
1392 v4l2_ctrl_handler_free(&dev->hdl);
1393 v4l2_device_unregister(&dev->v4l2_dev);
1394 kfree(dev);
1395 }
1396
1397 #ifdef CONFIG_PM
1398 static int stk_camera_suspend(struct usb_interface *intf, pm_message_t message)
1399 {
1400 struct stk_camera *dev = usb_get_intfdata(intf);
1401 if (is_streaming(dev)) {
1402 stk_stop_stream(dev);
1403 /* yes, this is ugly */
1404 set_streaming(dev);
1405 }
1406 return 0;
1407 }
1408
1409 static int stk_camera_resume(struct usb_interface *intf)
1410 {
1411 struct stk_camera *dev = usb_get_intfdata(intf);
1412 if (!is_initialised(dev))
1413 return 0;
1414 unset_initialised(dev);
1415 stk_initialise(dev);
1416 stk_camera_write_reg(dev, 0x0, 0x49);
1417 stk_setup_format(dev);
1418 if (is_streaming(dev))
1419 stk_start_stream(dev);
1420 return 0;
1421 }
1422 #endif
1423
1424 static struct usb_driver stk_camera_driver = {
1425 .name = "stkwebcam",
1426 .probe = stk_camera_probe,
1427 .disconnect = stk_camera_disconnect,
1428 .id_table = stkwebcam_table,
1429 #ifdef CONFIG_PM
1430 .suspend = stk_camera_suspend,
1431 .resume = stk_camera_resume,
1432 #endif
1433 };
1434
1435 module_usb_driver(stk_camera_driver);
Linux with added FPC-III support