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