projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
treewide: kzalloc() -> kcalloc()
[linux-2.6-block.git] / drivers / media / usb / stkwebcam / stk-webcam.c
CommitLineData
ec16dae5
JVJ		 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.
ec16dae5
JVJ		 19 */
20
f1bd9bd6
JP		 21#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
ec16dae5
JVJ		 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>
ec16dae5 28
7a29ee2e 29#include <linux/dmi.h>
ec16dae5 30#include <linux/usb.h>
ef69c8e8 31#include <linux/mm.h>
387d4477 32#include <linux/vmalloc.h>
ec16dae5
JVJ		 33#include <linux/videodev2.h>
34#include <media/v4l2-common.h>
35ea11ff 35#include <media/v4l2-ioctl.h>
89ea4706 36#include <media/v4l2-event.h>
ec16dae5
JVJ		 37
38#include "stk-webcam.h"
39
40
7a29ee2e
HG		 41static int hflip = -1;
42module_param(hflip, int, 0444);
4fd466a1 43MODULE_PARM_DESC(hflip, "Horizontal image flip (mirror). Defaults to 0");
ec16dae5 44
7a29ee2e
HG		 45static int vflip = -1;
46module_param(vflip, int, 0444);
4fd466a1 47MODULE_PARM_DESC(vflip, "Vertical image flip. Defaults to 0");
ec16dae5
JVJ		 48
49static int debug;
50module_param(debug, int, 0444);
51MODULE_PARM_DESC(debug, "Debug v4l ioctls. Defaults to 0");
52
53MODULE_LICENSE("GPL");
54MODULE_AUTHOR("Jaime Velasco Juan <jsagarribay@gmail.com> and Nicolas VIVIEN");
55MODULE_DESCRIPTION("Syntek DC1125 webcam driver");
56
ec16dae5 57/* Some cameras have audio interfaces, we aren't interested in those */
7fb2e072 58static const struct usb_device_id stkwebcam_table[] = {
ec16dae5
JVJ		 59 { USB_DEVICE_AND_INTERFACE_INFO(0x174f, 0xa311, 0xff, 0xff, 0xff) },
60 { USB_DEVICE_AND_INTERFACE_INFO(0x05e1, 0x0501, 0xff, 0xff, 0xff) },
61 { }
62};
63MODULE_DEVICE_TABLE(usb, stkwebcam_table);
64
2aeb73e1
HV		 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 */
7a29ee2e
HG		 98static 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 }
2aeb73e1
HV		 105 }, {
106 .ident = "ASUS F3JC",
107 .matches = {
108 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
109 DMI_MATCH(DMI_PRODUCT_NAME, "F3JC")
110 }
7a29ee2e 111 },
08149ecf
GJ		 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 },
7a29ee2e
HG		 119 {}
120};
121
122
ec16dae5
JVJ		 123/*
124 * Basic stuff
125 */
126int 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
d08876f5 145int stk_camera_read_reg(struct stk_camera *dev, u16 index, u8 *value)
ec16dae5
JVJ		 146{
147 struct usb_device *udev = dev->udev;
b5f93cb5 148 unsigned char *buf;
ec16dae5
JVJ		 149 int ret;
150
b5f93cb5
MCC		 151 buf = kmalloc(sizeof(u8), GFP_KERNEL);
152 if (!buf)
153 return -ENOMEM;
154
ec16dae5
JVJ		 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,
b5f93cb5 160 buf,
ec16dae5
JVJ		 161 sizeof(u8),
162 500);
b5f93cb5 163 if (ret >= 0)
d08876f5 164 *value = *buf;
b5f93cb5
MCC		 165
166 kfree(buf);
167 return ret;
ec16dae5
JVJ		 168}
169
170static int stk_start_stream(struct stk_camera *dev)
171{
d08876f5 172 u8 value;
ec16dae5 173 int i, ret;
d08876f5
DC		 174 u8 value_116, value_117;
175
ec16dae5
JVJ		 176
177 if (!is_present(dev))
178 return -ENODEV;
179 if (!is_memallocd(dev) || !is_initialised(dev)) {
f1bd9bd6 180 pr_err("FIXME: Buffers are not allocated\n");
ec16dae5
JVJ		 181 return -EFAULT;
182 }
183 ret = usb_set_interface(dev->udev, 0, 5);
184
185 if (ret < 0)
f1bd9bd6 186 pr_err("usb_set_interface failed !\n");
ec16dae5 187 if (stk_sensor_wakeup(dev))
f1bd9bd6 188 pr_err("error awaking the sensor\n");
ec16dae5
JVJ		 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
213static int stk_stop_stream(struct stk_camera *dev)
214{
d08876f5 215 u8 value;
ec16dae5
JVJ		 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))
f1bd9bd6 229 pr_err("usb_set_interface failed !\n");
ec16dae5 230 if (stk_sensor_sleep(dev))
f1bd9bd6 231 pr_err("error suspending the sensor\n");
ec16dae5
JVJ		 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
244static 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
274static 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
ec16dae5
JVJ		 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 */
302static 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) {
f1bd9bd6 318 pr_err("isoc_handler called with NULL device !\n");
ec16dae5
JVJ		 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) {
f1bd9bd6 331 pr_err("isoc_handler: urb->status == %d\n", urb->status);
ec16dae5
JVJ		 332 goto resubmit;
333 }
334
335 if (list_empty(&dev->sio_avail)) {
336 /*FIXME Stop streaming after a while */
f1bd9bd6 337 pr_err_ratelimited("isoc_handler without available buffer!\n");
ec16dae5
JVJ		 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)
f1bd9bd6
JP		 347 pr_err("Frame %d has error %d\n",
348 i, urb->iso_frame_desc[i].status);
ec16dae5
JVJ		 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) {
f1bd9bd6
JP		 372 pr_err_ratelimited("frame %d, bytesused=%d, skipping\n",
373 i, fb->v4lbuf.bytesused);
ec16dae5
JVJ		 374 fb->v4lbuf.bytesused = 0;
375 fill = fb->buffer;
376 } else if (fb->v4lbuf.bytesused == dev->frame_size) {
b1855907
JVJ		 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;
ec16dae5 389 }
ec16dae5
JVJ		 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) {
f1bd9bd6 398 pr_err_ratelimited("Frame buffer overflow, lost sync\n");
ec16dae5
JVJ		 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
411resubmit:
412 spin_unlock_irqrestore(&dev->spinlock, flags);
413 urb->dev = dev->udev;
414 ret = usb_submit_urb(urb, GFP_ATOMIC);
415 if (ret != 0) {
f1bd9bd6
JP		 416 pr_err("Error (%d) re-submitting urb in stk_isoc_handler\n",
417 ret);
ec16dae5
JVJ		 418 }
419}
420
421/* -------------------------------------------- */
422
423static 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)
f1bd9bd6 435 pr_err("isobufs already allocated. Bad\n");
ec16dae5 436 else
9884d7be
TM		 437 dev->isobufs = kcalloc(MAX_ISO_BUFS, sizeof(*dev->isobufs),
438 GFP_KERNEL);
ec16dae5 439 if (dev->isobufs == NULL) {
f1bd9bd6 440 pr_err("Unable to allocate iso buffers\n");
ec16dae5
JVJ		 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) {
f1bd9bd6 447 pr_err("Failed to allocate iso buffer %d\n", i);
ec16dae5
JVJ		 448 goto isobufs_out;
449 }
450 dev->isobufs[i].data = kbuf;
451 } else
f1bd9bd6 452 pr_err("isobuf data already allocated\n");
ec16dae5
JVJ		 453 if (dev->isobufs[i].urb == NULL) {
454 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
2685b1d1 455 if (urb == NULL)
ec16dae5 456 goto isobufs_out;
ec16dae5
JVJ		 457 dev->isobufs[i].urb = urb;
458 } else {
f1bd9bd6 459 pr_err("Killing URB\n");
ec16dae5
JVJ		 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
482isobufs_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
492static 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) {
f051ae18 504 if (atomic_read(&dev->urbs_used) && is_present(dev))
ec16dae5
JVJ		 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
515static 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;
1b18e7a0 527 buf->v4lbuf.flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
ec16dae5
JVJ		 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
534static 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);
704b3f4c
ME		 557 for (i = 0; i < nbufs; i++)
558 vfree(dev->sio_bufs[i].buffer);
ec16dae5
JVJ		 559 kfree(dev->sio_bufs);
560 dev->sio_bufs = NULL;
561 return 0;
562}
563
564static int stk_prepare_sio_buffers(struct stk_camera *dev, unsigned n_sbufs)
565{
566 int i;
567 if (dev->sio_bufs != NULL)
f1bd9bd6 568 pr_err("sio_bufs already allocated\n");
ec16dae5 569 else {
6396bb22
KC		 570 dev->sio_bufs = kcalloc(n_sbufs,
571 sizeof(struct stk_sio_buffer),
572 GFP_KERNEL);
ec16dae5
JVJ		 573 if (dev->sio_bufs == NULL)
574 return -ENOMEM;
575 for (i = 0; i < n_sbufs; i++) {
576 if (stk_setup_siobuf(dev, i))
b57ce417 577 return (dev->n_sbufs > 1 ? 0 : -ENOMEM);
ec16dae5
JVJ		 578 dev->n_sbufs = i+1;
579 }
580 }
581 return 0;
582}
583
584static 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
600static 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
bec43661 609static int v4l_stk_open(struct file *fp)
ec16dae5 610{
10351adc 611 struct stk_camera *dev = video_drvdata(fp);
89ea4706 612 int err;
ec16dae5 613
b57ce417 614 if (dev == NULL || !is_present(dev))
ec16dae5 615 return -ENXIO;
7b1c8f58 616
f80daa2d
HV		 617 if (mutex_lock_interruptible(&dev->lock))
618 return -ERESTARTSYS;
89ea4706 619 if (!dev->first_init)
7b1c8f58
AS		 620 stk_camera_write_reg(dev, 0x0, 0x24);
621 else
89ea4706 622 dev->first_init = 0;
ec16dae5 623
89ea4706
HV		 624 err = v4l2_fh_open(fp);
625 if (!err)
626 usb_autopm_get_interface(dev->interface);
f80daa2d 627 mutex_unlock(&dev->lock);
89ea4706 628 return err;
ec16dae5
JVJ		 629}
630
bec43661 631static int v4l_stk_release(struct file *fp)
ec16dae5 632{
10351adc 633 struct stk_camera *dev = video_drvdata(fp);
ec16dae5 634
f80daa2d 635 mutex_lock(&dev->lock);
f051ae18
DE		 636 if (dev->owner == fp) {
637 stk_stop_stream(dev);
638 stk_free_buffers(dev);
7b1c8f58 639 stk_camera_write_reg(dev, 0x0, 0x49); /* turn off the LED */
47a7e6f8 640 unset_initialised(dev);
f051ae18 641 dev->owner = NULL;
ec16dae5
JVJ		 642 }
643
b57ce417 644 if (is_present(dev))
f051ae18 645 usb_autopm_put_interface(dev->interface);
f80daa2d 646 mutex_unlock(&dev->lock);
89ea4706 647 return v4l2_fh_release(fp);
ec16dae5
JVJ		 648}
649
f80daa2d 650static ssize_t stk_read(struct file *fp, char __user *buf,
ec16dae5
JVJ		 651 size_t count, loff_t *f_pos)
652{
653 int i;
654 int ret;
655 unsigned long flags;
ec16dae5 656 struct stk_sio_buffer *sbuf;
10351adc 657 struct stk_camera *dev = video_drvdata(fp);
ec16dae5 658
ec16dae5
JVJ		 659 if (!is_present(dev))
660 return -EIO;
1b499fe5 661 if (dev->owner && (!dev->reading || dev->owner != fp))
ec16dae5
JVJ		 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;
1b499fe5 669 dev->reading = 1;
ec16dae5
JVJ		 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);
f1bd9bd6 692 pr_err("BUG: No siobufs ready\n");
ec16dae5
JVJ		 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
f80daa2d
HV		 712static 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
c23e0cb8 725static __poll_t v4l_stk_poll(struct file *fp, poll_table *wait)
ec16dae5 726{
10351adc 727 struct stk_camera *dev = video_drvdata(fp);
c23e0cb8 728 __poll_t res = v4l2_ctrl_poll(fp, wait);
ec16dae5 729
ec16dae5
JVJ		 730 poll_wait(fp, &dev->wait_frame, wait);
731
732 if (!is_present(dev))
a9a08845 733 return EPOLLERR;
ec16dae5
JVJ		 734
735 if (!list_empty(&dev->sio_full))
a9a08845 736 return res | EPOLLIN | EPOLLRDNORM;
ec16dae5 737
89ea4706 738 return res;
ec16dae5
JVJ		 739}
740
741
742static 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}
747static 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}
f0f37e2f 754static const struct vm_operations_struct stk_v4l_vm_ops = {
ec16dae5
JVJ		 755 .open = stk_v4l_vm_open,
756 .close = stk_v4l_vm_close
757};
758
759static 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;
10351adc 764 struct stk_camera *dev = video_drvdata(fp);
ec16dae5
JVJ		 765 struct stk_sio_buffer *sbuf = NULL;
766
767 if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED))
768 return -EINVAL;
769
ec16dae5
JVJ		 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
791static int stk_vidioc_querycap(struct file *filp,
792 void *priv, struct v4l2_capability *cap)
793{
b27763f0
HV		 794 struct stk_camera *dev = video_drvdata(filp);
795
ec16dae5
JVJ		 796 strcpy(cap->driver, "stk");
797 strcpy(cap->card, "stk");
b27763f0 798 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
ec16dae5 799
b27763f0 800 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE
ec16dae5 801 | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
b27763f0 802 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
ec16dae5
JVJ		 803 return 0;
804}
805
806static 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
818static int stk_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
819{
820 *i = 0;
821 return 0;
822}
823
824static int stk_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
825{
b27763f0 826 return i ? -EINVAL : 0;
ec16dae5
JVJ		 827}
828
dc0fb286 829static int stk_s_ctrl(struct v4l2_ctrl *ctrl)
ec16dae5 830{
dc0fb286
HV		 831 struct stk_camera *dev =
832 container_of(ctrl->handler, struct stk_camera, hdl);
ec16dae5 833
dc0fb286 834 switch (ctrl->id) {
ec16dae5 835 case V4L2_CID_BRIGHTNESS:
dc0fb286 836 return stk_sensor_set_brightness(dev, ctrl->val);
0a58d713 837 case V4L2_CID_HFLIP:
7a29ee2e 838 if (dmi_check_system(stk_upside_down_dmi_table))
dc0fb286 839 dev->vsettings.hflip = !ctrl->val;
7a29ee2e 840 else
dc0fb286 841 dev->vsettings.hflip = ctrl->val;
0a58d713
HV		 842 return 0;
843 case V4L2_CID_VFLIP:
7a29ee2e 844 if (dmi_check_system(stk_upside_down_dmi_table))
dc0fb286 845 dev->vsettings.vflip = !ctrl->val;
7a29ee2e 846 else
dc0fb286 847 dev->vsettings.vflip = ctrl->val;
0a58d713 848 return 0;
ec16dae5
JVJ		 849 default:
850 return -EINVAL;
851 }
852 return 0;
853}
854
855
78b526a4 856static int stk_vidioc_enum_fmt_vid_cap(struct file *filp,
ec16dae5
JVJ		 857 void *priv, struct v4l2_fmtdesc *fmtd)
858{
ec16dae5
JVJ		 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;
1112fb68
JVJ		 876 case 4:
877 fmtd->pixelformat = V4L2_PIX_FMT_YUYV;
878 strcpy(fmtd->description, "yuv4:2:2");
879 break;
ec16dae5
JVJ		 880 default:
881 return -EINVAL;
882 }
883 return 0;
884}
885
886static 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
78b526a4 898static int stk_vidioc_g_fmt_vid_cap(struct file *filp,
ec16dae5
JVJ		 899 void *priv, struct v4l2_format *f)
900{
901 struct v4l2_pix_format *pix_format = &f->fmt.pix;
10351adc 902 struct stk_camera *dev = video_drvdata(filp);
ec16dae5
JVJ		 903 int i;
904
b57ce417
AS		 905 for (i = 0; i < ARRAY_SIZE(stk_sizes) &&
906 stk_sizes[i].m != dev->vsettings.mode; i++)
907 ;
ec16dae5 908 if (i == ARRAY_SIZE(stk_sizes)) {
f1bd9bd6 909 pr_err("ERROR: mode invalid\n");
ec16dae5
JVJ		 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;
ec16dae5
JVJ		 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
8407653f
HV		 926static int stk_try_fmt_vid_cap(struct file *filp,
927 struct v4l2_format *fmtd, int *idx)
ec16dae5
JVJ		 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:
1112fb68 934 case V4L2_PIX_FMT_YUYV:
ec16dae5
JVJ		 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;
8407653f
HV		 949 if (idx)
950 *idx = i - 1;
ec16dae5
JVJ		 951 } else {
952 fmtd->fmt.pix.height = stk_sizes[i].h;
953 fmtd->fmt.pix.width = stk_sizes[i].w;
8407653f
HV		 954 if (idx)
955 *idx = i;
ec16dae5
JVJ		 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
8407653f
HV		 969static 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
1fdd61c0
JVJ		 975static 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;
77f2c2db
RK		 983 while (i < ARRAY_SIZE(stk_sizes) &&
984 stk_sizes[i].m != dev->vsettings.mode)
1fdd61c0
JVJ		 985 i++;
986 if (i == ARRAY_SIZE(stk_sizes)) {
f1bd9bd6 987 pr_err("Something is broken in %s\n", __func__);
1fdd61c0
JVJ		 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
78b526a4 1011static int stk_vidioc_s_fmt_vid_cap(struct file *filp,
ec16dae5
JVJ		 1012 void *priv, struct v4l2_format *fmtd)
1013{
1014 int ret;
8407653f 1015 int idx;
10351adc 1016 struct stk_camera *dev = video_drvdata(filp);
ec16dae5
JVJ		 1017
1018 if (dev == NULL)
1019 return -ENODEV;
1020 if (!is_present(dev))
1021 return -ENODEV;
1022 if (is_streaming(dev))
1023 return -EBUSY;
f81e372a 1024 if (dev->owner)
ec16dae5 1025 return -EBUSY;
8407653f 1026 ret = stk_try_fmt_vid_cap(filp, fmtd, &idx);
ec16dae5
JVJ		 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;
8407653f 1033 dev->vsettings.mode = stk_sizes[idx].m;
ec16dae5
JVJ		 1034
1035 stk_initialise(dev);
1fdd61c0 1036 return stk_setup_format(dev);
ec16dae5
JVJ		 1037}
1038
1039static int stk_vidioc_reqbufs(struct file *filp,
1040 void *priv, struct v4l2_requestbuffers *rb)
1041{
10351adc 1042 struct stk_camera *dev = video_drvdata(filp);
ec16dae5
JVJ		 1043
1044 if (dev == NULL)
1045 return -ENODEV;
ec16dae5
JVJ		 1046 if (rb->memory != V4L2_MEMORY_MMAP)
1047 return -EINVAL;
1048 if (is_streaming(dev)
1049 || (dev->owner && dev->owner != filp))
1050 return -EBUSY;
9776e171
HV		 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 }
ec16dae5
JVJ		 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
1072static int stk_vidioc_querybuf(struct file *filp,
1073 void *priv, struct v4l2_buffer *buf)
1074{
10351adc 1075 struct stk_camera *dev = video_drvdata(filp);
ec16dae5
JVJ		 1076 struct stk_sio_buffer *sbuf;
1077
223ffe5f 1078 if (buf->index >= dev->n_sbufs)
ec16dae5
JVJ		 1079 return -EINVAL;
1080 sbuf = dev->sio_bufs + buf->index;
1081 *buf = sbuf->v4lbuf;
1082 return 0;
1083}
1084
1085static int stk_vidioc_qbuf(struct file *filp,
1086 void *priv, struct v4l2_buffer *buf)
1087{
10351adc 1088 struct stk_camera *dev = video_drvdata(filp);
ec16dae5
JVJ		 1089 struct stk_sio_buffer *sbuf;
1090 unsigned long flags;
ec16dae5
JVJ		 1091
1092 if (buf->memory != V4L2_MEMORY_MMAP)
1093 return -EINVAL;
1094
223ffe5f 1095 if (buf->index >= dev->n_sbufs)
ec16dae5
JVJ		 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
1109static int stk_vidioc_dqbuf(struct file *filp,
1110 void *priv, struct v4l2_buffer *buf)
1111{
10351adc 1112 struct stk_camera *dev = video_drvdata(filp);
ec16dae5
JVJ		 1113 struct stk_sio_buffer *sbuf;
1114 unsigned long flags;
1115 int ret;
1116
2509e1cb 1117 if (!is_streaming(dev))
ec16dae5
JVJ		 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;
8e6057b5 1136 v4l2_get_timestamp(&sbuf->v4lbuf.timestamp);
ec16dae5
JVJ		 1137
1138 *buf = sbuf->v4lbuf;
1139 return 0;
1140}
1141
1142static int stk_vidioc_streamon(struct file *filp,
1143 void *priv, enum v4l2_buf_type type)
1144{
10351adc 1145 struct stk_camera *dev = video_drvdata(filp);
ec16dae5
JVJ		 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
1154static int stk_vidioc_streamoff(struct file *filp,
1155 void *priv, enum v4l2_buf_type type)
1156{
10351adc 1157 struct stk_camera *dev = video_drvdata(filp);
ec16dae5
JVJ		 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
1173static int stk_vidioc_g_parm(struct file *filp,
1174 void *priv, struct v4l2_streamparm *sp)
1175{
ec16dae5
JVJ		 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;
ec16dae5
JVJ		 1180 return 0;
1181}
1182
126be90f
JVJ		 1183static 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
dc0fb286
HV		 1202static const struct v4l2_ctrl_ops stk_ctrl_ops = {
1203 .s_ctrl = stk_s_ctrl,
1204};
1205
ff05c984 1206static const struct v4l2_file_operations v4l_stk_fops = {
ec16dae5
JVJ		 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,
f80daa2d 1213 .unlocked_ioctl = video_ioctl2,
ec16dae5
JVJ		 1214};
1215
a399810c 1216static const struct v4l2_ioctl_ops v4l_stk_ioctl_ops = {
ec16dae5 1217 .vidioc_querycap = stk_vidioc_querycap,
78b526a4
HV		 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,
ec16dae5
JVJ		 1222 .vidioc_enum_input = stk_vidioc_enum_input,
1223 .vidioc_s_input = stk_vidioc_s_input,
1224 .vidioc_g_input = stk_vidioc_g_input,
ec16dae5
JVJ		 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,
ec16dae5 1231 .vidioc_g_parm = stk_vidioc_g_parm,
126be90f 1232 .vidioc_enum_framesizes = stk_vidioc_enum_framesizes,
89ea4706
HV		 1233 .vidioc_log_status = v4l2_ctrl_log_status,
1234 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1235 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
ec16dae5
JVJ		 1236};
1237
a399810c
HV		 1238static void stk_v4l_dev_release(struct video_device *vd)
1239{
4aaec3ea
DE		 1240 struct stk_camera *dev = vdev_to_camera(vd);
1241
1242 if (dev->sio_bufs != NULL || dev->isobufs != NULL)
f1bd9bd6 1243 pr_err("We are leaking memory\n");
4aaec3ea 1244 usb_put_intf(dev->interface);
a399810c
HV		 1245}
1246
86844942 1247static const struct video_device stk_v4l_data = {
a399810c 1248 .name = "stkwebcam",
a399810c
HV		 1249 .fops = &v4l_stk_fops,
1250 .ioctl_ops = &v4l_stk_ioctl_ops,
1251 .release = stk_v4l_dev_release,
1252};
1253
ec16dae5
JVJ		 1254
1255static int stk_register_video_device(struct stk_camera *dev)
1256{
1257 int err;
1258
1259 dev->vdev = stk_v4l_data;
f80daa2d 1260 dev->vdev.lock = &dev->lock;
968c60f6 1261 dev->vdev.v4l2_dev = &dev->v4l2_dev;
10351adc 1262 video_set_drvdata(&dev->vdev, dev);
ec16dae5
JVJ		 1263 err = video_register_device(&dev->vdev, VFL_TYPE_GRABBER, -1);
1264 if (err)
f1bd9bd6 1265 pr_err("v4l registration failed\n");
ec16dae5 1266 else
f1bd9bd6
JP		 1267 pr_info("Syntek USB2.0 Camera is now controlling device %s\n",
1268 video_device_node_name(&dev->vdev));
ec16dae5
JVJ		 1269 return err;
1270}
1271
1272
1273/* USB Stuff */
1274
1275static int stk_camera_probe(struct usb_interface *interface,
1276 const struct usb_device_id *id)
1277{
dc0fb286 1278 struct v4l2_ctrl_handler *hdl;
4aaec3ea 1279 int err = 0;
dc0fb286 1280 int i;
ec16dae5
JVJ		 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) {
f1bd9bd6 1289 pr_err("Out of memory !\n");
ec16dae5
JVJ		 1290 return -ENOMEM;
1291 }
968c60f6
HV		 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 }
dc0fb286
HV		 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;
ec16dae5 1312
ec16dae5 1313 spin_lock_init(&dev->spinlock);
f80daa2d 1314 mutex_init(&dev->lock);
ec16dae5 1315 init_waitqueue_head(&dev->wait_frame);
89ea4706 1316 dev->first_init = 1; /* webcam LED management */
ec16dae5
JVJ		 1317
1318 dev->udev = udev;
1319 dev->interface = interface;
1320 usb_get_intf(interface);
1321
7a29ee2e
HG		 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;
ec16dae5
JVJ		 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
13417982 1346 && usb_endpoint_is_isoc_in(endpoint)) {
ec16dae5 1347 /* we found an isoc in endpoint */
13417982 1348 dev->isoc_ep = usb_endpoint_num(endpoint);
ec16dae5
JVJ		 1349 break;
1350 }
1351 }
1352 if (!dev->isoc_ep) {
f1bd9bd6 1353 pr_err("Could not find isoc-in endpoint\n");
4aaec3ea
DE		 1354 err = -ENODEV;
1355 goto error;
ec16dae5 1356 }
ec16dae5
JVJ		 1357 dev->vsettings.palette = V4L2_PIX_FMT_RGB565;
1358 dev->vsettings.mode = MODE_VGA;
1112fb68 1359 dev->frame_size = 640 * 480 * 2;
ec16dae5
JVJ		 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);
b57ce417 1367 if (err)
4aaec3ea 1368 goto error;
ec16dae5 1369
ec16dae5 1370 return 0;
4aaec3ea
DE		 1371
1372error:
dc0fb286 1373 v4l2_ctrl_handler_free(hdl);
968c60f6 1374 v4l2_device_unregister(&dev->v4l2_dev);
4aaec3ea
DE		 1375 kfree(dev);
1376 return err;
ec16dae5
JVJ		 1377}
1378
1379static 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);
ec16dae5 1387
f1bd9bd6
JP		 1388 pr_info("Syntek USB2.0 Camera release resources device %s\n",
1389 video_device_node_name(&dev->vdev));
4aaec3ea
DE		 1390
1391 video_unregister_device(&dev->vdev);
dc0fb286 1392 v4l2_ctrl_handler_free(&dev->hdl);
968c60f6 1393 v4l2_device_unregister(&dev->v4l2_dev);
6e298d58 1394 kfree(dev);
ec16dae5
JVJ		 1395}
1396
1fdd61c0 1397#ifdef CONFIG_PM
4d34dccd 1398static int stk_camera_suspend(struct usb_interface *intf, pm_message_t message)
1fdd61c0
JVJ		 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
4d34dccd 1409static int stk_camera_resume(struct usb_interface *intf)
1fdd61c0
JVJ		 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);
7b1c8f58 1416 stk_camera_write_reg(dev, 0x0, 0x49);
1fdd61c0
JVJ		 1417 stk_setup_format(dev);
1418 if (is_streaming(dev))
1419 stk_start_stream(dev);
1420 return 0;
1421}
1422#endif
1423
ec16dae5
JVJ		 1424static struct usb_driver stk_camera_driver = {
1425 .name = "stkwebcam",
1426 .probe = stk_camera_probe,
1427 .disconnect = stk_camera_disconnect,
1428 .id_table = stkwebcam_table,
1fdd61c0
JVJ		 1429#ifdef CONFIG_PM
1430 .suspend = stk_camera_suspend,
1431 .resume = stk_camera_resume,
1432#endif
ec16dae5
JVJ		 1433};
1434
ecb3b2b3 1435module_usb_driver(stk_camera_driver);
Linux 6.x block layer and io_uring tree(s)