Commit | Line | Data |
---|---|---|
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 |
53 | MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board"); |
54 | MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol"); | |
55 | MODULE_LICENSE("Dual BSD/GPL"); | |
56 | ||
57 | static unsigned video_nr = -1; | |
58 | module_param(video_nr, uint, 0644); | |
59 | MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect"); | |
60 | ||
61 | static unsigned n_devs = 1; | |
62 | module_param(n_devs, uint, 0644); | |
63 | MODULE_PARM_DESC(n_devs, "number of video devices to create"); | |
64 | ||
65 | static unsigned debug; | |
66 | module_param(debug, uint, 0644); | |
67 | MODULE_PARM_DESC(debug, "activates debug info"); | |
68 | ||
69 | static unsigned int vid_limit = 16; | |
70 | module_param(vid_limit, uint, 0644); | |
71 | MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes"); | |
72 | ||
730947bc HV |
73 | /* Global font descriptor */ |
74 | static 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 | ||
83 | struct vivi_fmt { | |
84 | char *name; | |
85 | u32 fourcc; /* v4l2 format id */ | |
86 | int depth; | |
87 | }; | |
88 | ||
d891f475 MD |
89 | static 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 |
122 | static 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 */ |
140 | struct 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 | ||
147 | struct 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 | ||
158 | static LIST_HEAD(vivi_devlist); | |
159 | ||
160 | struct 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 | ||
213 | enum 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 | ||
235 | struct 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 */ | |
241 | static 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 | 269 | static 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 | 316 | static 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 | 410 | static 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 |
421 | static 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 | 451 | static 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 | 516 | static 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 |
541 | unlock: |
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 | 548 | static 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 | 568 | stop_task: |
1e6dd65e MCC |
569 | remove_wait_queue(&dma_q->wq, &wait); |
570 | try_to_freeze(); | |
571 | } | |
572 | ||
972c3517 | 573 | static 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 | 591 | static 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 | 617 | static 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 |
646 | static 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 | 676 | static 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 | 697 | static 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 |
734 | static 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 | ||
741 | static 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 | 748 | static 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 | 762 | static 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 */ |
770 | static 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 | ||
778 | static 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 |
784 | static 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 | |
791 | static 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 | 807 | static 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 | 821 | static 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 | 836 | static 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 | 852 | static 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 |
885 | static 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 |
908 | static 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 | 915 | static 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 | 921 | static 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 | 927 | static 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 | 933 | static 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 | 939 | static 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 | 945 | static 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 | 951 | static 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 | 963 | static 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 | 971 | static 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 | 986 | static 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 |
999 | static ssize_t |
1000 | vivi_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 | ||
1009 | static unsigned int | |
1010 | vivi_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 | 1019 | static 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 | 1032 | static 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 |
1047 | static 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 | ||
1053 | static 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 | ||
1060 | static 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 | ||
1071 | static 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 | ||
1081 | static 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 | ||
1088 | static 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 | ||
1098 | static 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 | ||
1110 | static 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 | 1120 | static 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 | 1130 | static 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 | ||
1148 | static 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 |
1162 | static 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 | 1183 | static 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 | ||
1282 | rel_vdev: | |
1283 | video_device_release(vfd); | |
1284 | unreg_dev: | |
7e996afa | 1285 | v4l2_ctrl_handler_free(hdl); |
5ab6c9af HV |
1286 | v4l2_device_unregister(&dev->v4l2_dev); |
1287 | free_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 | */ | |
1298 | static 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 | ||
1338 | static void __exit vivi_exit(void) | |
1339 | { | |
55712ff7 | 1340 | vivi_release(); |
1e6dd65e MCC |
1341 | } |
1342 | ||
1343 | module_init(vivi_init); | |
1344 | module_exit(vivi_exit); |