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