?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.34-rc3
[pohmelfs.git] / drivers / media / video / pvrusb2 / pvrusb2-v4l2.c
blobcc8ddb2d2382902bb8e67194e3b79dfeaad0a65c
1 /*
2 *
3 *
4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
5 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
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/version.h>
24 #include "pvrusb2-context.h"
25 #include "pvrusb2-hdw.h"
26 #include "pvrusb2.h"
27 #include "pvrusb2-debug.h"
28 #include "pvrusb2-v4l2.h"
29 #include "pvrusb2-ioread.h"
30 #include <linux/videodev2.h>
31 #include <media/v4l2-dev.h>
32 #include <media/v4l2-common.h>
33 #include <media/v4l2-ioctl.h>
34
35 struct pvr2_v4l2_dev;
36 struct pvr2_v4l2_fh;
37 struct pvr2_v4l2;
38
39 struct pvr2_v4l2_dev {
40 struct video_device devbase; /* MUST be first! */
41 struct pvr2_v4l2 *v4lp;
42 struct pvr2_context_stream *stream;
43 /* Information about this device: */
44 enum pvr2_config config; /* Expected stream format */
45 int v4l_type; /* V4L defined type for this device node */
46 enum pvr2_v4l_type minor_type; /* pvr2-understood minor device type */
47 };
48
49 struct pvr2_v4l2_fh {
50 struct pvr2_channel channel;
51 struct pvr2_v4l2_dev *dev_info;
52 enum v4l2_priority prio;
53 struct pvr2_ioread *rhp;
54 struct file *file;
55 struct pvr2_v4l2 *vhead;
56 struct pvr2_v4l2_fh *vnext;
57 struct pvr2_v4l2_fh *vprev;
58 wait_queue_head_t wait_data;
59 int fw_mode_flag;
60 /* Map contiguous ordinal value to input id */
61 unsigned char *input_map;
62 unsigned int input_cnt;
63 };
64
65 struct pvr2_v4l2 {
66 struct pvr2_channel channel;
67 struct pvr2_v4l2_fh *vfirst;
68 struct pvr2_v4l2_fh *vlast;
69
70 struct v4l2_prio_state prio;
71
72 /* streams - Note that these must be separately, individually,
73 * allocated pointers. This is because the v4l core is going to
74 * manage their deletion - separately, individually... */
75 struct pvr2_v4l2_dev *dev_video;
76 struct pvr2_v4l2_dev *dev_radio;
77 };
78
79 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
80 module_param_array(video_nr, int, NULL, 0444);
81 MODULE_PARM_DESC(video_nr, "Offset for device's video dev minor");
82 static int radio_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
83 module_param_array(radio_nr, int, NULL, 0444);
84 MODULE_PARM_DESC(radio_nr, "Offset for device's radio dev minor");
85 static int vbi_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
86 module_param_array(vbi_nr, int, NULL, 0444);
87 MODULE_PARM_DESC(vbi_nr, "Offset for device's vbi dev minor");
88
89 static struct v4l2_capability pvr_capability ={
90 .driver = "pvrusb2",
91 .card = "Hauppauge WinTV pvr-usb2",
92 .bus_info = "usb",
93 .version = KERNEL_VERSION(0, 9, 0),
94 .capabilities = (V4L2_CAP_VIDEO_CAPTURE |
95 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_RADIO |
96 V4L2_CAP_READWRITE),
97 .reserved = {0,0,0,0}
98 };
99
100 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
101 {
102 .index = 0,
103 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
104 .flags = V4L2_FMT_FLAG_COMPRESSED,
105 .description = "MPEG1/2",
106 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
107 // breaks when I do that.
108 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
109 .reserved = { 0, 0, 0, 0 }
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] = {
118 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
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] = {
137 .type = V4L2_BUF_TYPE_VBI_CAPTURE,
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 .reserved = { 0, 0 }
148 }
149 }
150 }
151 };
152
153
154 /*
155 * pvr_ioctl()
156 *
157 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
158 *
159 */
160 static long pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
161 {
162 struct pvr2_v4l2_fh *fh = file->private_data;
163 struct pvr2_v4l2 *vp = fh->vhead;
164 struct pvr2_v4l2_dev *dev_info = fh->dev_info;
165 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
166 long ret = -EINVAL;
167
168 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
169 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
170 }
171
172 if (!pvr2_hdw_dev_ok(hdw)) {
173 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
174 "ioctl failed - bad or no context");
175 return -EFAULT;
176 }
177
178 /* check priority */
179 switch (cmd) {
180 case VIDIOC_S_CTRL:
181 case VIDIOC_S_STD:
182 case VIDIOC_S_INPUT:
183 case VIDIOC_S_TUNER:
184 case VIDIOC_S_FREQUENCY:
185 ret = v4l2_prio_check(&vp->prio, &fh->prio);
186 if (ret)
187 return ret;
188 }
189
190 switch (cmd) {
191 case VIDIOC_QUERYCAP:
192 {
193 struct v4l2_capability *cap = arg;
194
195 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
196 strlcpy(cap->bus_info,pvr2_hdw_get_bus_info(hdw),
197 sizeof(cap->bus_info));
198 strlcpy(cap->card,pvr2_hdw_get_desc(hdw),sizeof(cap->card));
199
200 ret = 0;
201 break;
202 }
203
204 case VIDIOC_G_PRIORITY:
205 {
206 enum v4l2_priority *p = arg;
207
208 *p = v4l2_prio_max(&vp->prio);
209 ret = 0;
210 break;
211 }
212
213 case VIDIOC_S_PRIORITY:
214 {
215 enum v4l2_priority *prio = arg;
216
217 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
218 break;
219 }
220
221 case VIDIOC_ENUMSTD:
222 {
223 struct v4l2_standard *vs = (struct v4l2_standard *)arg;
224 int idx = vs->index;
225 ret = pvr2_hdw_get_stdenum_value(hdw,vs,idx+1);
226 break;
227 }
228
229 case VIDIOC_G_STD:
230 {
231 int val = 0;
232 ret = pvr2_ctrl_get_value(
233 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),&val);
234 *(v4l2_std_id *)arg = val;
235 break;
236 }
237
238 case VIDIOC_S_STD:
239 {
240 ret = pvr2_ctrl_set_value(
241 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
242 *(v4l2_std_id *)arg);
243 break;
244 }
245
246 case VIDIOC_ENUMINPUT:
247 {
248 struct pvr2_ctrl *cptr;
249 struct v4l2_input *vi = (struct v4l2_input *)arg;
250 struct v4l2_input tmp;
251 unsigned int cnt;
252 int val;
253
254 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
255
256 memset(&tmp,0,sizeof(tmp));
257 tmp.index = vi->index;
258 ret = 0;
259 if (vi->index >= fh->input_cnt) {
260 ret = -EINVAL;
261 break;
262 }
263 val = fh->input_map[vi->index];
264 switch (val) {
265 case PVR2_CVAL_INPUT_TV:
266 case PVR2_CVAL_INPUT_DTV:
267 case PVR2_CVAL_INPUT_RADIO:
268 tmp.type = V4L2_INPUT_TYPE_TUNER;
269 break;
270 case PVR2_CVAL_INPUT_SVIDEO:
271 case PVR2_CVAL_INPUT_COMPOSITE:
272 tmp.type = V4L2_INPUT_TYPE_CAMERA;
273 break;
274 default:
275 ret = -EINVAL;
276 break;
277 }
278 if (ret < 0) break;
279
280 cnt = 0;
281 pvr2_ctrl_get_valname(cptr,val,
282 tmp.name,sizeof(tmp.name)-1,&cnt);
283 tmp.name[cnt] = 0;
284
285 /* Don't bother with audioset, since this driver currently
286 always switches the audio whenever the video is
287 switched. */
288
289 /* Handling std is a tougher problem. It doesn't make
290 sense in cases where a device might be multi-standard.
291 We could just copy out the current value for the
292 standard, but it can change over time. For now just
293 leave it zero. */
294
295 memcpy(vi, &tmp, sizeof(tmp));
296
297 ret = 0;
298 break;
299 }
300
301 case VIDIOC_G_INPUT:
302 {
303 unsigned int idx;
304 struct pvr2_ctrl *cptr;
305 struct v4l2_input *vi = (struct v4l2_input *)arg;
306 int val;
307 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
308 val = 0;
309 ret = pvr2_ctrl_get_value(cptr,&val);
310 vi->index = 0;
311 for (idx = 0; idx < fh->input_cnt; idx++) {
312 if (fh->input_map[idx] == val) {
313 vi->index = idx;
314 break;
315 }
316 }
317 break;
318 }
319
320 case VIDIOC_S_INPUT:
321 {
322 struct v4l2_input *vi = (struct v4l2_input *)arg;
323 if (vi->index >= fh->input_cnt) {
324 ret = -ERANGE;
325 break;
326 }
327 ret = pvr2_ctrl_set_value(
328 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
329 fh->input_map[vi->index]);
330 break;
331 }
332
333 case VIDIOC_ENUMAUDIO:
334 {
335 /* pkt: FIXME: We are returning one "fake" input here
336 which could very well be called "whatever_we_like".
337 This is for apps that want to see an audio input
338 just to feel comfortable, as well as to test if
339 it can do stereo or sth. There is actually no guarantee
340 that the actual audio input cannot change behind the app's
341 back, but most applications should not mind that either.
342
343 Hopefully, mplayer people will work with us on this (this
344 whole mess is to support mplayer pvr://), or Hans will come
345 up with a more standard way to say "we have inputs but we
346 don 't want you to change them independent of video" which
347 will sort this mess.
348 */
349 struct v4l2_audio *vin = arg;
350 ret = -EINVAL;
351 if (vin->index > 0) break;
352 strncpy(vin->name, "PVRUSB2 Audio",14);
353 vin->capability = V4L2_AUDCAP_STEREO;
354 ret = 0;
355 break;
356 break;
357 }
358
359 case VIDIOC_G_AUDIO:
360 {
361 /* pkt: FIXME: see above comment (VIDIOC_ENUMAUDIO) */
362 struct v4l2_audio *vin = arg;
363 memset(vin,0,sizeof(*vin));
364 vin->index = 0;
365 strncpy(vin->name, "PVRUSB2 Audio",14);
366 vin->capability = V4L2_AUDCAP_STEREO;
367 ret = 0;
368 break;
369 }
370
371 case VIDIOC_S_AUDIO:
372 {
373 ret = -EINVAL;
374 break;
375 }
376 case VIDIOC_G_TUNER:
377 {
378 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
379
380 if (vt->index != 0) break; /* Only answer for the 1st tuner */
381
382 pvr2_hdw_execute_tuner_poll(hdw);
383 ret = pvr2_hdw_get_tuner_status(hdw,vt);
384 break;
385 }
386
387 case VIDIOC_S_TUNER:
388 {
389 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
390
391 if (vt->index != 0)
392 break;
393
394 ret = pvr2_ctrl_set_value(
395 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
396 vt->audmode);
397 break;
398 }
399
400 case VIDIOC_S_FREQUENCY:
401 {
402 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
403 unsigned long fv;
404 struct v4l2_tuner vt;
405 int cur_input;
406 struct pvr2_ctrl *ctrlp;
407 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
408 if (ret != 0) break;
409 ctrlp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
410 ret = pvr2_ctrl_get_value(ctrlp,&cur_input);
411 if (ret != 0) break;
412 if (vf->type == V4L2_TUNER_RADIO) {
413 if (cur_input != PVR2_CVAL_INPUT_RADIO) {
414 pvr2_ctrl_set_value(ctrlp,
415 PVR2_CVAL_INPUT_RADIO);
416 }
417 } else {
418 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
419 pvr2_ctrl_set_value(ctrlp,
420 PVR2_CVAL_INPUT_TV);
421 }
422 }
423 fv = vf->frequency;
424 if (vt.capability & V4L2_TUNER_CAP_LOW) {
425 fv = (fv * 125) / 2;
426 } else {
427 fv = fv * 62500;
428 }
429 ret = pvr2_ctrl_set_value(
430 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),fv);
431 break;
432 }
433
434 case VIDIOC_G_FREQUENCY:
435 {
436 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
437 int val = 0;
438 int cur_input;
439 struct v4l2_tuner vt;
440 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
441 if (ret != 0) break;
442 ret = pvr2_ctrl_get_value(
443 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
444 &val);
445 if (ret != 0) break;
446 pvr2_ctrl_get_value(
447 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
448 &cur_input);
449 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
450 vf->type = V4L2_TUNER_RADIO;
451 } else {
452 vf->type = V4L2_TUNER_ANALOG_TV;
453 }
454 if (vt.capability & V4L2_TUNER_CAP_LOW) {
455 val = (val * 2) / 125;
456 } else {
457 val /= 62500;
458 }
459 vf->frequency = val;
460 break;
461 }
462
463 case VIDIOC_ENUM_FMT:
464 {
465 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
466
467 /* Only one format is supported : mpeg.*/
468 if (fd->index != 0)
469 break;
470
471 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
472 ret = 0;
473 break;
474 }
475
476 case VIDIOC_G_FMT:
477 {
478 struct v4l2_format *vf = (struct v4l2_format *)arg;
479 int val;
480 switch(vf->type) {
481 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
482 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
483 sizeof(struct v4l2_format));
484 val = 0;
485 pvr2_ctrl_get_value(
486 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
487 &val);
488 vf->fmt.pix.width = val;
489 val = 0;
490 pvr2_ctrl_get_value(
491 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
492 &val);
493 vf->fmt.pix.height = val;
494 ret = 0;
495 break;
496 case V4L2_BUF_TYPE_VBI_CAPTURE:
497 // ????? Still need to figure out to do VBI correctly
498 ret = -EINVAL;
499 break;
500 default:
501 ret = -EINVAL;
502 break;
503 }
504 break;
505 }
506
507 case VIDIOC_TRY_FMT:
508 case VIDIOC_S_FMT:
509 {
510 struct v4l2_format *vf = (struct v4l2_format *)arg;
511
512 ret = 0;
513 switch(vf->type) {
514 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
515 int lmin,lmax,ldef;
516 struct pvr2_ctrl *hcp,*vcp;
517 int h = vf->fmt.pix.height;
518 int w = vf->fmt.pix.width;
519 hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
520 vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
521
522 lmin = pvr2_ctrl_get_min(hcp);
523 lmax = pvr2_ctrl_get_max(hcp);
524 pvr2_ctrl_get_def(hcp, &ldef);
525 if (w == -1) {
526 w = ldef;
527 } else if (w < lmin) {
528 w = lmin;
529 } else if (w > lmax) {
530 w = lmax;
531 }
532 lmin = pvr2_ctrl_get_min(vcp);
533 lmax = pvr2_ctrl_get_max(vcp);
534 pvr2_ctrl_get_def(vcp, &ldef);
535 if (h == -1) {
536 h = ldef;
537 } else if (h < lmin) {
538 h = lmin;
539 } else if (h > lmax) {
540 h = lmax;
541 }
542
543 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
544 sizeof(struct v4l2_format));
545 vf->fmt.pix.width = w;
546 vf->fmt.pix.height = h;
547
548 if (cmd == VIDIOC_S_FMT) {
549 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
550 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
551 }
552 } break;
553 case V4L2_BUF_TYPE_VBI_CAPTURE:
554 // ????? Still need to figure out to do VBI correctly
555 ret = -EINVAL;
556 break;
557 default:
558 ret = -EINVAL;
559 break;
560 }
561 break;
562 }
563
564 case VIDIOC_STREAMON:
565 {
566 if (!fh->dev_info->stream) {
567 /* No stream defined for this node. This means
568 that we're not currently allowed to stream from
569 this node. */
570 ret = -EPERM;
571 break;
572 }
573 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
574 if (ret < 0) return ret;
575 ret = pvr2_hdw_set_streaming(hdw,!0);
576 break;
577 }
578
579 case VIDIOC_STREAMOFF:
580 {
581 if (!fh->dev_info->stream) {
582 /* No stream defined for this node. This means
583 that we're not currently allowed to stream from
584 this node. */
585 ret = -EPERM;
586 break;
587 }
588 ret = pvr2_hdw_set_streaming(hdw,0);
589 break;
590 }
591
592 case VIDIOC_QUERYCTRL:
593 {
594 struct pvr2_ctrl *cptr;
595 int val;
596 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
597 ret = 0;
598 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
599 cptr = pvr2_hdw_get_ctrl_nextv4l(
600 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
601 if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
602 } else {
603 cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
604 }
605 if (!cptr) {
606 pvr2_trace(PVR2_TRACE_V4LIOCTL,
607 "QUERYCTRL id=0x%x not implemented here",
608 vc->id);
609 ret = -EINVAL;
610 break;
611 }
612
613 pvr2_trace(PVR2_TRACE_V4LIOCTL,
614 "QUERYCTRL id=0x%x mapping name=%s (%s)",
615 vc->id,pvr2_ctrl_get_name(cptr),
616 pvr2_ctrl_get_desc(cptr));
617 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
618 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
619 pvr2_ctrl_get_def(cptr, &val);
620 vc->default_value = val;
621 switch (pvr2_ctrl_get_type(cptr)) {
622 case pvr2_ctl_enum:
623 vc->type = V4L2_CTRL_TYPE_MENU;
624 vc->minimum = 0;
625 vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
626 vc->step = 1;
627 break;
628 case pvr2_ctl_bool:
629 vc->type = V4L2_CTRL_TYPE_BOOLEAN;
630 vc->minimum = 0;
631 vc->maximum = 1;
632 vc->step = 1;
633 break;
634 case pvr2_ctl_int:
635 vc->type = V4L2_CTRL_TYPE_INTEGER;
636 vc->minimum = pvr2_ctrl_get_min(cptr);
637 vc->maximum = pvr2_ctrl_get_max(cptr);
638 vc->step = 1;
639 break;
640 default:
641 pvr2_trace(PVR2_TRACE_V4LIOCTL,
642 "QUERYCTRL id=0x%x name=%s not mappable",
643 vc->id,pvr2_ctrl_get_name(cptr));
644 ret = -EINVAL;
645 break;
646 }
647 break;
648 }
649
650 case VIDIOC_QUERYMENU:
651 {
652 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
653 unsigned int cnt = 0;
654 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
655 vm->index,
656 vm->name,sizeof(vm->name)-1,
657 &cnt);
658 vm->name[cnt] = 0;
659 break;
660 }
661
662 case VIDIOC_G_CTRL:
663 {
664 struct v4l2_control *vc = (struct v4l2_control *)arg;
665 int val = 0;
666 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
667 &val);
668 vc->value = val;
669 break;
670 }
671
672 case VIDIOC_S_CTRL:
673 {
674 struct v4l2_control *vc = (struct v4l2_control *)arg;
675 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
676 vc->value);
677 break;
678 }
679
680 case VIDIOC_G_EXT_CTRLS:
681 {
682 struct v4l2_ext_controls *ctls =
683 (struct v4l2_ext_controls *)arg;
684 struct v4l2_ext_control *ctrl;
685 unsigned int idx;
686 int val;
687 ret = 0;
688 for (idx = 0; idx < ctls->count; idx++) {
689 ctrl = ctls->controls + idx;
690 ret = pvr2_ctrl_get_value(
691 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
692 if (ret) {
693 ctls->error_idx = idx;
694 break;
695 }
696 /* Ensure that if read as a 64 bit value, the user
697 will still get a hopefully sane value */
698 ctrl->value64 = 0;
699 ctrl->value = val;
700 }
701 break;
702 }
703
704 case VIDIOC_S_EXT_CTRLS:
705 {
706 struct v4l2_ext_controls *ctls =
707 (struct v4l2_ext_controls *)arg;
708 struct v4l2_ext_control *ctrl;
709 unsigned int idx;
710 ret = 0;
711 for (idx = 0; idx < ctls->count; idx++) {
712 ctrl = ctls->controls + idx;
713 ret = pvr2_ctrl_set_value(
714 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
715 ctrl->value);
716 if (ret) {
717 ctls->error_idx = idx;
718 break;
719 }
720 }
721 break;
722 }
723
724 case VIDIOC_TRY_EXT_CTRLS:
725 {
726 struct v4l2_ext_controls *ctls =
727 (struct v4l2_ext_controls *)arg;
728 struct v4l2_ext_control *ctrl;
729 struct pvr2_ctrl *pctl;
730 unsigned int idx;
731 /* For the moment just validate that the requested control
732 actually exists. */
733 ret = 0;
734 for (idx = 0; idx < ctls->count; idx++) {
735 ctrl = ctls->controls + idx;
736 pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
737 if (!pctl) {
738 ret = -EINVAL;
739 ctls->error_idx = idx;
740 break;
741 }
742 }
743 break;
744 }
745
746 case VIDIOC_CROPCAP:
747 {
748 struct v4l2_cropcap *cap = (struct v4l2_cropcap *)arg;
749 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
750 ret = -EINVAL;
751 break;
752 }
753 ret = pvr2_hdw_get_cropcap(hdw, cap);
754 cap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* paranoia */
755 break;
756 }
757 case VIDIOC_G_CROP:
758 {
759 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
760 int val = 0;
761 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
762 ret = -EINVAL;
763 break;
764 }
765 ret = pvr2_ctrl_get_value(
766 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL), &val);
767 if (ret != 0) {
768 ret = -EINVAL;
769 break;
770 }
771 crop->c.left = val;
772 ret = pvr2_ctrl_get_value(
773 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT), &val);
774 if (ret != 0) {
775 ret = -EINVAL;
776 break;
777 }
778 crop->c.top = val;
779 ret = pvr2_ctrl_get_value(
780 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW), &val);
781 if (ret != 0) {
782 ret = -EINVAL;
783 break;
784 }
785 crop->c.width = val;
786 ret = pvr2_ctrl_get_value(
787 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH), &val);
788 if (ret != 0) {
789 ret = -EINVAL;
790 break;
791 }
792 crop->c.height = val;
793 }
794 case VIDIOC_S_CROP:
795 {
796 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
797 struct v4l2_cropcap cap;
798 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
799 ret = -EINVAL;
800 break;
801 }
802 cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
803 ret = pvr2_ctrl_set_value(
804 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL),
805 crop->c.left);
806 if (ret != 0) {
807 ret = -EINVAL;
808 break;
809 }
810 ret = pvr2_ctrl_set_value(
811 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT),
812 crop->c.top);
813 if (ret != 0) {
814 ret = -EINVAL;
815 break;
816 }
817 ret = pvr2_ctrl_set_value(
818 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW),
819 crop->c.width);
820 if (ret != 0) {
821 ret = -EINVAL;
822 break;
823 }
824 ret = pvr2_ctrl_set_value(
825 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH),
826 crop->c.height);
827 if (ret != 0) {
828 ret = -EINVAL;
829 break;
830 }
831 }
832 case VIDIOC_LOG_STATUS:
833 {
834 pvr2_hdw_trigger_module_log(hdw);
835 ret = 0;
836 break;
837 }
838 #ifdef CONFIG_VIDEO_ADV_DEBUG
839 case VIDIOC_DBG_S_REGISTER:
840 case VIDIOC_DBG_G_REGISTER:
841 {
842 u64 val;
843 struct v4l2_dbg_register *req = (struct v4l2_dbg_register *)arg;
844 if (cmd == VIDIOC_DBG_S_REGISTER) val = req->val;
845 ret = pvr2_hdw_register_access(
846 hdw, &req->match, req->reg,
847 cmd == VIDIOC_DBG_S_REGISTER, &val);
848 if (cmd == VIDIOC_DBG_G_REGISTER) req->val = val;
849 break;
850 }
851 #endif
852
853 default :
854 ret = v4l_compat_translate_ioctl(file, cmd,
855 arg, pvr2_v4l2_do_ioctl);
856 }
857
858 pvr2_hdw_commit_ctl(hdw);
859
860 if (ret < 0) {
861 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
862 pvr2_trace(PVR2_TRACE_V4LIOCTL,
863 "pvr2_v4l2_do_ioctl failure, ret=%ld", ret);
864 } else {
865 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
866 pvr2_trace(PVR2_TRACE_V4LIOCTL,
867 "pvr2_v4l2_do_ioctl failure, ret=%ld"
868 " command was:", ret);
869 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
870 cmd);
871 }
872 }
873 } else {
874 pvr2_trace(PVR2_TRACE_V4LIOCTL,
875 "pvr2_v4l2_do_ioctl complete, ret=%ld (0x%lx)",
876 ret, ret);
877 }
878 return ret;
879 }
880
881 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
882 {
883 struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
884 enum pvr2_config cfg = dip->config;
885
886 pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
887
888 /* Paranoia */
889 dip->v4lp = NULL;
890 dip->stream = NULL;
891
892 /* Actual deallocation happens later when all internal references
893 are gone. */
894 video_unregister_device(&dip->devbase);
895
896 printk(KERN_INFO "pvrusb2: unregistered device %s [%s]\n",
897 video_device_node_name(&dip->devbase),
898 pvr2_config_get_name(cfg));
899
900 }
901
902
903 static void pvr2_v4l2_dev_disassociate_parent(struct pvr2_v4l2_dev *dip)
904 {
905 if (!dip) return;
906 if (!dip->devbase.parent) return;
907 dip->devbase.parent = NULL;
908 device_move(&dip->devbase.dev, NULL, DPM_ORDER_NONE);
909 }
910
911
912 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
913 {
914 if (vp->dev_video) {
915 pvr2_v4l2_dev_destroy(vp->dev_video);
916 vp->dev_video = NULL;
917 }
918 if (vp->dev_radio) {
919 pvr2_v4l2_dev_destroy(vp->dev_radio);
920 vp->dev_radio = NULL;
921 }
922
923 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
924 pvr2_channel_done(&vp->channel);
925 kfree(vp);
926 }
927
928
929 static void pvr2_video_device_release(struct video_device *vdev)
930 {
931 struct pvr2_v4l2_dev *dev;
932 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
933 kfree(dev);
934 }
935
936
937 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
938 {
939 struct pvr2_v4l2 *vp;
940 vp = container_of(chp,struct pvr2_v4l2,channel);
941 if (!vp->channel.mc_head->disconnect_flag) return;
942 pvr2_v4l2_dev_disassociate_parent(vp->dev_video);
943 pvr2_v4l2_dev_disassociate_parent(vp->dev_radio);
944 if (vp->vfirst) return;
945 pvr2_v4l2_destroy_no_lock(vp);
946 }
947
948
949 static long pvr2_v4l2_ioctl(struct file *file,
950 unsigned int cmd, unsigned long arg)
951 {
952
953 return video_usercopy(file, cmd, arg, pvr2_v4l2_do_ioctl);
954 }
955
956
957 static int pvr2_v4l2_release(struct file *file)
958 {
959 struct pvr2_v4l2_fh *fhp = file->private_data;
960 struct pvr2_v4l2 *vp = fhp->vhead;
961 struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
962
963 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
964
965 if (fhp->rhp) {
966 struct pvr2_stream *sp;
967 pvr2_hdw_set_streaming(hdw,0);
968 sp = pvr2_ioread_get_stream(fhp->rhp);
969 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
970 pvr2_ioread_destroy(fhp->rhp);
971 fhp->rhp = NULL;
972 }
973
974 v4l2_prio_close(&vp->prio, &fhp->prio);
975 file->private_data = NULL;
976
977 if (fhp->vnext) {
978 fhp->vnext->vprev = fhp->vprev;
979 } else {
980 vp->vlast = fhp->vprev;
981 }
982 if (fhp->vprev) {
983 fhp->vprev->vnext = fhp->vnext;
984 } else {
985 vp->vfirst = fhp->vnext;
986 }
987 fhp->vnext = NULL;
988 fhp->vprev = NULL;
989 fhp->vhead = NULL;
990 pvr2_channel_done(&fhp->channel);
991 pvr2_trace(PVR2_TRACE_STRUCT,
992 "Destroying pvr_v4l2_fh id=%p",fhp);
993 if (fhp->input_map) {
994 kfree(fhp->input_map);
995 fhp->input_map = NULL;
996 }
997 kfree(fhp);
998 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
999 pvr2_v4l2_destroy_no_lock(vp);
1000 }
1001 return 0;
1002 }
1003
1004
1005 static int pvr2_v4l2_open(struct file *file)
1006 {
1007 struct pvr2_v4l2_dev *dip; /* Our own context pointer */
1008 struct pvr2_v4l2_fh *fhp;
1009 struct pvr2_v4l2 *vp;
1010 struct pvr2_hdw *hdw;
1011 unsigned int input_mask = 0;
1012 unsigned int input_cnt,idx;
1013 int ret = 0;
1014
1015 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1016
1017 vp = dip->v4lp;
1018 hdw = vp->channel.hdw;
1019
1020 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1021
1022 if (!pvr2_hdw_dev_ok(hdw)) {
1023 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
1024 "pvr2_v4l2_open: hardware not ready");
1025 return -EIO;
1026 }
1027
1028 fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1029 if (!fhp) {
1030 return -ENOMEM;
1031 }
1032
1033 init_waitqueue_head(&fhp->wait_data);
1034 fhp->dev_info = dip;
1035
1036 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1037 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
1038
1039 if (dip->v4l_type == VFL_TYPE_RADIO) {
1040 /* Opening device as a radio, legal input selection subset
1041 is just the radio. */
1042 input_mask = (1 << PVR2_CVAL_INPUT_RADIO);
1043 } else {
1044 /* Opening the main V4L device, legal input selection
1045 subset includes all analog inputs. */
1046 input_mask = ((1 << PVR2_CVAL_INPUT_RADIO) |
1047 (1 << PVR2_CVAL_INPUT_TV) |
1048 (1 << PVR2_CVAL_INPUT_COMPOSITE) |
1049 (1 << PVR2_CVAL_INPUT_SVIDEO));
1050 }
1051 ret = pvr2_channel_limit_inputs(&fhp->channel,input_mask);
1052 if (ret) {
1053 pvr2_channel_done(&fhp->channel);
1054 pvr2_trace(PVR2_TRACE_STRUCT,
1055 "Destroying pvr_v4l2_fh id=%p (input mask error)",
1056 fhp);
1057
1058 kfree(fhp);
1059 return ret;
1060 }
1061
1062 input_mask &= pvr2_hdw_get_input_available(hdw);
1063 input_cnt = 0;
1064 for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1065 if (input_mask & (1 << idx)) input_cnt++;
1066 }
1067 fhp->input_cnt = input_cnt;
1068 fhp->input_map = kzalloc(input_cnt,GFP_KERNEL);
1069 if (!fhp->input_map) {
1070 pvr2_channel_done(&fhp->channel);
1071 pvr2_trace(PVR2_TRACE_STRUCT,
1072 "Destroying pvr_v4l2_fh id=%p (input map failure)",
1073 fhp);
1074 kfree(fhp);
1075 return -ENOMEM;
1076 }
1077 input_cnt = 0;
1078 for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1079 if (!(input_mask & (1 << idx))) continue;
1080 fhp->input_map[input_cnt++] = idx;
1081 }
1082
1083 fhp->vnext = NULL;
1084 fhp->vprev = vp->vlast;
1085 if (vp->vlast) {
1086 vp->vlast->vnext = fhp;
1087 } else {
1088 vp->vfirst = fhp;
1089 }
1090 vp->vlast = fhp;
1091 fhp->vhead = vp;
1092
1093 fhp->file = file;
1094 file->private_data = fhp;
1095 v4l2_prio_open(&vp->prio,&fhp->prio);
1096
1097 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
1098
1099 return 0;
1100 }
1101
1102
1103 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1104 {
1105 wake_up(&fhp->wait_data);
1106 }
1107
1108 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1109 {
1110 int ret;
1111 struct pvr2_stream *sp;
1112 struct pvr2_hdw *hdw;
1113 if (fh->rhp) return 0;
1114
1115 if (!fh->dev_info->stream) {
1116 /* No stream defined for this node. This means that we're
1117 not currently allowed to stream from this node. */
1118 return -EPERM;
1119 }
1120
1121 /* First read() attempt. Try to claim the stream and start
1122 it... */
1123 if ((ret = pvr2_channel_claim_stream(&fh->channel,
1124 fh->dev_info->stream)) != 0) {
1125 /* Someone else must already have it */
1126 return ret;
1127 }
1128
1129 fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
1130 if (!fh->rhp) {
1131 pvr2_channel_claim_stream(&fh->channel,NULL);
1132 return -ENOMEM;
1133 }
1134
1135 hdw = fh->channel.mc_head->hdw;
1136 sp = fh->dev_info->stream->stream;
1137 pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1138 pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
1139 if ((ret = pvr2_hdw_set_streaming(hdw,!0)) < 0) return ret;
1140 return pvr2_ioread_set_enabled(fh->rhp,!0);
1141 }
1142
1143
1144 static ssize_t pvr2_v4l2_read(struct file *file,
1145 char __user *buff, size_t count, loff_t *ppos)
1146 {
1147 struct pvr2_v4l2_fh *fh = file->private_data;
1148 int ret;
1149
1150 if (fh->fw_mode_flag) {
1151 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1152 char *tbuf;
1153 int c1,c2;
1154 int tcnt = 0;
1155 unsigned int offs = *ppos;
1156
1157 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1158 if (!tbuf) return -ENOMEM;
1159
1160 while (count) {
1161 c1 = count;
1162 if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1163 c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1164 if (c2 < 0) {
1165 tcnt = c2;
1166 break;
1167 }
1168 if (!c2) break;
1169 if (copy_to_user(buff,tbuf,c2)) {
1170 tcnt = -EFAULT;
1171 break;
1172 }
1173 offs += c2;
1174 tcnt += c2;
1175 buff += c2;
1176 count -= c2;
1177 *ppos += c2;
1178 }
1179 kfree(tbuf);
1180 return tcnt;
1181 }
1182
1183 if (!fh->rhp) {
1184 ret = pvr2_v4l2_iosetup(fh);
1185 if (ret) {
1186 return ret;
1187 }
1188 }
1189
1190 for (;;) {
1191 ret = pvr2_ioread_read(fh->rhp,buff,count);
1192 if (ret >= 0) break;
1193 if (ret != -EAGAIN) break;
1194 if (file->f_flags & O_NONBLOCK) break;
1195 /* Doing blocking I/O. Wait here. */
1196 ret = wait_event_interruptible(
1197 fh->wait_data,
1198 pvr2_ioread_avail(fh->rhp) >= 0);
1199 if (ret < 0) break;
1200 }
1201
1202 return ret;
1203 }
1204
1205
1206 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1207 {
1208 unsigned int mask = 0;
1209 struct pvr2_v4l2_fh *fh = file->private_data;
1210 int ret;
1211
1212 if (fh->fw_mode_flag) {
1213 mask |= POLLIN | POLLRDNORM;
1214 return mask;
1215 }
1216
1217 if (!fh->rhp) {
1218 ret = pvr2_v4l2_iosetup(fh);
1219 if (ret) return POLLERR;
1220 }
1221
1222 poll_wait(file,&fh->wait_data,wait);
1223
1224 if (pvr2_ioread_avail(fh->rhp) >= 0) {
1225 mask |= POLLIN | POLLRDNORM;
1226 }
1227
1228 return mask;
1229 }
1230
1231
1232 static const struct v4l2_file_operations vdev_fops = {
1233 .owner = THIS_MODULE,
1234 .open = pvr2_v4l2_open,
1235 .release = pvr2_v4l2_release,
1236 .read = pvr2_v4l2_read,
1237 .ioctl = pvr2_v4l2_ioctl,
1238 .poll = pvr2_v4l2_poll,
1239 };
1240
1241
1242 static struct video_device vdev_template = {
1243 .fops = &vdev_fops,
1244 };
1245
1246
1247 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1248 struct pvr2_v4l2 *vp,
1249 int v4l_type)
1250 {
1251 struct usb_device *usbdev;
1252 int mindevnum;
1253 int unit_number;
1254 int *nr_ptr = NULL;
1255 dip->v4lp = vp;
1256
1257 usbdev = pvr2_hdw_get_dev(vp->channel.mc_head->hdw);
1258 dip->v4l_type = v4l_type;
1259 switch (v4l_type) {
1260 case VFL_TYPE_GRABBER:
1261 dip->stream = &vp->channel.mc_head->video_stream;
1262 dip->config = pvr2_config_mpeg;
1263 dip->minor_type = pvr2_v4l_type_video;
1264 nr_ptr = video_nr;
1265 if (!dip->stream) {
1266 pr_err(KBUILD_MODNAME
1267 ": Failed to set up pvrusb2 v4l video dev"
1268 " due to missing stream instance\n");
1269 return;
1270 }
1271 break;
1272 case VFL_TYPE_VBI:
1273 dip->config = pvr2_config_vbi;
1274 dip->minor_type = pvr2_v4l_type_vbi;
1275 nr_ptr = vbi_nr;
1276 break;
1277 case VFL_TYPE_RADIO:
1278 dip->stream = &vp->channel.mc_head->video_stream;
1279 dip->config = pvr2_config_mpeg;
1280 dip->minor_type = pvr2_v4l_type_radio;
1281 nr_ptr = radio_nr;
1282 break;
1283 default:
1284 /* Bail out (this should be impossible) */
1285 pr_err(KBUILD_MODNAME ": Failed to set up pvrusb2 v4l dev"
1286 " due to unrecognized config\n");
1287 return;
1288 }
1289
1290 memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1291 dip->devbase.release = pvr2_video_device_release;
1292
1293 mindevnum = -1;
1294 unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1295 if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1296 mindevnum = nr_ptr[unit_number];
1297 }
1298 dip->devbase.parent = &usbdev->dev;
1299 if ((video_register_device(&dip->devbase,
1300 dip->v4l_type, mindevnum) < 0) &&
1301 (video_register_device(&dip->devbase,
1302 dip->v4l_type, -1) < 0)) {
1303 pr_err(KBUILD_MODNAME
1304 ": Failed to register pvrusb2 v4l device\n");
1305 }
1306
1307 printk(KERN_INFO "pvrusb2: registered device %s [%s]\n",
1308 video_device_node_name(&dip->devbase),
1309 pvr2_config_get_name(dip->config));
1310
1311 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1312 dip->minor_type,dip->devbase.minor);
1313 }
1314
1315
1316 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1317 {
1318 struct pvr2_v4l2 *vp;
1319
1320 vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1321 if (!vp) return vp;
1322 pvr2_channel_init(&vp->channel,mnp);
1323 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1324
1325 vp->channel.check_func = pvr2_v4l2_internal_check;
1326
1327 /* register streams */
1328 vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1329 if (!vp->dev_video) goto fail;
1330 pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1331 if (pvr2_hdw_get_input_available(vp->channel.mc_head->hdw) &
1332 (1 << PVR2_CVAL_INPUT_RADIO)) {
1333 vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1334 if (!vp->dev_radio) goto fail;
1335 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1336 }
1337
1338 return vp;
1339 fail:
1340 pvr2_trace(PVR2_TRACE_STRUCT,"Failure creating pvr2_v4l2 id=%p",vp);
1341 pvr2_v4l2_destroy_no_lock(vp);
1342 return NULL;
1343 }
1344
1345 /*
1346 Stuff for Emacs to see, in order to encourage consistent editing style:
1347 *** Local Variables: ***
1348 *** mode: c ***
1349 *** fill-column: 75 ***
1350 *** tab-width: 8 ***
1351 *** c-basic-offset: 8 ***
1352 *** End: ***
1353 */