projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] move soc_camera i2c drivers into its own dir
[linux-2.6-block.git] / drivers / media / video / vivi.c
CommitLineData
1e6dd65e
MCC		 1/*
2 * Virtual Video driver - This code emulates a real video device with v4l2 api
3 *
4 * Copyright (c) 2006 by:
5 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
6 * Ted Walther <ted--a.t--enumera.com>
7 * John Sokol <sokol--a.t--videotechnology.com>
8 * http://v4l.videotechnology.com/
9 *
e007a325
PO		 10 * Conversion to videobuf2 by Pawel Osciak & Marek Szyprowski
11 * Copyright (c) 2010 Samsung Electronics
12 *
1e6dd65e
MCC		 13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the BSD Licence, GNU General Public License
15 * as published by the Free Software Foundation; either version 2 of the
16 * License, or (at your option) any later version
17 */
18#include <linux/module.h>
1e6dd65e 19#include <linux/errno.h>
1e6dd65e 20#include <linux/kernel.h>
1e6dd65e
MCC		 21#include <linux/init.h>
22#include <linux/sched.h>
6b46c397 23#include <linux/slab.h>
730947bc 24#include <linux/font.h>
51b54029 25#include <linux/mutex.h>
1e6dd65e 26#include <linux/videodev2.h>
1e6dd65e 27#include <linux/kthread.h>
7dfb7103 28#include <linux/freezer.h>
e007a325 29#include <media/videobuf2-vmalloc.h>
5ab6c9af
HV		 30#include <media/v4l2-device.h>
31#include <media/v4l2-ioctl.h>
7e996afa 32#include <media/v4l2-ctrls.h>
2e4784d0 33#include <media/v4l2-fh.h>
c7a52f8d 34#include <media/v4l2-event.h>
730947bc 35#include <media/v4l2-common.h>
1e6dd65e 36
584ce48d 37#define VIVI_MODULE_NAME "vivi"
745271ae 38
1e6dd65e
MCC		 39/* Wake up at about 30 fps */
40#define WAKE_NUMERATOR 30
41#define WAKE_DENOMINATOR 1001
42#define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */
43
730947bc
HV		 44#define MAX_WIDTH 1920
45#define MAX_HEIGHT 1200
46
1990d50b 47#define VIVI_VERSION "0.8.1"
1e6dd65e 48
5ab6c9af
HV		 49MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
50MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
51MODULE_LICENSE("Dual BSD/GPL");
1990d50b 52MODULE_VERSION(VIVI_VERSION);
5ab6c9af
HV		 53
54static unsigned video_nr = -1;
55module_param(video_nr, uint, 0644);
56MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
57
58static unsigned n_devs = 1;
59module_param(n_devs, uint, 0644);
60MODULE_PARM_DESC(n_devs, "number of video devices to create");
61
62static unsigned debug;
63module_param(debug, uint, 0644);
64MODULE_PARM_DESC(debug, "activates debug info");
65
66static unsigned int vid_limit = 16;
67module_param(vid_limit, uint, 0644);
68MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
69
730947bc
HV		 70/* Global font descriptor */
71static const u8 *font8x16;
1e6dd65e 72
5ab6c9af
HV		 73#define dprintk(dev, level, fmt, arg...) \
74 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
1e6dd65e
MCC		 75
76/* ------------------------------------------------------------------
77 Basic structures
78 ------------------------------------------------------------------*/
79
80struct vivi_fmt {
81 char *name;
82 u32 fourcc; /* v4l2 format id */
0a3a8a36
HV		 83 u8 depth;
84 bool is_yuv;
1e6dd65e
MCC		 85};
86
d891f475
MD		 87static struct vivi_fmt formats[] = {
88 {
89 .name = "4:2:2, packed, YUYV",
90 .fourcc = V4L2_PIX_FMT_YUYV,
91 .depth = 16,
0a3a8a36 92 .is_yuv = true,
d891f475 93 },
fca36bab
MD		 94 {
95 .name = "4:2:2, packed, UYVY",
96 .fourcc = V4L2_PIX_FMT_UYVY,
97 .depth = 16,
0a3a8a36 98 .is_yuv = true,
fca36bab 99 },
3d51dca2
HV		 100 {
101 .name = "4:2:2, packed, YVYU",
102 .fourcc = V4L2_PIX_FMT_YVYU,
103 .depth = 16,
0a3a8a36 104 .is_yuv = true,
3d51dca2
HV		 105 },
106 {
107 .name = "4:2:2, packed, VYUY",
108 .fourcc = V4L2_PIX_FMT_VYUY,
109 .depth = 16,
0a3a8a36 110 .is_yuv = true,
3d51dca2 111 },
aeadb5d4
MD		 112 {
113 .name = "RGB565 (LE)",
114 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
115 .depth = 16,
116 },
117 {
118 .name = "RGB565 (BE)",
119 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
120 .depth = 16,
121 },
def52393
MD		 122 {
123 .name = "RGB555 (LE)",
124 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
125 .depth = 16,
126 },
127 {
128 .name = "RGB555 (BE)",
129 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
130 .depth = 16,
131 },
3d51dca2
HV		 132 {
133 .name = "RGB24 (LE)",
134 .fourcc = V4L2_PIX_FMT_RGB24, /* rgb */
135 .depth = 24,
136 },
137 {
138 .name = "RGB24 (BE)",
139 .fourcc = V4L2_PIX_FMT_BGR24, /* bgr */
140 .depth = 24,
141 },
142 {
143 .name = "RGB32 (LE)",
144 .fourcc = V4L2_PIX_FMT_RGB32, /* argb */
145 .depth = 32,
146 },
147 {
148 .name = "RGB32 (BE)",
149 .fourcc = V4L2_PIX_FMT_BGR32, /* bgra */
150 .depth = 32,
151 },
1e6dd65e
MCC		 152};
153
d891f475
MD		 154static struct vivi_fmt *get_format(struct v4l2_format *f)
155{
156 struct vivi_fmt *fmt;
157 unsigned int k;
158
159 for (k = 0; k < ARRAY_SIZE(formats); k++) {
160 fmt = &formats[k];
161 if (fmt->fourcc == f->fmt.pix.pixelformat)
162 break;
163 }
164
165 if (k == ARRAY_SIZE(formats))
166 return NULL;
167
168 return &formats[k];
169}
170
1e6dd65e
MCC		 171/* buffer for one video frame */
172struct vivi_buffer {
173 /* common v4l buffer stuff -- must be first */
e007a325
PO		 174 struct vb2_buffer vb;
175 struct list_head list;
1e6dd65e 176 struct vivi_fmt *fmt;
1e6dd65e
MCC		 177};
178
179struct vivi_dmaqueue {
180 struct list_head active;
1e6dd65e
MCC		 181
182 /* thread for generating video stream*/
183 struct task_struct *kthread;
184 wait_queue_head_t wq;
185 /* Counters to control fps rate */
186 int frame;
187 int ini_jiffies;
188};
189
190static LIST_HEAD(vivi_devlist);
191
192struct vivi_dev {
193 struct list_head vivi_devlist;
5ab6c9af 194 struct v4l2_device v4l2_dev;
7e996afa 195 struct v4l2_ctrl_handler ctrl_handler;
70bd97ae 196 struct video_device vdev;
1e6dd65e 197
730947bc 198 /* controls */
7e996afa
HV		 199 struct v4l2_ctrl *brightness;
200 struct v4l2_ctrl *contrast;
201 struct v4l2_ctrl *saturation;
202 struct v4l2_ctrl *hue;
a1c894fb
HV		 203 struct {
204 /* autogain/gain cluster */
205 struct v4l2_ctrl *autogain;
206 struct v4l2_ctrl *gain;
207 };
7e996afa 208 struct v4l2_ctrl *volume;
7088f4df 209 struct v4l2_ctrl *alpha;
7e996afa
HV		 210 struct v4l2_ctrl *button;
211 struct v4l2_ctrl *boolean;
212 struct v4l2_ctrl *int32;
213 struct v4l2_ctrl *int64;
214 struct v4l2_ctrl *menu;
215 struct v4l2_ctrl *string;
b6d17a56 216 struct v4l2_ctrl *bitmask;
c520331a 217 struct v4l2_ctrl *int_menu;
730947bc 218
55862ac9 219 spinlock_t slock;
aa9dbac4 220 struct mutex mutex;
1e6dd65e 221
1e6dd65e
MCC		 222 struct vivi_dmaqueue vidq;
223
224 /* Several counters */
730947bc 225 unsigned ms;
dfd8c04e 226 unsigned long jiffies;
7e996afa 227 unsigned button_pressed;
025341d4
MCC		 228
229 int mv_count; /* Controls bars movement */
e164b58a
MCC		 230
231 /* Input Number */
232 int input;
c41ee24b 233
1e6dd65e
MCC		 234 /* video capture */
235 struct vivi_fmt *fmt;
543323bc 236 unsigned int width, height;
e007a325 237 struct vb2_queue vb_vidq;
e007a325 238 unsigned int field_count;
1e6dd65e 239
3d51dca2
HV		 240 u8 bars[9][3];
241 u8 line[MAX_WIDTH * 8];
242 unsigned int pixelsize;
7088f4df 243 u8 alpha_component;
1e6dd65e
MCC		 244};
245
246/* ------------------------------------------------------------------
247 DMA and thread functions
248 ------------------------------------------------------------------*/
249
250/* Bars and Colors should match positions */
251
252enum colors {
253 WHITE,
730947bc 254 AMBER,
1e6dd65e
MCC		 255 CYAN,
256 GREEN,
257 MAGENTA,
258 RED,
543323bc
MCC		 259 BLUE,
260 BLACK,
730947bc 261 TEXT_BLACK,
1e6dd65e
MCC		 262};
263
730947bc 264/* R G B */
e164b58a 265#define COLOR_WHITE {204, 204, 204}
730947bc
HV		 266#define COLOR_AMBER {208, 208, 0}
267#define COLOR_CYAN { 0, 206, 206}
e164b58a
MCC		 268#define COLOR_GREEN { 0, 239, 0}
269#define COLOR_MAGENTA {239, 0, 239}
270#define COLOR_RED {205, 0, 0}
271#define COLOR_BLUE { 0, 0, 255}
272#define COLOR_BLACK { 0, 0, 0}
273
274struct bar_std {
730947bc 275 u8 bar[9][3];
e164b58a
MCC		 276};
277
278/* Maximum number of bars are 10 - otherwise, the input print code
279 should be modified */
280static struct bar_std bars[] = {
281 { /* Standard ITU-R color bar sequence */
730947bc
HV		 282 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
283 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
e164b58a 284 }, {
730947bc
HV		 285 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
286 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
e164b58a 287 }, {
730947bc
HV		 288 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
289 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
e164b58a 290 }, {
730947bc
HV		 291 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
292 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
e164b58a 293 },
1e6dd65e
MCC		 294};
295
e164b58a
MCC		 296#define NUM_INPUTS ARRAY_SIZE(bars)
297
543323bc
MCC		 298#define TO_Y(r, g, b) \
299 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
1e6dd65e 300/* RGB to V(Cr) Color transform */
543323bc
MCC		 301#define TO_V(r, g, b) \
302 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
1e6dd65e 303/* RGB to U(Cb) Color transform */
543323bc
MCC		 304#define TO_U(r, g, b) \
305 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
1e6dd65e 306
c285addb 307/* precalculate color bar values to speed up rendering */
730947bc 308static void precalculate_bars(struct vivi_dev *dev)
c285addb 309{
730947bc 310 u8 r, g, b;
c285addb
MCC		 311 int k, is_yuv;
312
730947bc
HV		 313 for (k = 0; k < 9; k++) {
314 r = bars[dev->input].bar[k][0];
315 g = bars[dev->input].bar[k][1];
316 b = bars[dev->input].bar[k][2];
0a3a8a36 317 is_yuv = dev->fmt->is_yuv;
c285addb 318
730947bc 319 switch (dev->fmt->fourcc) {
c285addb
MCC		 320 case V4L2_PIX_FMT_RGB565:
321 case V4L2_PIX_FMT_RGB565X:
322 r >>= 3;
323 g >>= 2;
324 b >>= 3;
325 break;
326 case V4L2_PIX_FMT_RGB555:
327 case V4L2_PIX_FMT_RGB555X:
328 r >>= 3;
329 g >>= 3;
330 b >>= 3;
331 break;
0a3a8a36
HV		 332 case V4L2_PIX_FMT_YUYV:
333 case V4L2_PIX_FMT_UYVY:
334 case V4L2_PIX_FMT_YVYU:
335 case V4L2_PIX_FMT_VYUY:
3d51dca2
HV		 336 case V4L2_PIX_FMT_RGB24:
337 case V4L2_PIX_FMT_BGR24:
338 case V4L2_PIX_FMT_RGB32:
339 case V4L2_PIX_FMT_BGR32:
340 break;
c285addb
MCC		 341 }
342
343 if (is_yuv) {
730947bc
HV		 344 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
345 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
346 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
c285addb 347 } else {
730947bc
HV		 348 dev->bars[k][0] = r;
349 dev->bars[k][1] = g;
350 dev->bars[k][2] = b;
c285addb
MCC		 351 }
352 }
c285addb
MCC		 353}
354
e164b58a
MCC		 355#define TSTAMP_MIN_Y 24
356#define TSTAMP_MAX_Y (TSTAMP_MIN_Y + 15)
357#define TSTAMP_INPUT_X 10
358#define TSTAMP_MIN_X (54 + TSTAMP_INPUT_X)
1e6dd65e 359
3d51dca2
HV		 360/* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
361static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos, bool odd)
74d7c5af 362{
730947bc 363 u8 r_y, g_u, b_v;
7088f4df 364 u8 alpha = dev->alpha_component;
74d7c5af 365 int color;
730947bc 366 u8 *p;
74d7c5af 367
730947bc
HV		 368 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
369 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
370 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
74d7c5af 371
3d51dca2 372 for (color = 0; color < dev->pixelsize; color++) {
74d7c5af
MD		 373 p = buf + color;
374
730947bc 375 switch (dev->fmt->fourcc) {
d891f475
MD		 376 case V4L2_PIX_FMT_YUYV:
377 switch (color) {
378 case 0:
d891f475
MD		 379 *p = r_y;
380 break;
381 case 1:
3d51dca2 382 *p = odd ? b_v : g_u;
d891f475
MD		 383 break;
384 }
74d7c5af 385 break;
fca36bab
MD		 386 case V4L2_PIX_FMT_UYVY:
387 switch (color) {
3d51dca2
HV		 388 case 0:
389 *p = odd ? b_v : g_u;
390 break;
fca36bab 391 case 1:
fca36bab
MD		 392 *p = r_y;
393 break;
3d51dca2
HV		 394 }
395 break;
396 case V4L2_PIX_FMT_YVYU:
397 switch (color) {
398 case 0:
399 *p = r_y;
400 break;
401 case 1:
402 *p = odd ? g_u : b_v;
403 break;
404 }
405 break;
406 case V4L2_PIX_FMT_VYUY:
407 switch (color) {
fca36bab 408 case 0:
3d51dca2 409 *p = odd ? g_u : b_v;
fca36bab 410 break;
3d51dca2
HV		 411 case 1:
412 *p = r_y;
fca36bab
MD		 413 break;
414 }
415 break;
aeadb5d4
MD		 416 case V4L2_PIX_FMT_RGB565:
417 switch (color) {
418 case 0:
aeadb5d4
MD		 419 *p = (g_u << 5) | b_v;
420 break;
421 case 1:
aeadb5d4
MD		 422 *p = (r_y << 3) | (g_u >> 3);
423 break;
424 }
425 break;
426 case V4L2_PIX_FMT_RGB565X:
427 switch (color) {
428 case 0:
aeadb5d4
MD		 429 *p = (r_y << 3) | (g_u >> 3);
430 break;
431 case 1:
aeadb5d4
MD		 432 *p = (g_u << 5) | b_v;
433 break;
434 }
435 break;
def52393
MD		 436 case V4L2_PIX_FMT_RGB555:
437 switch (color) {
438 case 0:
def52393
MD		 439 *p = (g_u << 5) | b_v;
440 break;
441 case 1:
7088f4df 442 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
def52393
MD		 443 break;
444 }
445 break;
446 case V4L2_PIX_FMT_RGB555X:
447 switch (color) {
448 case 0:
7088f4df 449 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
def52393
MD		 450 break;
451 case 1:
def52393
MD		 452 *p = (g_u << 5) | b_v;
453 break;
454 }
455 break;
3d51dca2
HV		 456 case V4L2_PIX_FMT_RGB24:
457 switch (color) {
458 case 0:
459 *p = r_y;
460 break;
461 case 1:
462 *p = g_u;
463 break;
464 case 2:
465 *p = b_v;
466 break;
467 }
468 break;
469 case V4L2_PIX_FMT_BGR24:
470 switch (color) {
471 case 0:
472 *p = b_v;
473 break;
474 case 1:
475 *p = g_u;
476 break;
477 case 2:
478 *p = r_y;
479 break;
480 }
481 break;
482 case V4L2_PIX_FMT_RGB32:
483 switch (color) {
484 case 0:
7088f4df 485 *p = alpha;
3d51dca2
HV		 486 break;
487 case 1:
488 *p = r_y;
489 break;
490 case 2:
491 *p = g_u;
492 break;
493 case 3:
494 *p = b_v;
495 break;
496 }
497 break;
498 case V4L2_PIX_FMT_BGR32:
499 switch (color) {
500 case 0:
501 *p = b_v;
502 break;
503 case 1:
504 *p = g_u;
505 break;
506 case 2:
507 *p = r_y;
508 break;
509 case 3:
7088f4df 510 *p = alpha;
3d51dca2
HV		 511 break;
512 }
513 break;
74d7c5af
MD		 514 }
515 }
516}
517
730947bc 518static void precalculate_line(struct vivi_dev *dev)
1e6dd65e 519{
730947bc 520 int w;
1e6dd65e 521
3d51dca2
HV		 522 for (w = 0; w < dev->width * 2; w++) {
523 int colorpos = w / (dev->width / 8) % 8;
74d7c5af 524
3d51dca2 525 gen_twopix(dev, dev->line + w * dev->pixelsize, colorpos, w & 1);
1e6dd65e 526 }
730947bc 527}
1e6dd65e 528
730947bc
HV		 529static void gen_text(struct vivi_dev *dev, char *basep,
530 int y, int x, char *text)
531{
532 int line;
e164b58a 533
730947bc
HV		 534 /* Checks if it is possible to show string */
535 if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
536 return;
1e6dd65e
MCC		 537
538 /* Print stream time */
730947bc
HV		 539 for (line = y; line < y + 16; line++) {
540 int j = 0;
3d51dca2 541 char *pos = basep + line * dev->width * dev->pixelsize + x * dev->pixelsize;
730947bc
HV		 542 char *s;
543
544 for (s = text; *s; s++) {
545 u8 chr = font8x16[*s * 16 + line - y];
546 int i;
547
548 for (i = 0; i < 7; i++, j++) {
74d7c5af 549 /* Draw white font on black background */
730947bc 550 if (chr & (1 << (7 - i)))
3d51dca2 551 gen_twopix(dev, pos + j * dev->pixelsize, WHITE, (x+y) & 1);
74d7c5af 552 else
3d51dca2 553 gen_twopix(dev, pos + j * dev->pixelsize, TEXT_BLACK, (x+y) & 1);
1e6dd65e
MCC		 554 }
555 }
556 }
1e6dd65e 557}
78718e5d 558
730947bc 559static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
1e6dd65e 560{
e007a325
PO		 561 int wmax = dev->width;
562 int hmax = dev->height;
1e6dd65e 563 struct timeval ts;
e007a325 564 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
730947bc
HV		 565 unsigned ms;
566 char str[100];
567 int h, line = 1;
a1c894fb 568 s32 gain;
b50e7fe9 569
5c554e6b 570 if (!vbuf)
5a037706 571 return;
1e6dd65e 572
730947bc 573 for (h = 0; h < hmax; h++)
3d51dca2
HV		 574 memcpy(vbuf + h * wmax * dev->pixelsize,
575 dev->line + (dev->mv_count % wmax) * dev->pixelsize,
576 wmax * dev->pixelsize);
5a037706 577
1e6dd65e
MCC		 578 /* Updates stream time */
579
730947bc 580 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
543323bc 581 dev->jiffies = jiffies;
730947bc
HV		 582 ms = dev->ms;
583 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
584 (ms / (60 * 60 * 1000)) % 24,
585 (ms / (60 * 1000)) % 60,
586 (ms / 1000) % 60,
587 ms % 1000);
588 gen_text(dev, vbuf, line++ * 16, 16, str);
589 snprintf(str, sizeof(str), " %dx%d, input %d ",
590 dev->width, dev->height, dev->input);
591 gen_text(dev, vbuf, line++ * 16, 16, str);
592
a1c894fb 593 gain = v4l2_ctrl_g_ctrl(dev->gain);
77e7c4e6 594 mutex_lock(dev->ctrl_handler.lock);
730947bc 595 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
7e996afa
HV		 596 dev->brightness->cur.val,
597 dev->contrast->cur.val,
598 dev->saturation->cur.val,
599 dev->hue->cur.val);
730947bc 600 gen_text(dev, vbuf, line++ * 16, 16, str);
7088f4df
HV		 601 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d, alpha 0x%02x ",
602 dev->autogain->cur.val, gain, dev->volume->cur.val,
603 dev->alpha->cur.val);
730947bc 604 gen_text(dev, vbuf, line++ * 16, 16, str);
b6d17a56 605 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
7e996afa 606 dev->int32->cur.val,
b6d17a56
HV		 607 dev->int64->cur.val64,
608 dev->bitmask->cur.val);
7e996afa
HV		 609 gen_text(dev, vbuf, line++ * 16, 16, str);
610 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
611 dev->boolean->cur.val,
612 dev->menu->qmenu[dev->menu->cur.val],
613 dev->string->cur.string);
f70cfc7f 614 gen_text(dev, vbuf, line++ * 16, 16, str);
c520331a
SA		 615 snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
616 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
617 dev->int_menu->cur.val);
618 gen_text(dev, vbuf, line++ * 16, 16, str);
77e7c4e6 619 mutex_unlock(dev->ctrl_handler.lock);
7e996afa
HV		 620 if (dev->button_pressed) {
621 dev->button_pressed--;
622 snprintf(str, sizeof(str), " button pressed!");
623 gen_text(dev, vbuf, line++ * 16, 16, str);
624 }
730947bc
HV		 625
626 dev->mv_count += 2;
1e6dd65e 627
cd779254 628 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
e007a325
PO		 629 dev->field_count++;
630 buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
1e6dd65e 631 do_gettimeofday(&ts);
e007a325 632 buf->vb.v4l2_buf.timestamp = ts;
1e6dd65e
MCC		 633}
634
730947bc 635static void vivi_thread_tick(struct vivi_dev *dev)
1e6dd65e 636{
78718e5d 637 struct vivi_dmaqueue *dma_q = &dev->vidq;
730947bc 638 struct vivi_buffer *buf;
78718e5d 639 unsigned long flags = 0;
1e6dd65e 640
78718e5d 641 dprintk(dev, 1, "Thread tick\n");
1e6dd65e 642
78718e5d
BP		 643 spin_lock_irqsave(&dev->slock, flags);
644 if (list_empty(&dma_q->active)) {
645 dprintk(dev, 1, "No active queue to serve\n");
1de5be5e
HV		 646 spin_unlock_irqrestore(&dev->slock, flags);
647 return;
78718e5d 648 }
1e6dd65e 649
e007a325
PO		 650 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
651 list_del(&buf->list);
1de5be5e 652 spin_unlock_irqrestore(&dev->slock, flags);
1e6dd65e 653
e007a325 654 do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
78718e5d
BP		 655
656 /* Fill buffer */
730947bc 657 vivi_fillbuff(dev, buf);
78718e5d
BP		 658 dprintk(dev, 1, "filled buffer %p\n", buf);
659
e007a325
PO		 660 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
661 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
1e6dd65e
MCC		 662}
663
6594ad82
MCC		 664#define frames_to_ms(frames) \
665 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
666
730947bc 667static void vivi_sleep(struct vivi_dev *dev)
1e6dd65e 668{
78718e5d
BP		 669 struct vivi_dmaqueue *dma_q = &dev->vidq;
670 int timeout;
1e6dd65e
MCC		 671 DECLARE_WAITQUEUE(wait, current);
672
7e28adb2 673 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
6c2f9901 674 (unsigned long)dma_q);
1e6dd65e
MCC		 675
676 add_wait_queue(&dma_q->wq, &wait);
6594ad82
MCC		 677 if (kthread_should_stop())
678 goto stop_task;
679
6594ad82 680 /* Calculate time to wake up */
78718e5d 681 timeout = msecs_to_jiffies(frames_to_ms(1));
6594ad82 682
730947bc 683 vivi_thread_tick(dev);
6594ad82
MCC		 684
685 schedule_timeout_interruptible(timeout);
1e6dd65e 686
6594ad82 687stop_task:
1e6dd65e
MCC		 688 remove_wait_queue(&dma_q->wq, &wait);
689 try_to_freeze();
690}
691
972c3517 692static int vivi_thread(void *data)
1e6dd65e 693{
730947bc 694 struct vivi_dev *dev = data;
1e6dd65e 695
6c2f9901 696 dprintk(dev, 1, "thread started\n");
1e6dd65e 697
83144186 698 set_freezable();
0b600512 699
1e6dd65e 700 for (;;) {
730947bc 701 vivi_sleep(dev);
1e6dd65e
MCC		 702
703 if (kthread_should_stop())
704 break;
705 }
6c2f9901 706 dprintk(dev, 1, "thread: exit\n");
1e6dd65e
MCC		 707 return 0;
708}
709
e007a325 710static int vivi_start_generating(struct vivi_dev *dev)
1e6dd65e 711{
78718e5d 712 struct vivi_dmaqueue *dma_q = &dev->vidq;
6c2f9901 713
7e28adb2 714 dprintk(dev, 1, "%s\n", __func__);
1e6dd65e 715
730947bc
HV		 716 /* Resets frame counters */
717 dev->ms = 0;
718 dev->mv_count = 0;
719 dev->jiffies = jiffies;
720
721 dma_q->frame = 0;
722 dma_q->ini_jiffies = jiffies;
723 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
1e6dd65e 724
054afee4 725 if (IS_ERR(dma_q->kthread)) {
5ab6c9af 726 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
e007a325 727 return PTR_ERR(dma_q->kthread);
1e6dd65e 728 }
0b600512
MCC		 729 /* Wakes thread */
730 wake_up_interruptible(&dma_q->wq);
731
7e28adb2 732 dprintk(dev, 1, "returning from %s\n", __func__);
e007a325 733 return 0;
1e6dd65e
MCC		 734}
735
e007a325 736static void vivi_stop_generating(struct vivi_dev *dev)
1e6dd65e 737{
730947bc 738 struct vivi_dmaqueue *dma_q = &dev->vidq;
6c2f9901 739
7e28adb2 740 dprintk(dev, 1, "%s\n", __func__);
730947bc 741
1e6dd65e
MCC		 742 /* shutdown control thread */
743 if (dma_q->kthread) {
744 kthread_stop(dma_q->kthread);
543323bc 745 dma_q->kthread = NULL;
1e6dd65e 746 }
730947bc 747
e007a325
PO		 748 /*
749 * Typical driver might need to wait here until dma engine stops.
750 * In this case we can abort imiedetly, so it's just a noop.
751 */
752
753 /* Release all active buffers */
754 while (!list_empty(&dma_q->active)) {
755 struct vivi_buffer *buf;
756 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
757 list_del(&buf->list);
758 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
759 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
760 }
1e6dd65e 761}
1e6dd65e
MCC		 762/* ------------------------------------------------------------------
763 Videobuf operations
764 ------------------------------------------------------------------*/
fc714e70
GL		 765static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
766 unsigned int *nbuffers, unsigned int *nplanes,
767 unsigned int sizes[], void *alloc_ctxs[])
1e6dd65e 768{
e007a325
PO		 769 struct vivi_dev *dev = vb2_get_drv_priv(vq);
770 unsigned long size;
771
2e90c6c3
HV		 772 if (fmt)
773 size = fmt->fmt.pix.sizeimage;
774 else
775 size = dev->width * dev->height * dev->pixelsize;
776
777 if (size == 0)
778 return -EINVAL;
1e6dd65e 779
e007a325
PO		 780 if (0 == *nbuffers)
781 *nbuffers = 32;
1e6dd65e 782
e007a325
PO		 783 while (size * *nbuffers > vid_limit * 1024 * 1024)
784 (*nbuffers)--;
6bb2790f 785
e007a325 786 *nplanes = 1;
6bb2790f 787
e007a325
PO		 788 sizes[0] = size;
789
790 /*
791 * videobuf2-vmalloc allocator is context-less so no need to set
792 * alloc_ctxs array.
793 */
794
795 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
796 *nbuffers, size);
6bb2790f 797
1e6dd65e
MCC		 798 return 0;
799}
800
e007a325 801static int buffer_prepare(struct vb2_buffer *vb)
1e6dd65e 802{
e007a325 803 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
543323bc 804 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
e007a325 805 unsigned long size;
1e6dd65e 806
e007a325 807 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
1e6dd65e 808
730947bc 809 BUG_ON(NULL == dev->fmt);
78718e5d 810
e007a325
PO		 811 /*
812 * Theses properties only change when queue is idle, see s_fmt.
813 * The below checks should not be performed here, on each
814 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
815 * should thus be moved to buffer_init and s_fmt.
816 */
730947bc
HV		 817 if (dev->width < 48 || dev->width > MAX_WIDTH ||
818 dev->height < 32 || dev->height > MAX_HEIGHT)
1e6dd65e 819 return -EINVAL;
78718e5d 820
3d51dca2 821 size = dev->width * dev->height * dev->pixelsize;
e007a325
PO		 822 if (vb2_plane_size(vb, 0) < size) {
823 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
824 __func__, vb2_plane_size(vb, 0), size);
1e6dd65e 825 return -EINVAL;
e007a325
PO		 826 }
827
828 vb2_set_plane_payload(&buf->vb, 0, size);
1e6dd65e 829
e007a325 830 buf->fmt = dev->fmt;
1e6dd65e 831
730947bc
HV		 832 precalculate_bars(dev);
833 precalculate_line(dev);
c285addb 834
e007a325
PO		 835 return 0;
836}
1e6dd65e 837
e007a325 838static void buffer_queue(struct vb2_buffer *vb)
1e6dd65e 839{
e007a325 840 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
730947bc 841 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
78718e5d 842 struct vivi_dmaqueue *vidq = &dev->vidq;
e007a325 843 unsigned long flags = 0;
78718e5d 844
7e28adb2 845 dprintk(dev, 1, "%s\n", __func__);
78718e5d 846
e007a325
PO		 847 spin_lock_irqsave(&dev->slock, flags);
848 list_add_tail(&buf->list, &vidq->active);
849 spin_unlock_irqrestore(&dev->slock, flags);
1e6dd65e
MCC		 850}
851
bd323e28 852static int start_streaming(struct vb2_queue *vq, unsigned int count)
1e6dd65e 853{
e007a325
PO		 854 struct vivi_dev *dev = vb2_get_drv_priv(vq);
855 dprintk(dev, 1, "%s\n", __func__);
856 return vivi_start_generating(dev);
857}
1e6dd65e 858
e007a325
PO		 859/* abort streaming and wait for last buffer */
860static int stop_streaming(struct vb2_queue *vq)
861{
862 struct vivi_dev *dev = vb2_get_drv_priv(vq);
7e28adb2 863 dprintk(dev, 1, "%s\n", __func__);
e007a325
PO		 864 vivi_stop_generating(dev);
865 return 0;
866}
867
868static void vivi_lock(struct vb2_queue *vq)
869{
870 struct vivi_dev *dev = vb2_get_drv_priv(vq);
871 mutex_lock(&dev->mutex);
872}
1e6dd65e 873
e007a325
PO		 874static void vivi_unlock(struct vb2_queue *vq)
875{
876 struct vivi_dev *dev = vb2_get_drv_priv(vq);
877 mutex_unlock(&dev->mutex);
1e6dd65e
MCC		 878}
879
e007a325
PO		 880
881static struct vb2_ops vivi_video_qops = {
882 .queue_setup = queue_setup,
e007a325 883 .buf_prepare = buffer_prepare,
e007a325
PO		 884 .buf_queue = buffer_queue,
885 .start_streaming = start_streaming,
886 .stop_streaming = stop_streaming,
887 .wait_prepare = vivi_unlock,
888 .wait_finish = vivi_lock,
1e6dd65e
MCC		 889};
890
c820cc45
MCC		 891/* ------------------------------------------------------------------
892 IOCTL vidioc handling
893 ------------------------------------------------------------------*/
543323bc 894static int vidioc_querycap(struct file *file, void *priv,
c820cc45
MCC		 895 struct v4l2_capability *cap)
896{
730947bc 897 struct vivi_dev *dev = video_drvdata(file);
5ab6c9af 898
c820cc45
MCC		 899 strcpy(cap->driver, "vivi");
900 strcpy(cap->card, "vivi");
5ab6c9af 901 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
23268ae5
HV		 902 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
903 V4L2_CAP_READWRITE;
904 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
c820cc45
MCC		 905 return 0;
906}
907
78b526a4 908static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
c820cc45
MCC		 909 struct v4l2_fmtdesc *f)
910{
d891f475
MD		 911 struct vivi_fmt *fmt;
912
913 if (f->index >= ARRAY_SIZE(formats))
c820cc45
MCC		 914 return -EINVAL;
915
d891f475
MD		 916 fmt = &formats[f->index];
917
918 strlcpy(f->description, fmt->name, sizeof(f->description));
919 f->pixelformat = fmt->fourcc;
c820cc45
MCC		 920 return 0;
921}
922
78b526a4 923static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
c820cc45
MCC		 924 struct v4l2_format *f)
925{
730947bc 926 struct vivi_dev *dev = video_drvdata(file);
c820cc45 927
730947bc
HV		 928 f->fmt.pix.width = dev->width;
929 f->fmt.pix.height = dev->height;
cd779254 930 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
730947bc 931 f->fmt.pix.pixelformat = dev->fmt->fourcc;
c820cc45 932 f->fmt.pix.bytesperline =
730947bc 933 (f->fmt.pix.width * dev->fmt->depth) >> 3;
c820cc45
MCC		 934 f->fmt.pix.sizeimage =
935 f->fmt.pix.height * f->fmt.pix.bytesperline;
0a3a8a36 936 if (dev->fmt->is_yuv)
8c79eece
HV		 937 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
938 else
939 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
730947bc 940 return 0;
c820cc45
MCC		 941}
942
78b526a4 943static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1e6dd65e
MCC		 944 struct v4l2_format *f)
945{
730947bc 946 struct vivi_dev *dev = video_drvdata(file);
1e6dd65e 947 struct vivi_fmt *fmt;
1e6dd65e 948
d891f475
MD		 949 fmt = get_format(f);
950 if (!fmt) {
cd779254 951 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
d891f475 952 f->fmt.pix.pixelformat);
cd779254
HV		 953 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
954 fmt = get_format(f);
1e6dd65e
MCC		 955 }
956
cd779254 957 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
730947bc
HV		 958 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
959 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
1e6dd65e
MCC		 960 f->fmt.pix.bytesperline =
961 (f->fmt.pix.width * fmt->depth) >> 3;
962 f->fmt.pix.sizeimage =
963 f->fmt.pix.height * f->fmt.pix.bytesperline;
0a3a8a36 964 if (fmt->is_yuv)
8c79eece
HV		 965 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
966 else
967 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
2f65f467 968 f->fmt.pix.priv = 0;
1e6dd65e
MCC		 969 return 0;
970}
971
e164b58a
MCC		 972static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
973 struct v4l2_format *f)
974{
730947bc 975 struct vivi_dev *dev = video_drvdata(file);
e007a325 976 struct vb2_queue *q = &dev->vb_vidq;
e164b58a 977
730947bc 978 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
e164b58a
MCC		 979 if (ret < 0)
980 return ret;
981
f2ba5a0b 982 if (vb2_is_busy(q)) {
730947bc 983 dprintk(dev, 1, "%s device busy\n", __func__);
e007a325 984 return -EBUSY;
e164b58a
MCC		 985 }
986
730947bc 987 dev->fmt = get_format(f);
3d51dca2 988 dev->pixelsize = dev->fmt->depth / 8;
730947bc
HV		 989 dev->width = f->fmt.pix.width;
990 dev->height = f->fmt.pix.height;
e007a325
PO		 991
992 return 0;
1e6dd65e
MCC		 993}
994
77747f79
HV		 995static int vidioc_enum_framesizes(struct file *file, void *fh,
996 struct v4l2_frmsizeenum *fsize)
997{
998 static const struct v4l2_frmsize_stepwise sizes = {
999 48, MAX_WIDTH, 4,
1000 32, MAX_HEIGHT, 1
1001 };
1002 int i;
1003
1004 if (fsize->index)
1005 return -EINVAL;
1006 for (i = 0; i < ARRAY_SIZE(formats); i++)
1007 if (formats[i].fourcc == fsize->pixel_format)
1008 break;
1009 if (i == ARRAY_SIZE(formats))
1010 return -EINVAL;
1011 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1012 fsize->stepwise = sizes;
1013 return 0;
1014}
1015
c820cc45 1016/* only one input in this sample driver */
543323bc 1017static int vidioc_enum_input(struct file *file, void *priv,
c820cc45
MCC		 1018 struct v4l2_input *inp)
1019{
e164b58a 1020 if (inp->index >= NUM_INPUTS)
c820cc45 1021 return -EINVAL;
1e6dd65e 1022
c820cc45 1023 inp->type = V4L2_INPUT_TYPE_CAMERA;
e164b58a 1024 sprintf(inp->name, "Camera %u", inp->index);
730947bc 1025 return 0;
c820cc45 1026}
1e6dd65e 1027
543323bc 1028static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
c820cc45 1029{
730947bc 1030 struct vivi_dev *dev = video_drvdata(file);
e164b58a
MCC		 1031
1032 *i = dev->input;
730947bc 1033 return 0;
c820cc45 1034}
730947bc 1035
543323bc 1036static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
c820cc45 1037{
730947bc 1038 struct vivi_dev *dev = video_drvdata(file);
e164b58a
MCC		 1039
1040 if (i >= NUM_INPUTS)
c820cc45 1041 return -EINVAL;
1e6dd65e 1042
c7a52f8d
HV		 1043 if (i == dev->input)
1044 return 0;
1045
e164b58a 1046 dev->input = i;
730947bc
HV		 1047 precalculate_bars(dev);
1048 precalculate_line(dev);
1049 return 0;
c820cc45 1050}
1e6dd65e 1051
730947bc 1052/* --- controls ---------------------------------------------- */
1e6dd65e 1053
a1c894fb
HV		 1054static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1055{
1056 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1057
1058 if (ctrl == dev->autogain)
1059 dev->gain->val = jiffies & 0xff;
1060 return 0;
1061}
1062
7e996afa 1063static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
c820cc45 1064{
7e996afa 1065 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1e6dd65e 1066
7088f4df
HV		 1067 switch (ctrl->id) {
1068 case V4L2_CID_ALPHA_COMPONENT:
1069 dev->alpha_component = ctrl->val;
1070 break;
1071 default:
1072 if (ctrl == dev->button)
1073 dev->button_pressed = 30;
1074 break;
1075 }
7e996afa 1076 return 0;
1e6dd65e
MCC		 1077}
1078
1079/* ------------------------------------------------------------------
1080 File operations for the device
1081 ------------------------------------------------------------------*/
1082
7e996afa 1083static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
a1c894fb 1084 .g_volatile_ctrl = vivi_g_volatile_ctrl,
7e996afa
HV		 1085 .s_ctrl = vivi_s_ctrl,
1086};
1087
1088#define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1089
1090static const struct v4l2_ctrl_config vivi_ctrl_button = {
1091 .ops = &vivi_ctrl_ops,
1092 .id = VIVI_CID_CUSTOM_BASE + 0,
1093 .name = "Button",
1094 .type = V4L2_CTRL_TYPE_BUTTON,
1095};
1096
1097static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1098 .ops = &vivi_ctrl_ops,
1099 .id = VIVI_CID_CUSTOM_BASE + 1,
1100 .name = "Boolean",
1101 .type = V4L2_CTRL_TYPE_BOOLEAN,
1102 .min = 0,
1103 .max = 1,
1104 .step = 1,
1105 .def = 1,
1106};
1107
1108static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1109 .ops = &vivi_ctrl_ops,
1110 .id = VIVI_CID_CUSTOM_BASE + 2,
1111 .name = "Integer 32 Bits",
1112 .type = V4L2_CTRL_TYPE_INTEGER,
5b283029
HV		 1113 .min = 0x80000000,
1114 .max = 0x7fffffff,
7e996afa
HV		 1115 .step = 1,
1116};
1117
1118static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1119 .ops = &vivi_ctrl_ops,
1120 .id = VIVI_CID_CUSTOM_BASE + 3,
1121 .name = "Integer 64 Bits",
1122 .type = V4L2_CTRL_TYPE_INTEGER64,
1123};
1124
1125static const char * const vivi_ctrl_menu_strings[] = {
1126 "Menu Item 0 (Skipped)",
1127 "Menu Item 1",
1128 "Menu Item 2 (Skipped)",
1129 "Menu Item 3",
1130 "Menu Item 4",
1131 "Menu Item 5 (Skipped)",
1132 NULL,
1133};
1134
1135static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1136 .ops = &vivi_ctrl_ops,
1137 .id = VIVI_CID_CUSTOM_BASE + 4,
1138 .name = "Menu",
1139 .type = V4L2_CTRL_TYPE_MENU,
1140 .min = 1,
1141 .max = 4,
1142 .def = 3,
1143 .menu_skip_mask = 0x04,
1144 .qmenu = vivi_ctrl_menu_strings,
1145};
1146
1147static const struct v4l2_ctrl_config vivi_ctrl_string = {
1148 .ops = &vivi_ctrl_ops,
1149 .id = VIVI_CID_CUSTOM_BASE + 5,
1150 .name = "String",
1151 .type = V4L2_CTRL_TYPE_STRING,
1152 .min = 2,
1153 .max = 4,
1154 .step = 1,
1155};
1156
b6d17a56
HV		 1157static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1158 .ops = &vivi_ctrl_ops,
1159 .id = VIVI_CID_CUSTOM_BASE + 6,
1160 .name = "Bitmask",
1161 .type = V4L2_CTRL_TYPE_BITMASK,
1162 .def = 0x80002000,
1163 .min = 0,
1164 .max = 0x80402010,
1165 .step = 0,
1166};
1167
c520331a
SA		 1168static const s64 vivi_ctrl_int_menu_values[] = {
1169 1, 1, 2, 3, 5, 8, 13, 21, 42,
1170};
1171
1172static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1173 .ops = &vivi_ctrl_ops,
1174 .id = VIVI_CID_CUSTOM_BASE + 7,
1175 .name = "Integer menu",
1176 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1177 .min = 1,
1178 .max = 8,
1179 .def = 4,
1180 .menu_skip_mask = 0x02,
1181 .qmenu_int = vivi_ctrl_int_menu_values,
1182};
1183
bec43661 1184static const struct v4l2_file_operations vivi_fops = {
1e6dd65e 1185 .owner = THIS_MODULE,
c7a52f8d 1186 .open = v4l2_fh_open,
f2ba5a0b
HV		 1187 .release = vb2_fop_release,
1188 .read = vb2_fop_read,
1189 .poll = vb2_fop_poll,
fedc6c81 1190 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
f2ba5a0b 1191 .mmap = vb2_fop_mmap,
1e6dd65e
MCC		 1192};
1193
a399810c 1194static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
c820cc45 1195 .vidioc_querycap = vidioc_querycap,
78b526a4
HV		 1196 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1197 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1198 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1199 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
77747f79 1200 .vidioc_enum_framesizes = vidioc_enum_framesizes,
f2ba5a0b 1201 .vidioc_reqbufs = vb2_ioctl_reqbufs,
2e90c6c3
HV		 1202 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1203 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
f2ba5a0b
HV		 1204 .vidioc_querybuf = vb2_ioctl_querybuf,
1205 .vidioc_qbuf = vb2_ioctl_qbuf,
1206 .vidioc_dqbuf = vb2_ioctl_dqbuf,
c820cc45
MCC		 1207 .vidioc_enum_input = vidioc_enum_input,
1208 .vidioc_g_input = vidioc_g_input,
1209 .vidioc_s_input = vidioc_s_input,
f2ba5a0b
HV		 1210 .vidioc_streamon = vb2_ioctl_streamon,
1211 .vidioc_streamoff = vb2_ioctl_streamoff,
e2ecb257 1212 .vidioc_log_status = v4l2_ctrl_log_status,
6d6604fa 1213 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
c7a52f8d 1214 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
a399810c
HV		 1215};
1216
1217static struct video_device vivi_template = {
1218 .name = "vivi",
a399810c
HV		 1219 .fops = &vivi_fops,
1220 .ioctl_ops = &vivi_ioctl_ops,
70bd97ae 1221 .release = video_device_release_empty,
1e6dd65e 1222};
5ab6c9af 1223
c820cc45 1224/* -----------------------------------------------------------------
1e6dd65e
MCC		 1225 Initialization and module stuff
1226 ------------------------------------------------------------------*/
1227
5ab6c9af
HV		 1228static int vivi_release(void)
1229{
1230 struct vivi_dev *dev;
1231 struct list_head *list;
980d4f17 1232
5ab6c9af
HV		 1233 while (!list_empty(&vivi_devlist)) {
1234 list = vivi_devlist.next;
1235 list_del(list);
1236 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1237
38c7c036 1238 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
70bd97ae
HV		 1239 video_device_node_name(&dev->vdev));
1240 video_unregister_device(&dev->vdev);
5ab6c9af 1241 v4l2_device_unregister(&dev->v4l2_dev);
7e996afa 1242 v4l2_ctrl_handler_free(&dev->ctrl_handler);
5ab6c9af
HV		 1243 kfree(dev);
1244 }
1245
1246 return 0;
1247}
1248
c41ee24b 1249static int __init vivi_create_instance(int inst)
1e6dd65e 1250{
1e6dd65e 1251 struct vivi_dev *dev;
f905c442 1252 struct video_device *vfd;
7e996afa 1253 struct v4l2_ctrl_handler *hdl;
e007a325 1254 struct vb2_queue *q;
730947bc 1255 int ret;
1e6dd65e 1256
5ab6c9af
HV		 1257 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1258 if (!dev)
1259 return -ENOMEM;
980d4f17 1260
5ab6c9af 1261 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
c41ee24b 1262 "%s-%03d", VIVI_MODULE_NAME, inst);
5ab6c9af
HV		 1263 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1264 if (ret)
1265 goto free_dev;
1e6dd65e 1266
730947bc
HV		 1267 dev->fmt = &formats[0];
1268 dev->width = 640;
1269 dev->height = 480;
3d51dca2 1270 dev->pixelsize = dev->fmt->depth / 8;
7e996afa
HV		 1271 hdl = &dev->ctrl_handler;
1272 v4l2_ctrl_handler_init(hdl, 11);
1273 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1274 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1275 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1276 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1277 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1278 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1279 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1280 V4L2_CID_SATURATION, 0, 255, 1, 127);
1281 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1282 V4L2_CID_HUE, -128, 127, 1, 0);
a1c894fb
HV		 1283 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1284 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1285 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1286 V4L2_CID_GAIN, 0, 255, 1, 100);
7088f4df
HV		 1287 dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1288 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
7e996afa
HV		 1289 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1290 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1291 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1292 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1293 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1294 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
b6d17a56 1295 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
c520331a 1296 dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
7e996afa
HV		 1297 if (hdl->error) {
1298 ret = hdl->error;
1299 goto unreg_dev;
1300 }
a1c894fb 1301 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
7e996afa 1302 dev->v4l2_dev.ctrl_handler = hdl;
730947bc 1303
fedc6c81
HV		 1304 /* initialize locks */
1305 spin_lock_init(&dev->slock);
fedc6c81 1306
e007a325
PO		 1307 /* initialize queue */
1308 q = &dev->vb_vidq;
1309 memset(q, 0, sizeof(dev->vb_vidq));
1310 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1311 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1312 q->drv_priv = dev;
1313 q->buf_struct_size = sizeof(struct vivi_buffer);
1314 q->ops = &vivi_video_qops;
1315 q->mem_ops = &vb2_vmalloc_memops;
1316
1317 vb2_queue_init(q);
1318
1319 mutex_init(&dev->mutex);
730947bc 1320
5ab6c9af
HV		 1321 /* init video dma queues */
1322 INIT_LIST_HEAD(&dev->vidq.active);
1323 init_waitqueue_head(&dev->vidq.wq);
1e6dd65e 1324
70bd97ae 1325 vfd = &dev->vdev;
5ab6c9af 1326 *vfd = vivi_template;
c285addb 1327 vfd->debug = debug;
730947bc 1328 vfd->v4l2_dev = &dev->v4l2_dev;
f2ba5a0b 1329 vfd->queue = q;
b1a873a3 1330 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
e007a325
PO		 1331
1332 /*
1333 * Provide a mutex to v4l2 core. It will be used to protect
1334 * all fops and v4l2 ioctls.
1335 */
fedc6c81 1336 vfd->lock = &dev->mutex;
70bd97ae 1337 video_set_drvdata(vfd, dev);
55712ff7 1338
5ab6c9af
HV		 1339 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1340 if (ret < 0)
70bd97ae 1341 goto unreg_dev;
980d4f17 1342
5ab6c9af
HV		 1343 /* Now that everything is fine, let's add it to device list */
1344 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
980d4f17 1345
38c7c036
LP		 1346 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1347 video_device_node_name(vfd));
5ab6c9af
HV		 1348 return 0;
1349
5ab6c9af 1350unreg_dev:
7e996afa 1351 v4l2_ctrl_handler_free(hdl);
5ab6c9af
HV		 1352 v4l2_device_unregister(&dev->v4l2_dev);
1353free_dev:
1354 kfree(dev);
1355 return ret;
1356}
f905c442 1357
5ab6c9af
HV		 1358/* This routine allocates from 1 to n_devs virtual drivers.
1359
1360 The real maximum number of virtual drivers will depend on how many drivers
1361 will succeed. This is limited to the maximum number of devices that
1362 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1363 */
1364static int __init vivi_init(void)
1365{
730947bc 1366 const struct font_desc *font = find_font("VGA8x16");
9185cbfc 1367 int ret = 0, i;
5ab6c9af 1368
730947bc
HV		 1369 if (font == NULL) {
1370 printk(KERN_ERR "vivi: could not find font\n");
1371 return -ENODEV;
1372 }
1373 font8x16 = font->data;
1374
5ab6c9af
HV		 1375 if (n_devs <= 0)
1376 n_devs = 1;
1377
1378 for (i = 0; i < n_devs; i++) {
1379 ret = vivi_create_instance(i);
1380 if (ret) {
1381 /* If some instantiations succeeded, keep driver */
1382 if (i)
1383 ret = 0;
1384 break;
1385 }
55712ff7 1386 }
f905c442 1387
55712ff7 1388 if (ret < 0) {
730947bc 1389 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
5ab6c9af
HV		 1390 return ret;
1391 }
1392
1393 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1990d50b
MCC		 1394 "Capture Board ver %s successfully loaded.\n",
1395 VIVI_VERSION);
980d4f17 1396
5ab6c9af
HV		 1397 /* n_devs will reflect the actual number of allocated devices */
1398 n_devs = i;
980d4f17 1399
1e6dd65e
MCC		 1400 return ret;
1401}
1402
1403static void __exit vivi_exit(void)
1404{
55712ff7 1405 vivi_release();
1e6dd65e
MCC		 1406}
1407
1408module_init(vivi_init);
1409module_exit(vivi_exit);
Linux 6.x block layer and io_uring tree(s)