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