Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pvrusb2-v4l2.c
Go to the documentation of this file.
1 /*
2  *
3  *
4  * Copyright (C) 2005 Mike Isely <[email protected]>
5  * Copyright (C) 2004 Aurelien Alleaume <[email protected]>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  */
21 
22 #include <linux/kernel.h>
23 #include <linux/slab.h>
24 #include <linux/version.h>
25 #include "pvrusb2-context.h"
26 #include "pvrusb2-hdw.h"
27 #include "pvrusb2.h"
28 #include "pvrusb2-debug.h"
29 #include "pvrusb2-v4l2.h"
30 #include "pvrusb2-ioread.h"
31 #include <linux/videodev2.h>
32 #include <linux/module.h>
33 #include <media/v4l2-dev.h>
34 #include <media/v4l2-common.h>
35 #include <media/v4l2-ioctl.h>
36 
37 struct pvr2_v4l2_dev;
38 struct pvr2_v4l2_fh;
39 struct pvr2_v4l2;
40 
41 struct pvr2_v4l2_dev {
42  struct video_device devbase; /* MUST be first! */
43  struct pvr2_v4l2 *v4lp;
45  /* Information about this device: */
46  enum pvr2_config config; /* Expected stream format */
47  int v4l_type; /* V4L defined type for this device node */
48  enum pvr2_v4l_type minor_type; /* pvr2-understood minor device type */
49 };
50 
51 struct pvr2_v4l2_fh {
53  struct pvr2_v4l2_dev *pdi;
55  struct pvr2_ioread *rhp;
56  struct file *file;
57  struct pvr2_v4l2 *vhead;
62  /* Map contiguous ordinal value to input id */
63  unsigned char *input_map;
64  unsigned int input_cnt;
65 };
66 
67 struct pvr2_v4l2 {
71 
73 
74  /* streams - Note that these must be separately, individually,
75  * allocated pointers. This is because the v4l core is going to
76  * manage their deletion - separately, individually... */
79 };
80 
81 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
82 module_param_array(video_nr, int, NULL, 0444);
83 MODULE_PARM_DESC(video_nr, "Offset for device's video dev minor");
84 static int radio_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
85 module_param_array(radio_nr, int, NULL, 0444);
86 MODULE_PARM_DESC(radio_nr, "Offset for device's radio dev minor");
87 static int vbi_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
88 module_param_array(vbi_nr, int, NULL, 0444);
89 MODULE_PARM_DESC(vbi_nr, "Offset for device's vbi dev minor");
90 
91 static struct v4l2_capability pvr_capability ={
92  .driver = "pvrusb2",
93  .card = "Hauppauge WinTV pvr-usb2",
94  .bus_info = "usb",
95  .version = LINUX_VERSION_CODE,
96  .capabilities = (V4L2_CAP_VIDEO_CAPTURE |
99 };
100 
101 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
102  {
103  .index = 0,
105  .flags = V4L2_FMT_FLAG_COMPRESSED,
106  .description = "MPEG1/2",
107  // This should really be V4L2_PIX_FMT_MPEG, but xawtv
108  // breaks when I do that.
109  .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
110  }
111 };
112 
113 #define PVR_FORMAT_PIX 0
114 #define PVR_FORMAT_VBI 1
115 
116 static struct v4l2_format pvr_format [] = {
117  [PVR_FORMAT_PIX] = {
119  .fmt = {
120  .pix = {
121  .width = 720,
122  .height = 576,
123  // This should really be V4L2_PIX_FMT_MPEG,
124  // but xawtv breaks when I do that.
125  .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
126  .field = V4L2_FIELD_INTERLACED,
127  .bytesperline = 0, // doesn't make sense
128  // here
129  //FIXME : Don't know what to put here...
130  .sizeimage = (32*1024),
131  .colorspace = 0, // doesn't make sense here
132  .priv = 0
133  }
134  }
135  },
136  [PVR_FORMAT_VBI] = {
138  .fmt = {
139  .vbi = {
140  .sampling_rate = 27000000,
141  .offset = 248,
142  .samples_per_line = 1443,
143  .sample_format = V4L2_PIX_FMT_GREY,
144  .start = { 0, 0 },
145  .count = { 0, 0 },
146  .flags = 0,
147  }
148  }
149  }
150 };
151 
152 
153 
154 /*
155  * This is part of Video 4 Linux API. These procedures handle ioctl() calls.
156  */
157 static int pvr2_querycap(struct file *file, void *priv, struct v4l2_capability *cap)
158 {
159  struct pvr2_v4l2_fh *fh = file->private_data;
160  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
161 
162  memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
164  sizeof(cap->bus_info));
165  strlcpy(cap->card, pvr2_hdw_get_desc(hdw), sizeof(cap->card));
166  return 0;
167 }
168 
169 static int pvr2_g_priority(struct file *file, void *priv, enum v4l2_priority *p)
170 {
171  struct pvr2_v4l2_fh *fh = file->private_data;
172  struct pvr2_v4l2 *vp = fh->vhead;
173 
174  *p = v4l2_prio_max(&vp->prio);
175  return 0;
176 }
177 
178 static int pvr2_s_priority(struct file *file, void *priv, enum v4l2_priority prio)
179 {
180  struct pvr2_v4l2_fh *fh = file->private_data;
181  struct pvr2_v4l2 *vp = fh->vhead;
182 
183  return v4l2_prio_change(&vp->prio, &fh->prio, prio);
184 }
185 
186 static int pvr2_g_std(struct file *file, void *priv, v4l2_std_id *std)
187 {
188  struct pvr2_v4l2_fh *fh = file->private_data;
189  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
190  int val = 0;
191  int ret;
192 
193  ret = pvr2_ctrl_get_value(
195  *std = val;
196  return ret;
197 }
198 
199 int pvr2_s_std(struct file *file, void *priv, v4l2_std_id *std)
200 {
201  struct pvr2_v4l2_fh *fh = file->private_data;
202  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
203 
204  return pvr2_ctrl_set_value(
206 }
207 
208 static int pvr2_querystd(struct file *file, void *priv, v4l2_std_id *std)
209 {
210  struct pvr2_v4l2_fh *fh = file->private_data;
211  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
212  int val = 0;
213  int ret;
214 
215  ret = pvr2_ctrl_get_value(
217  *std = val;
218  return ret;
219 }
220 
221 static int pvr2_enum_input(struct file *file, void *priv, struct v4l2_input *vi)
222 {
223  struct pvr2_v4l2_fh *fh = file->private_data;
224  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
225  struct pvr2_ctrl *cptr;
226  struct v4l2_input tmp;
227  unsigned int cnt;
228  int val;
229 
231 
232  memset(&tmp, 0, sizeof(tmp));
233  tmp.index = vi->index;
234  if (vi->index >= fh->input_cnt)
235  return -EINVAL;
236  val = fh->input_map[vi->index];
237  switch (val) {
238  case PVR2_CVAL_INPUT_TV:
239  case PVR2_CVAL_INPUT_DTV:
241  tmp.type = V4L2_INPUT_TYPE_TUNER;
242  break;
246  break;
247  default:
248  return -EINVAL;
249  }
250 
251  cnt = 0;
252  pvr2_ctrl_get_valname(cptr, val,
253  tmp.name, sizeof(tmp.name) - 1, &cnt);
254  tmp.name[cnt] = 0;
255 
256  /* Don't bother with audioset, since this driver currently
257  always switches the audio whenever the video is
258  switched. */
259 
260  /* Handling std is a tougher problem. It doesn't make
261  sense in cases where a device might be multi-standard.
262  We could just copy out the current value for the
263  standard, but it can change over time. For now just
264  leave it zero. */
265  *vi = tmp;
266  return 0;
267 }
268 
269 static int pvr2_g_input(struct file *file, void *priv, unsigned int *i)
270 {
271  struct pvr2_v4l2_fh *fh = file->private_data;
272  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
273  unsigned int idx;
274  struct pvr2_ctrl *cptr;
275  int val;
276  int ret;
277 
279  val = 0;
280  ret = pvr2_ctrl_get_value(cptr, &val);
281  *i = 0;
282  for (idx = 0; idx < fh->input_cnt; idx++) {
283  if (fh->input_map[idx] == val) {
284  *i = idx;
285  break;
286  }
287  }
288  return ret;
289 }
290 
291 static int pvr2_s_input(struct file *file, void *priv, unsigned int inp)
292 {
293  struct pvr2_v4l2_fh *fh = file->private_data;
294  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
295 
296  if (inp >= fh->input_cnt)
297  return -EINVAL;
298  return pvr2_ctrl_set_value(
300  fh->input_map[inp]);
301 }
302 
303 static int pvr2_enumaudio(struct file *file, void *priv, struct v4l2_audio *vin)
304 {
305  /* pkt: FIXME: We are returning one "fake" input here
306  which could very well be called "whatever_we_like".
307  This is for apps that want to see an audio input
308  just to feel comfortable, as well as to test if
309  it can do stereo or sth. There is actually no guarantee
310  that the actual audio input cannot change behind the app's
311  back, but most applications should not mind that either.
312 
313  Hopefully, mplayer people will work with us on this (this
314  whole mess is to support mplayer pvr://), or Hans will come
315  up with a more standard way to say "we have inputs but we
316  don 't want you to change them independent of video" which
317  will sort this mess.
318  */
319 
320  if (vin->index > 0)
321  return -EINVAL;
322  strncpy(vin->name, "PVRUSB2 Audio", 14);
324  return 0;
325 }
326 
327 static int pvr2_g_audio(struct file *file, void *priv, struct v4l2_audio *vin)
328 {
329  /* pkt: FIXME: see above comment (VIDIOC_ENUMAUDIO) */
330  vin->index = 0;
331  strncpy(vin->name, "PVRUSB2 Audio", 14);
333  return 0;
334 }
335 
336 static int pvr2_s_audio(struct file *file, void *priv, const struct v4l2_audio *vout)
337 {
338  if (vout->index)
339  return -EINVAL;
340  return 0;
341 }
342 
343 static int pvr2_g_tuner(struct file *file, void *priv, struct v4l2_tuner *vt)
344 {
345  struct pvr2_v4l2_fh *fh = file->private_data;
346  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
347 
348  if (vt->index != 0)
349  return -EINVAL; /* Only answer for the 1st tuner */
350 
352  return pvr2_hdw_get_tuner_status(hdw, vt);
353 }
354 
355 static int pvr2_s_tuner(struct file *file, void *priv, struct v4l2_tuner *vt)
356 {
357  struct pvr2_v4l2_fh *fh = file->private_data;
358  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
359 
360  if (vt->index != 0)
361  return -EINVAL;
362 
363  return pvr2_ctrl_set_value(
365  vt->audmode);
366 }
367 
368 int pvr2_s_frequency(struct file *file, void *priv, struct v4l2_frequency *vf)
369 {
370  struct pvr2_v4l2_fh *fh = file->private_data;
371  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
372  unsigned long fv;
373  struct v4l2_tuner vt;
374  int cur_input;
375  struct pvr2_ctrl *ctrlp;
376  int ret;
377 
378  ret = pvr2_hdw_get_tuner_status(hdw, &vt);
379  if (ret != 0)
380  return ret;
382  ret = pvr2_ctrl_get_value(ctrlp, &cur_input);
383  if (ret != 0)
384  return ret;
385  if (vf->type == V4L2_TUNER_RADIO) {
386  if (cur_input != PVR2_CVAL_INPUT_RADIO)
388  } else {
389  if (cur_input == PVR2_CVAL_INPUT_RADIO)
391  }
392  fv = vf->frequency;
394  fv = (fv * 125) / 2;
395  else
396  fv = fv * 62500;
397  return pvr2_ctrl_set_value(
399 }
400 
401 static int pvr2_g_frequency(struct file *file, void *priv, struct v4l2_frequency *vf)
402 {
403  struct pvr2_v4l2_fh *fh = file->private_data;
404  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
405  int val = 0;
406  int cur_input;
407  struct v4l2_tuner vt;
408  int ret;
409 
410  ret = pvr2_hdw_get_tuner_status(hdw, &vt);
411  if (ret != 0)
412  return ret;
413  ret = pvr2_ctrl_get_value(
415  &val);
416  if (ret != 0)
417  return ret;
420  &cur_input);
421  if (cur_input == PVR2_CVAL_INPUT_RADIO)
422  vf->type = V4L2_TUNER_RADIO;
423  else
426  val = (val * 2) / 125;
427  else
428  val /= 62500;
429  vf->frequency = val;
430  return 0;
431 }
432 
433 static int pvr2_enum_fmt_vid_cap(struct file *file, void *priv, struct v4l2_fmtdesc *fd)
434 {
435  /* Only one format is supported : mpeg.*/
436  if (fd->index != 0)
437  return -EINVAL;
438 
439  memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
440  return 0;
441 }
442 
443 static int pvr2_g_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *vf)
444 {
445  struct pvr2_v4l2_fh *fh = file->private_data;
446  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
447  int val;
448 
449  memcpy(vf, &pvr_format[PVR_FORMAT_PIX], sizeof(struct v4l2_format));
450  val = 0;
453  &val);
454  vf->fmt.pix.width = val;
455  val = 0;
458  &val);
459  vf->fmt.pix.height = val;
460  return 0;
461 }
462 
463 static int pvr2_try_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *vf)
464 {
465  struct pvr2_v4l2_fh *fh = file->private_data;
466  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
467  int lmin, lmax, ldef;
468  struct pvr2_ctrl *hcp, *vcp;
469  int h = vf->fmt.pix.height;
470  int w = vf->fmt.pix.width;
471 
474 
475  lmin = pvr2_ctrl_get_min(hcp);
476  lmax = pvr2_ctrl_get_max(hcp);
477  pvr2_ctrl_get_def(hcp, &ldef);
478  if (w == -1)
479  w = ldef;
480  else if (w < lmin)
481  w = lmin;
482  else if (w > lmax)
483  w = lmax;
484  lmin = pvr2_ctrl_get_min(vcp);
485  lmax = pvr2_ctrl_get_max(vcp);
486  pvr2_ctrl_get_def(vcp, &ldef);
487  if (h == -1)
488  h = ldef;
489  else if (h < lmin)
490  h = lmin;
491  else if (h > lmax)
492  h = lmax;
493 
494  memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
495  sizeof(struct v4l2_format));
496  vf->fmt.pix.width = w;
497  vf->fmt.pix.height = h;
498  return 0;
499 }
500 
501 static int pvr2_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *vf)
502 {
503  struct pvr2_v4l2_fh *fh = file->private_data;
504  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
505  struct pvr2_ctrl *hcp, *vcp;
506  int ret = pvr2_try_fmt_vid_cap(file, fh, vf);
507 
508  if (ret)
509  return ret;
512  pvr2_ctrl_set_value(hcp, vf->fmt.pix.width);
513  pvr2_ctrl_set_value(vcp, vf->fmt.pix.height);
514  return 0;
515 }
516 
517 static int pvr2_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
518 {
519  struct pvr2_v4l2_fh *fh = file->private_data;
520  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
521  struct pvr2_v4l2_dev *pdi = fh->pdi;
522  int ret;
523 
524  if (!fh->pdi->stream) {
525  /* No stream defined for this node. This means
526  that we're not currently allowed to stream from
527  this node. */
528  return -EPERM;
529  }
530  ret = pvr2_hdw_set_stream_type(hdw, pdi->config);
531  if (ret < 0)
532  return ret;
533  return pvr2_hdw_set_streaming(hdw, !0);
534 }
535 
536 static int pvr2_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
537 {
538  struct pvr2_v4l2_fh *fh = file->private_data;
539  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
540 
541  if (!fh->pdi->stream) {
542  /* No stream defined for this node. This means
543  that we're not currently allowed to stream from
544  this node. */
545  return -EPERM;
546  }
547  return pvr2_hdw_set_streaming(hdw, 0);
548 }
549 
550 static int pvr2_queryctrl(struct file *file, void *priv,
551  struct v4l2_queryctrl *vc)
552 {
553  struct pvr2_v4l2_fh *fh = file->private_data;
554  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
555  struct pvr2_ctrl *cptr;
556  int val;
557 
558  if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
560  hdw, (vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
561  if (cptr)
562  vc->id = pvr2_ctrl_get_v4lid(cptr);
563  } else {
564  cptr = pvr2_hdw_get_ctrl_v4l(hdw, vc->id);
565  }
566  if (!cptr) {
568  "QUERYCTRL id=0x%x not implemented here",
569  vc->id);
570  return -EINVAL;
571  }
572 
574  "QUERYCTRL id=0x%x mapping name=%s (%s)",
575  vc->id, pvr2_ctrl_get_name(cptr),
576  pvr2_ctrl_get_desc(cptr));
577  strlcpy(vc->name, pvr2_ctrl_get_desc(cptr), sizeof(vc->name));
578  vc->flags = pvr2_ctrl_get_v4lflags(cptr);
579  pvr2_ctrl_get_def(cptr, &val);
580  vc->default_value = val;
581  switch (pvr2_ctrl_get_type(cptr)) {
582  case pvr2_ctl_enum:
584  vc->minimum = 0;
585  vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
586  vc->step = 1;
587  break;
588  case pvr2_ctl_bool:
590  vc->minimum = 0;
591  vc->maximum = 1;
592  vc->step = 1;
593  break;
594  case pvr2_ctl_int:
596  vc->minimum = pvr2_ctrl_get_min(cptr);
597  vc->maximum = pvr2_ctrl_get_max(cptr);
598  vc->step = 1;
599  break;
600  default:
602  "QUERYCTRL id=0x%x name=%s not mappable",
603  vc->id, pvr2_ctrl_get_name(cptr));
604  return -EINVAL;
605  }
606  return 0;
607 }
608 
609 static int pvr2_querymenu(struct file *file, void *priv, struct v4l2_querymenu *vm)
610 {
611  struct pvr2_v4l2_fh *fh = file->private_data;
612  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
613  unsigned int cnt = 0;
614  int ret;
615 
617  vm->index,
618  vm->name, sizeof(vm->name) - 1,
619  &cnt);
620  vm->name[cnt] = 0;
621  return ret;
622 }
623 
624 static int pvr2_g_ctrl(struct file *file, void *priv, struct v4l2_control *vc)
625 {
626  struct pvr2_v4l2_fh *fh = file->private_data;
627  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
628  int val = 0;
629  int ret;
630 
632  &val);
633  vc->value = val;
634  return ret;
635 }
636 
637 static int pvr2_s_ctrl(struct file *file, void *priv, struct v4l2_control *vc)
638 {
639  struct pvr2_v4l2_fh *fh = file->private_data;
640  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
641 
643  vc->value);
644 }
645 
646 static int pvr2_g_ext_ctrls(struct file *file, void *priv,
647  struct v4l2_ext_controls *ctls)
648 {
649  struct pvr2_v4l2_fh *fh = file->private_data;
650  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
651  struct v4l2_ext_control *ctrl;
652  unsigned int idx;
653  int val;
654  int ret;
655 
656  ret = 0;
657  for (idx = 0; idx < ctls->count; idx++) {
658  ctrl = ctls->controls + idx;
659  ret = pvr2_ctrl_get_value(
660  pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id), &val);
661  if (ret) {
662  ctls->error_idx = idx;
663  return ret;
664  }
665  /* Ensure that if read as a 64 bit value, the user
666  will still get a hopefully sane value */
667  ctrl->value64 = 0;
668  ctrl->value = val;
669  }
670  return 0;
671 }
672 
673 static int pvr2_s_ext_ctrls(struct file *file, void *priv,
674  struct v4l2_ext_controls *ctls)
675 {
676  struct pvr2_v4l2_fh *fh = file->private_data;
677  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
678  struct v4l2_ext_control *ctrl;
679  unsigned int idx;
680  int ret;
681 
682  ret = 0;
683  for (idx = 0; idx < ctls->count; idx++) {
684  ctrl = ctls->controls + idx;
685  ret = pvr2_ctrl_set_value(
686  pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id),
687  ctrl->value);
688  if (ret) {
689  ctls->error_idx = idx;
690  return ret;
691  }
692  }
693  return 0;
694 }
695 
696 static int pvr2_try_ext_ctrls(struct file *file, void *priv,
697  struct v4l2_ext_controls *ctls)
698 {
699  struct pvr2_v4l2_fh *fh = file->private_data;
700  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
701  struct v4l2_ext_control *ctrl;
702  struct pvr2_ctrl *pctl;
703  unsigned int idx;
704 
705  /* For the moment just validate that the requested control
706  actually exists. */
707  for (idx = 0; idx < ctls->count; idx++) {
708  ctrl = ctls->controls + idx;
709  pctl = pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id);
710  if (!pctl) {
711  ctls->error_idx = idx;
712  return -EINVAL;
713  }
714  }
715  return 0;
716 }
717 
718 static int pvr2_cropcap(struct file *file, void *priv, struct v4l2_cropcap *cap)
719 {
720  struct pvr2_v4l2_fh *fh = file->private_data;
721  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
722  int ret;
723 
724  if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
725  return -EINVAL;
726  ret = pvr2_hdw_get_cropcap(hdw, cap);
727  cap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* paranoia */
728  return ret;
729 }
730 
731 static int pvr2_g_crop(struct file *file, void *priv, struct v4l2_crop *crop)
732 {
733  struct pvr2_v4l2_fh *fh = file->private_data;
734  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
735  int val = 0;
736  int ret;
737 
738  if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
739  return -EINVAL;
740  ret = pvr2_ctrl_get_value(
742  if (ret != 0)
743  return -EINVAL;
744  crop->c.left = val;
745  ret = pvr2_ctrl_get_value(
747  if (ret != 0)
748  return -EINVAL;
749  crop->c.top = val;
750  ret = pvr2_ctrl_get_value(
752  if (ret != 0)
753  return -EINVAL;
754  crop->c.width = val;
755  ret = pvr2_ctrl_get_value(
757  if (ret != 0)
758  return -EINVAL;
759  crop->c.height = val;
760  return 0;
761 }
762 
763 static int pvr2_s_crop(struct file *file, void *priv, const struct v4l2_crop *crop)
764 {
765  struct pvr2_v4l2_fh *fh = file->private_data;
766  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
767  int ret;
768 
769  if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
770  return -EINVAL;
771  ret = pvr2_ctrl_set_value(
773  crop->c.left);
774  if (ret != 0)
775  return -EINVAL;
776  ret = pvr2_ctrl_set_value(
778  crop->c.top);
779  if (ret != 0)
780  return -EINVAL;
781  ret = pvr2_ctrl_set_value(
783  crop->c.width);
784  if (ret != 0)
785  return -EINVAL;
786  ret = pvr2_ctrl_set_value(
788  crop->c.height);
789  if (ret != 0)
790  return -EINVAL;
791  return 0;
792 }
793 
794 static int pvr2_log_status(struct file *file, void *priv)
795 {
796  struct pvr2_v4l2_fh *fh = file->private_data;
797  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
798 
800  return 0;
801 }
802 
803 #ifdef CONFIG_VIDEO_ADV_DEBUG
804 static int pvr2_g_register(struct file *file, void *priv, struct v4l2_dbg_register *req)
805 {
806  struct pvr2_v4l2_fh *fh = file->private_data;
807  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
808  u64 val;
809  int ret;
810 
812  hdw, &req->match, req->reg,
813  0, &val);
814  req->val = val;
815  return ret;
816 }
817 
818 static int pvr2_s_register(struct file *file, void *priv, struct v4l2_dbg_register *req)
819 {
820  struct pvr2_v4l2_fh *fh = file->private_data;
821  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
822  u64 val;
823  int ret;
824 
825  val = req->val;
827  hdw, &req->match, req->reg,
828  1, &val);
829  return ret;
830 }
831 #endif
832 
833 static const struct v4l2_ioctl_ops pvr2_ioctl_ops = {
834  .vidioc_querycap = pvr2_querycap,
835  .vidioc_g_priority = pvr2_g_priority,
836  .vidioc_s_priority = pvr2_s_priority,
837  .vidioc_s_audio = pvr2_s_audio,
838  .vidioc_g_audio = pvr2_g_audio,
839  .vidioc_enumaudio = pvr2_enumaudio,
840  .vidioc_enum_input = pvr2_enum_input,
841  .vidioc_cropcap = pvr2_cropcap,
842  .vidioc_s_crop = pvr2_s_crop,
843  .vidioc_g_crop = pvr2_g_crop,
844  .vidioc_g_input = pvr2_g_input,
845  .vidioc_s_input = pvr2_s_input,
846  .vidioc_g_frequency = pvr2_g_frequency,
847  .vidioc_s_frequency = pvr2_s_frequency,
848  .vidioc_s_tuner = pvr2_s_tuner,
849  .vidioc_g_tuner = pvr2_g_tuner,
850  .vidioc_g_std = pvr2_g_std,
851  .vidioc_s_std = pvr2_s_std,
852  .vidioc_querystd = pvr2_querystd,
853  .vidioc_log_status = pvr2_log_status,
854  .vidioc_enum_fmt_vid_cap = pvr2_enum_fmt_vid_cap,
855  .vidioc_g_fmt_vid_cap = pvr2_g_fmt_vid_cap,
856  .vidioc_s_fmt_vid_cap = pvr2_s_fmt_vid_cap,
857  .vidioc_try_fmt_vid_cap = pvr2_try_fmt_vid_cap,
858  .vidioc_streamon = pvr2_streamon,
859  .vidioc_streamoff = pvr2_streamoff,
860  .vidioc_queryctrl = pvr2_queryctrl,
861  .vidioc_querymenu = pvr2_querymenu,
862  .vidioc_g_ctrl = pvr2_g_ctrl,
863  .vidioc_s_ctrl = pvr2_s_ctrl,
864  .vidioc_g_ext_ctrls = pvr2_g_ext_ctrls,
865  .vidioc_s_ext_ctrls = pvr2_s_ext_ctrls,
866  .vidioc_try_ext_ctrls = pvr2_try_ext_ctrls,
867 #ifdef CONFIG_VIDEO_ADV_DEBUG
868  .vidioc_g_register = pvr2_g_register,
869  .vidioc_s_register = pvr2_s_register,
870 #endif
871 };
872 
873 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
874 {
875  struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
876  enum pvr2_config cfg = dip->config;
877  char msg[80];
878  unsigned int mcnt;
879 
880  /* Construct the unregistration message *before* we actually
881  perform the unregistration step. By doing it this way we don't
882  have to worry about potentially touching deleted resources. */
883  mcnt = scnprintf(msg, sizeof(msg) - 1,
884  "pvrusb2: unregistered device %s [%s]",
885  video_device_node_name(&dip->devbase),
886  pvr2_config_get_name(cfg));
887  msg[mcnt] = 0;
888 
890 
891  /* Paranoia */
892  dip->v4lp = NULL;
893  dip->stream = NULL;
894 
895  /* Actual deallocation happens later when all internal references
896  are gone. */
898 
899  printk(KERN_INFO "%s\n", msg);
900 
901 }
902 
903 
904 static void pvr2_v4l2_dev_disassociate_parent(struct pvr2_v4l2_dev *dip)
905 {
906  if (!dip) return;
907  if (!dip->devbase.parent) return;
908  dip->devbase.parent = NULL;
909  device_move(&dip->devbase.dev, NULL, DPM_ORDER_NONE);
910 }
911 
912 
913 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
914 {
915  if (vp->dev_video) {
916  pvr2_v4l2_dev_destroy(vp->dev_video);
917  vp->dev_video = NULL;
918  }
919  if (vp->dev_radio) {
920  pvr2_v4l2_dev_destroy(vp->dev_radio);
921  vp->dev_radio = NULL;
922  }
923 
924  pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
926  kfree(vp);
927 }
928 
929 
930 static void pvr2_video_device_release(struct video_device *vdev)
931 {
932  struct pvr2_v4l2_dev *dev;
933  dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
934  kfree(dev);
935 }
936 
937 
938 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
939 {
940  struct pvr2_v4l2 *vp;
941  vp = container_of(chp,struct pvr2_v4l2,channel);
942  if (!vp->channel.mc_head->disconnect_flag) return;
943  pvr2_v4l2_dev_disassociate_parent(vp->dev_video);
944  pvr2_v4l2_dev_disassociate_parent(vp->dev_radio);
945  if (vp->vfirst) return;
946  pvr2_v4l2_destroy_no_lock(vp);
947 }
948 
949 
950 static long pvr2_v4l2_ioctl(struct file *file,
951  unsigned int cmd, unsigned long arg)
952 {
953 
954  struct pvr2_v4l2_fh *fh = file->private_data;
955  struct pvr2_v4l2 *vp = fh->vhead;
956  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
957  long ret = -EINVAL;
958 
961 
962  if (!pvr2_hdw_dev_ok(hdw)) {
964  "ioctl failed - bad or no context");
965  return -EFAULT;
966  }
967 
968  /* check priority */
969  switch (cmd) {
970  case VIDIOC_S_CTRL:
971  case VIDIOC_S_STD:
972  case VIDIOC_S_INPUT:
973  case VIDIOC_S_TUNER:
974  case VIDIOC_S_FREQUENCY:
975  ret = v4l2_prio_check(&vp->prio, fh->prio);
976  if (ret)
977  return ret;
978  }
979 
980  ret = video_ioctl2(file, cmd, arg);
981 
982  pvr2_hdw_commit_ctl(hdw);
983 
984  if (ret < 0) {
985  if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
986  pvr2_trace(PVR2_TRACE_V4LIOCTL,
987  "pvr2_v4l2_do_ioctl failure, ret=%ld", ret);
988  } else {
989  if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
990  pvr2_trace(PVR2_TRACE_V4LIOCTL,
991  "pvr2_v4l2_do_ioctl failure, ret=%ld"
992  " command was:", ret);
994  cmd);
995  }
996  }
997  } else {
998  pvr2_trace(PVR2_TRACE_V4LIOCTL,
999  "pvr2_v4l2_do_ioctl complete, ret=%ld (0x%lx)",
1000  ret, ret);
1001  }
1002  return ret;
1003 
1004 }
1005 
1006 
1007 static int pvr2_v4l2_release(struct file *file)
1008 {
1009  struct pvr2_v4l2_fh *fhp = file->private_data;
1010  struct pvr2_v4l2 *vp = fhp->vhead;
1011  struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
1012 
1013  pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
1014 
1015  if (fhp->rhp) {
1016  struct pvr2_stream *sp;
1017  pvr2_hdw_set_streaming(hdw,0);
1018  sp = pvr2_ioread_get_stream(fhp->rhp);
1019  if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
1020  pvr2_ioread_destroy(fhp->rhp);
1021  fhp->rhp = NULL;
1022  }
1023 
1024  v4l2_prio_close(&vp->prio, fhp->prio);
1025  file->private_data = NULL;
1026 
1027  if (fhp->vnext) {
1028  fhp->vnext->vprev = fhp->vprev;
1029  } else {
1030  vp->vlast = fhp->vprev;
1031  }
1032  if (fhp->vprev) {
1033  fhp->vprev->vnext = fhp->vnext;
1034  } else {
1035  vp->vfirst = fhp->vnext;
1036  }
1037  fhp->vnext = NULL;
1038  fhp->vprev = NULL;
1039  fhp->vhead = NULL;
1040  pvr2_channel_done(&fhp->channel);
1042  "Destroying pvr_v4l2_fh id=%p",fhp);
1043  if (fhp->input_map) {
1044  kfree(fhp->input_map);
1045  fhp->input_map = NULL;
1046  }
1047  kfree(fhp);
1048  if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
1049  pvr2_v4l2_destroy_no_lock(vp);
1050  }
1051  return 0;
1052 }
1053 
1054 
1055 static int pvr2_v4l2_open(struct file *file)
1056 {
1057  struct pvr2_v4l2_dev *dip; /* Our own context pointer */
1058  struct pvr2_v4l2_fh *fhp;
1059  struct pvr2_v4l2 *vp;
1060  struct pvr2_hdw *hdw;
1061  unsigned int input_mask = 0;
1062  unsigned int input_cnt,idx;
1063  int ret = 0;
1064 
1065  dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1066 
1067  vp = dip->v4lp;
1068  hdw = vp->channel.hdw;
1069 
1070  pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1071 
1072  if (!pvr2_hdw_dev_ok(hdw)) {
1074  "pvr2_v4l2_open: hardware not ready");
1075  return -EIO;
1076  }
1077 
1078  fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1079  if (!fhp) {
1080  return -ENOMEM;
1081  }
1082 
1084  fhp->pdi = dip;
1085 
1086  pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1087  pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
1088 
1089  if (dip->v4l_type == VFL_TYPE_RADIO) {
1090  /* Opening device as a radio, legal input selection subset
1091  is just the radio. */
1092  input_mask = (1 << PVR2_CVAL_INPUT_RADIO);
1093  } else {
1094  /* Opening the main V4L device, legal input selection
1095  subset includes all analog inputs. */
1096  input_mask = ((1 << PVR2_CVAL_INPUT_RADIO) |
1097  (1 << PVR2_CVAL_INPUT_TV) |
1098  (1 << PVR2_CVAL_INPUT_COMPOSITE) |
1099  (1 << PVR2_CVAL_INPUT_SVIDEO));
1100  }
1101  ret = pvr2_channel_limit_inputs(&fhp->channel,input_mask);
1102  if (ret) {
1103  pvr2_channel_done(&fhp->channel);
1105  "Destroying pvr_v4l2_fh id=%p (input mask error)",
1106  fhp);
1107 
1108  kfree(fhp);
1109  return ret;
1110  }
1111 
1112  input_mask &= pvr2_hdw_get_input_available(hdw);
1113  input_cnt = 0;
1114  for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1115  if (input_mask & (1 << idx)) input_cnt++;
1116  }
1117  fhp->input_cnt = input_cnt;
1118  fhp->input_map = kzalloc(input_cnt,GFP_KERNEL);
1119  if (!fhp->input_map) {
1120  pvr2_channel_done(&fhp->channel);
1122  "Destroying pvr_v4l2_fh id=%p (input map failure)",
1123  fhp);
1124  kfree(fhp);
1125  return -ENOMEM;
1126  }
1127  input_cnt = 0;
1128  for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1129  if (!(input_mask & (1 << idx))) continue;
1130  fhp->input_map[input_cnt++] = idx;
1131  }
1132 
1133  fhp->vnext = NULL;
1134  fhp->vprev = vp->vlast;
1135  if (vp->vlast) {
1136  vp->vlast->vnext = fhp;
1137  } else {
1138  vp->vfirst = fhp;
1139  }
1140  vp->vlast = fhp;
1141  fhp->vhead = vp;
1142 
1143  fhp->file = file;
1144  file->private_data = fhp;
1145  v4l2_prio_open(&vp->prio, &fhp->prio);
1146 
1148 
1149  return 0;
1150 }
1151 
1152 
1153 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1154 {
1155  wake_up(&fhp->wait_data);
1156 }
1157 
1158 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1159 {
1160  int ret;
1161  struct pvr2_stream *sp;
1162  struct pvr2_hdw *hdw;
1163  if (fh->rhp) return 0;
1164 
1165  if (!fh->pdi->stream) {
1166  /* No stream defined for this node. This means that we're
1167  not currently allowed to stream from this node. */
1168  return -EPERM;
1169  }
1170 
1171  /* First read() attempt. Try to claim the stream and start
1172  it... */
1173  if ((ret = pvr2_channel_claim_stream(&fh->channel,
1174  fh->pdi->stream)) != 0) {
1175  /* Someone else must already have it */
1176  return ret;
1177  }
1178 
1179  fh->rhp = pvr2_channel_create_mpeg_stream(fh->pdi->stream);
1180  if (!fh->rhp) {
1182  return -ENOMEM;
1183  }
1184 
1185  hdw = fh->channel.mc_head->hdw;
1186  sp = fh->pdi->stream->stream;
1187  pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1188  pvr2_hdw_set_stream_type(hdw,fh->pdi->config);
1189  if ((ret = pvr2_hdw_set_streaming(hdw,!0)) < 0) return ret;
1190  return pvr2_ioread_set_enabled(fh->rhp,!0);
1191 }
1192 
1193 
1194 static ssize_t pvr2_v4l2_read(struct file *file,
1195  char __user *buff, size_t count, loff_t *ppos)
1196 {
1197  struct pvr2_v4l2_fh *fh = file->private_data;
1198  int ret;
1199 
1200  if (fh->fw_mode_flag) {
1201  struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1202  char *tbuf;
1203  int c1,c2;
1204  int tcnt = 0;
1205  unsigned int offs = *ppos;
1206 
1207  tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1208  if (!tbuf) return -ENOMEM;
1209 
1210  while (count) {
1211  c1 = count;
1212  if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1213  c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1214  if (c2 < 0) {
1215  tcnt = c2;
1216  break;
1217  }
1218  if (!c2) break;
1219  if (copy_to_user(buff,tbuf,c2)) {
1220  tcnt = -EFAULT;
1221  break;
1222  }
1223  offs += c2;
1224  tcnt += c2;
1225  buff += c2;
1226  count -= c2;
1227  *ppos += c2;
1228  }
1229  kfree(tbuf);
1230  return tcnt;
1231  }
1232 
1233  if (!fh->rhp) {
1234  ret = pvr2_v4l2_iosetup(fh);
1235  if (ret) {
1236  return ret;
1237  }
1238  }
1239 
1240  for (;;) {
1241  ret = pvr2_ioread_read(fh->rhp,buff,count);
1242  if (ret >= 0) break;
1243  if (ret != -EAGAIN) break;
1244  if (file->f_flags & O_NONBLOCK) break;
1245  /* Doing blocking I/O. Wait here. */
1247  fh->wait_data,
1248  pvr2_ioread_avail(fh->rhp) >= 0);
1249  if (ret < 0) break;
1250  }
1251 
1252  return ret;
1253 }
1254 
1255 
1256 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1257 {
1258  unsigned int mask = 0;
1259  struct pvr2_v4l2_fh *fh = file->private_data;
1260  int ret;
1261 
1262  if (fh->fw_mode_flag) {
1263  mask |= POLLIN | POLLRDNORM;
1264  return mask;
1265  }
1266 
1267  if (!fh->rhp) {
1268  ret = pvr2_v4l2_iosetup(fh);
1269  if (ret) return POLLERR;
1270  }
1271 
1272  poll_wait(file,&fh->wait_data,wait);
1273 
1274  if (pvr2_ioread_avail(fh->rhp) >= 0) {
1275  mask |= POLLIN | POLLRDNORM;
1276  }
1277 
1278  return mask;
1279 }
1280 
1281 
1282 static const struct v4l2_file_operations vdev_fops = {
1283  .owner = THIS_MODULE,
1284  .open = pvr2_v4l2_open,
1285  .release = pvr2_v4l2_release,
1286  .read = pvr2_v4l2_read,
1287  .ioctl = pvr2_v4l2_ioctl,
1288  .poll = pvr2_v4l2_poll,
1289 };
1290 
1291 
1292 static struct video_device vdev_template = {
1293  .fops = &vdev_fops,
1294 };
1295 
1296 
1297 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1298  struct pvr2_v4l2 *vp,
1299  int v4l_type)
1300 {
1301  struct usb_device *usbdev;
1302  int mindevnum;
1303  int unit_number;
1304  struct pvr2_hdw *hdw;
1305  int *nr_ptr = NULL;
1306  dip->v4lp = vp;
1307 
1308  hdw = vp->channel.mc_head->hdw;
1309  usbdev = pvr2_hdw_get_dev(hdw);
1310  dip->v4l_type = v4l_type;
1311  switch (v4l_type) {
1312  case VFL_TYPE_GRABBER:
1313  dip->stream = &vp->channel.mc_head->video_stream;
1314  dip->config = pvr2_config_mpeg;
1316  nr_ptr = video_nr;
1317  if (!dip->stream) {
1318  pr_err(KBUILD_MODNAME
1319  ": Failed to set up pvrusb2 v4l video dev"
1320  " due to missing stream instance\n");
1321  return;
1322  }
1323  break;
1324  case VFL_TYPE_VBI:
1325  dip->config = pvr2_config_vbi;
1327  nr_ptr = vbi_nr;
1328  break;
1329  case VFL_TYPE_RADIO:
1330  dip->stream = &vp->channel.mc_head->video_stream;
1331  dip->config = pvr2_config_mpeg;
1333  nr_ptr = radio_nr;
1334  break;
1335  default:
1336  /* Bail out (this should be impossible) */
1337  pr_err(KBUILD_MODNAME ": Failed to set up pvrusb2 v4l dev"
1338  " due to unrecognized config\n");
1339  return;
1340  }
1341 
1342  memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1343  dip->devbase.release = pvr2_video_device_release;
1344  dip->devbase.ioctl_ops = &pvr2_ioctl_ops;
1345  {
1346  int val;
1349  PVR2_CID_STDAVAIL), &val);
1350  dip->devbase.tvnorms = (v4l2_std_id)val;
1351  }
1352 
1353  mindevnum = -1;
1354  unit_number = pvr2_hdw_get_unit_number(hdw);
1355  if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1356  mindevnum = nr_ptr[unit_number];
1357  }
1358  dip->devbase.parent = &usbdev->dev;
1359  if ((video_register_device(&dip->devbase,
1360  dip->v4l_type, mindevnum) < 0) &&
1361  (video_register_device(&dip->devbase,
1362  dip->v4l_type, -1) < 0)) {
1363  pr_err(KBUILD_MODNAME
1364  ": Failed to register pvrusb2 v4l device\n");
1365  }
1366 
1367  printk(KERN_INFO "pvrusb2: registered device %s [%s]\n",
1368  video_device_node_name(&dip->devbase),
1370 
1372  dip->minor_type,dip->devbase.minor);
1373 }
1374 
1375 
1377 {
1378  struct pvr2_v4l2 *vp;
1379 
1380  vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1381  if (!vp) return vp;
1382  pvr2_channel_init(&vp->channel,mnp);
1383  pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1384 
1385  vp->channel.check_func = pvr2_v4l2_internal_check;
1386 
1387  /* register streams */
1388  vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1389  if (!vp->dev_video) goto fail;
1390  pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1391  if (pvr2_hdw_get_input_available(vp->channel.mc_head->hdw) &
1392  (1 << PVR2_CVAL_INPUT_RADIO)) {
1393  vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1394  if (!vp->dev_radio) goto fail;
1395  pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1396  }
1397 
1398  return vp;
1399  fail:
1400  pvr2_trace(PVR2_TRACE_STRUCT,"Failure creating pvr2_v4l2 id=%p",vp);
1401  pvr2_v4l2_destroy_no_lock(vp);
1402  return NULL;
1403 }
1404 
1405 /*
1406  Stuff for Emacs to see, in order to encourage consistent editing style:
1407  *** Local Variables: ***
1408  *** mode: c ***
1409  *** fill-column: 75 ***
1410  *** tab-width: 8 ***
1411  *** c-basic-offset: 8 ***
1412  *** End: ***
1413  */