?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / drivers / media / video / pvrusb2 / pvrusb2-v4l2.c
blobe27f8ab76966ccdebd9f1a11338b0006ea759a84
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 = LINUX_VERSION_CODE,
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_G_TUNER:
373 {
374 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
375
376 if (vt->index != 0) break; /* Only answer for the 1st tuner */
377
378 pvr2_hdw_execute_tuner_poll(hdw);
379 ret = pvr2_hdw_get_tuner_status(hdw,vt);
380 break;
381 }
382
383 case VIDIOC_S_TUNER:
384 {
385 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
386
387 if (vt->index != 0)
388 break;
389
390 ret = pvr2_ctrl_set_value(
391 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
392 vt->audmode);
393 break;
394 }
395
396 case VIDIOC_S_FREQUENCY:
397 {
398 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
399 unsigned long fv;
400 struct v4l2_tuner vt;
401 int cur_input;
402 struct pvr2_ctrl *ctrlp;
403 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
404 if (ret != 0) break;
405 ctrlp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
406 ret = pvr2_ctrl_get_value(ctrlp,&cur_input);
407 if (ret != 0) break;
408 if (vf->type == V4L2_TUNER_RADIO) {
409 if (cur_input != PVR2_CVAL_INPUT_RADIO) {
410 pvr2_ctrl_set_value(ctrlp,
411 PVR2_CVAL_INPUT_RADIO);
412 }
413 } else {
414 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
415 pvr2_ctrl_set_value(ctrlp,
416 PVR2_CVAL_INPUT_TV);
417 }
418 }
419 fv = vf->frequency;
420 if (vt.capability & V4L2_TUNER_CAP_LOW) {
421 fv = (fv * 125) / 2;
422 } else {
423 fv = fv * 62500;
424 }
425 ret = pvr2_ctrl_set_value(
426 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),fv);
427 break;
428 }
429
430 case VIDIOC_G_FREQUENCY:
431 {
432 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
433 int val = 0;
434 int cur_input;
435 struct v4l2_tuner vt;
436 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
437 if (ret != 0) break;
438 ret = pvr2_ctrl_get_value(
439 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
440 &val);
441 if (ret != 0) break;
442 pvr2_ctrl_get_value(
443 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
444 &cur_input);
445 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
446 vf->type = V4L2_TUNER_RADIO;
447 } else {
448 vf->type = V4L2_TUNER_ANALOG_TV;
449 }
450 if (vt.capability & V4L2_TUNER_CAP_LOW) {
451 val = (val * 2) / 125;
452 } else {
453 val /= 62500;
454 }
455 vf->frequency = val;
456 break;
457 }
458
459 case VIDIOC_ENUM_FMT:
460 {
461 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
462
463 /* Only one format is supported : mpeg.*/
464 if (fd->index != 0)
465 break;
466
467 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
468 ret = 0;
469 break;
470 }
471
472 case VIDIOC_G_FMT:
473 {
474 struct v4l2_format *vf = (struct v4l2_format *)arg;
475 int val;
476 switch(vf->type) {
477 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
478 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
479 sizeof(struct v4l2_format));
480 val = 0;
481 pvr2_ctrl_get_value(
482 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
483 &val);
484 vf->fmt.pix.width = val;
485 val = 0;
486 pvr2_ctrl_get_value(
487 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
488 &val);
489 vf->fmt.pix.height = val;
490 ret = 0;
491 break;
492 case V4L2_BUF_TYPE_VBI_CAPTURE:
493 // ????? Still need to figure out to do VBI correctly
494 ret = -EINVAL;
495 break;
496 default:
497 ret = -EINVAL;
498 break;
499 }
500 break;
501 }
502
503 case VIDIOC_TRY_FMT:
504 case VIDIOC_S_FMT:
505 {
506 struct v4l2_format *vf = (struct v4l2_format *)arg;
507
508 ret = 0;
509 switch(vf->type) {
510 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
511 int lmin,lmax,ldef;
512 struct pvr2_ctrl *hcp,*vcp;
513 int h = vf->fmt.pix.height;
514 int w = vf->fmt.pix.width;
515 hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
516 vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
517
518 lmin = pvr2_ctrl_get_min(hcp);
519 lmax = pvr2_ctrl_get_max(hcp);
520 pvr2_ctrl_get_def(hcp, &ldef);
521 if (w == -1) {
522 w = ldef;
523 } else if (w < lmin) {
524 w = lmin;
525 } else if (w > lmax) {
526 w = lmax;
527 }
528 lmin = pvr2_ctrl_get_min(vcp);
529 lmax = pvr2_ctrl_get_max(vcp);
530 pvr2_ctrl_get_def(vcp, &ldef);
531 if (h == -1) {
532 h = ldef;
533 } else if (h < lmin) {
534 h = lmin;
535 } else if (h > lmax) {
536 h = lmax;
537 }
538
539 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
540 sizeof(struct v4l2_format));
541 vf->fmt.pix.width = w;
542 vf->fmt.pix.height = h;
543
544 if (cmd == VIDIOC_S_FMT) {
545 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
546 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
547 }
548 } break;
549 case V4L2_BUF_TYPE_VBI_CAPTURE:
550 // ????? Still need to figure out to do VBI correctly
551 ret = -EINVAL;
552 break;
553 default:
554 ret = -EINVAL;
555 break;
556 }
557 break;
558 }
559
560 case VIDIOC_STREAMON:
561 {
562 if (!fh->pdi->stream) {
563 /* No stream defined for this node. This means
564 that we're not currently allowed to stream from
565 this node. */
566 ret = -EPERM;
567 break;
568 }
569 ret = pvr2_hdw_set_stream_type(hdw,pdi->config);
570 if (ret < 0) return ret;
571 ret = pvr2_hdw_set_streaming(hdw,!0);
572 break;
573 }
574
575 case VIDIOC_STREAMOFF:
576 {
577 if (!fh->pdi->stream) {
578 /* No stream defined for this node. This means
579 that we're not currently allowed to stream from
580 this node. */
581 ret = -EPERM;
582 break;
583 }
584 ret = pvr2_hdw_set_streaming(hdw,0);
585 break;
586 }
587
588 case VIDIOC_QUERYCTRL:
589 {
590 struct pvr2_ctrl *cptr;
591 int val;
592 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
593 ret = 0;
594 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
595 cptr = pvr2_hdw_get_ctrl_nextv4l(
596 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
597 if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
598 } else {
599 cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
600 }
601 if (!cptr) {
602 pvr2_trace(PVR2_TRACE_V4LIOCTL,
603 "QUERYCTRL id=0x%x not implemented here",
604 vc->id);
605 ret = -EINVAL;
606 break;
607 }
608
609 pvr2_trace(PVR2_TRACE_V4LIOCTL,
610 "QUERYCTRL id=0x%x mapping name=%s (%s)",
611 vc->id,pvr2_ctrl_get_name(cptr),
612 pvr2_ctrl_get_desc(cptr));
613 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
614 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
615 pvr2_ctrl_get_def(cptr, &val);
616 vc->default_value = val;
617 switch (pvr2_ctrl_get_type(cptr)) {
618 case pvr2_ctl_enum:
619 vc->type = V4L2_CTRL_TYPE_MENU;
620 vc->minimum = 0;
621 vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
622 vc->step = 1;
623 break;
624 case pvr2_ctl_bool:
625 vc->type = V4L2_CTRL_TYPE_BOOLEAN;
626 vc->minimum = 0;
627 vc->maximum = 1;
628 vc->step = 1;
629 break;
630 case pvr2_ctl_int:
631 vc->type = V4L2_CTRL_TYPE_INTEGER;
632 vc->minimum = pvr2_ctrl_get_min(cptr);
633 vc->maximum = pvr2_ctrl_get_max(cptr);
634 vc->step = 1;
635 break;
636 default:
637 pvr2_trace(PVR2_TRACE_V4LIOCTL,
638 "QUERYCTRL id=0x%x name=%s not mappable",
639 vc->id,pvr2_ctrl_get_name(cptr));
640 ret = -EINVAL;
641 break;
642 }
643 break;
644 }
645
646 case VIDIOC_QUERYMENU:
647 {
648 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
649 unsigned int cnt = 0;
650 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
651 vm->index,
652 vm->name,sizeof(vm->name)-1,
653 &cnt);
654 vm->name[cnt] = 0;
655 break;
656 }
657
658 case VIDIOC_G_CTRL:
659 {
660 struct v4l2_control *vc = (struct v4l2_control *)arg;
661 int val = 0;
662 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
663 &val);
664 vc->value = val;
665 break;
666 }
667
668 case VIDIOC_S_CTRL:
669 {
670 struct v4l2_control *vc = (struct v4l2_control *)arg;
671 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
672 vc->value);
673 break;
674 }
675
676 case VIDIOC_G_EXT_CTRLS:
677 {
678 struct v4l2_ext_controls *ctls =
679 (struct v4l2_ext_controls *)arg;
680 struct v4l2_ext_control *ctrl;
681 unsigned int idx;
682 int val;
683 ret = 0;
684 for (idx = 0; idx < ctls->count; idx++) {
685 ctrl = ctls->controls + idx;
686 ret = pvr2_ctrl_get_value(
687 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
688 if (ret) {
689 ctls->error_idx = idx;
690 break;
691 }
692 /* Ensure that if read as a 64 bit value, the user
693 will still get a hopefully sane value */
694 ctrl->value64 = 0;
695 ctrl->value = val;
696 }
697 break;
698 }
699
700 case VIDIOC_S_EXT_CTRLS:
701 {
702 struct v4l2_ext_controls *ctls =
703 (struct v4l2_ext_controls *)arg;
704 struct v4l2_ext_control *ctrl;
705 unsigned int idx;
706 ret = 0;
707 for (idx = 0; idx < ctls->count; idx++) {
708 ctrl = ctls->controls + idx;
709 ret = pvr2_ctrl_set_value(
710 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
711 ctrl->value);
712 if (ret) {
713 ctls->error_idx = idx;
714 break;
715 }
716 }
717 break;
718 }
719
720 case VIDIOC_TRY_EXT_CTRLS:
721 {
722 struct v4l2_ext_controls *ctls =
723 (struct v4l2_ext_controls *)arg;
724 struct v4l2_ext_control *ctrl;
725 struct pvr2_ctrl *pctl;
726 unsigned int idx;
727 /* For the moment just validate that the requested control
728 actually exists. */
729 ret = 0;
730 for (idx = 0; idx < ctls->count; idx++) {
731 ctrl = ctls->controls + idx;
732 pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
733 if (!pctl) {
734 ret = -EINVAL;
735 ctls->error_idx = idx;
736 break;
737 }
738 }
739 break;
740 }
741
742 case VIDIOC_CROPCAP:
743 {
744 struct v4l2_cropcap *cap = (struct v4l2_cropcap *)arg;
745 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
746 ret = -EINVAL;
747 break;
748 }
749 ret = pvr2_hdw_get_cropcap(hdw, cap);
750 cap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* paranoia */
751 break;
752 }
753 case VIDIOC_G_CROP:
754 {
755 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
756 int val = 0;
757 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
758 ret = -EINVAL;
759 break;
760 }
761 ret = pvr2_ctrl_get_value(
762 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL), &val);
763 if (ret != 0) {
764 ret = -EINVAL;
765 break;
766 }
767 crop->c.left = val;
768 ret = pvr2_ctrl_get_value(
769 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT), &val);
770 if (ret != 0) {
771 ret = -EINVAL;
772 break;
773 }
774 crop->c.top = val;
775 ret = pvr2_ctrl_get_value(
776 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW), &val);
777 if (ret != 0) {
778 ret = -EINVAL;
779 break;
780 }
781 crop->c.width = val;
782 ret = pvr2_ctrl_get_value(
783 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH), &val);
784 if (ret != 0) {
785 ret = -EINVAL;
786 break;
787 }
788 crop->c.height = val;
789 }
790 case VIDIOC_S_CROP:
791 {
792 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
793 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
794 ret = -EINVAL;
795 break;
796 }
797 ret = pvr2_ctrl_set_value(
798 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL),
799 crop->c.left);
800 if (ret != 0) {
801 ret = -EINVAL;
802 break;
803 }
804 ret = pvr2_ctrl_set_value(
805 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT),
806 crop->c.top);
807 if (ret != 0) {
808 ret = -EINVAL;
809 break;
810 }
811 ret = pvr2_ctrl_set_value(
812 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW),
813 crop->c.width);
814 if (ret != 0) {
815 ret = -EINVAL;
816 break;
817 }
818 ret = pvr2_ctrl_set_value(
819 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH),
820 crop->c.height);
821 if (ret != 0) {
822 ret = -EINVAL;
823 break;
824 }
825 }
826 case VIDIOC_LOG_STATUS:
827 {
828 pvr2_hdw_trigger_module_log(hdw);
829 ret = 0;
830 break;
831 }
832 #ifdef CONFIG_VIDEO_ADV_DEBUG
833 case VIDIOC_DBG_S_REGISTER:
834 case VIDIOC_DBG_G_REGISTER:
835 {
836 u64 val;
837 struct v4l2_dbg_register *req = (struct v4l2_dbg_register *)arg;
838 if (cmd == VIDIOC_DBG_S_REGISTER) val = req->val;
839 ret = pvr2_hdw_register_access(
840 hdw, &req->match, req->reg,
841 cmd == VIDIOC_DBG_S_REGISTER, &val);
842 if (cmd == VIDIOC_DBG_G_REGISTER) req->val = val;
843 break;
844 }
845 #endif
846
847 default :
848 ret = -ENOTTY;
849 break;
850 }
851
852 pvr2_hdw_commit_ctl(hdw);
853
854 if (ret < 0) {
855 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
856 pvr2_trace(PVR2_TRACE_V4LIOCTL,
857 "pvr2_v4l2_do_ioctl failure, ret=%ld", ret);
858 } else {
859 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
860 pvr2_trace(PVR2_TRACE_V4LIOCTL,
861 "pvr2_v4l2_do_ioctl failure, ret=%ld"
862 " command was:", ret);
863 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
864 cmd);
865 }
866 }
867 } else {
868 pvr2_trace(PVR2_TRACE_V4LIOCTL,
869 "pvr2_v4l2_do_ioctl complete, ret=%ld (0x%lx)",
870 ret, ret);
871 }
872 return ret;
873 }
874
875 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
876 {
877 struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
878 enum pvr2_config cfg = dip->config;
879 char msg[80];
880 unsigned int mcnt;
881
882 /* Construct the unregistration message *before* we actually
883 perform the unregistration step. By doing it this way we don't
884 have to worry about potentially touching deleted resources. */
885 mcnt = scnprintf(msg, sizeof(msg) - 1,
886 "pvrusb2: unregistered device %s [%s]",
887 video_device_node_name(&dip->devbase),
888 pvr2_config_get_name(cfg));
889 msg[mcnt] = 0;
890
891 pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
892
893 /* Paranoia */
894 dip->v4lp = NULL;
895 dip->stream = NULL;
896
897 /* Actual deallocation happens later when all internal references
898 are gone. */
899 video_unregister_device(&dip->devbase);
900
901 printk(KERN_INFO "%s\n", msg);
902
903 }
904
905
906 static void pvr2_v4l2_dev_disassociate_parent(struct pvr2_v4l2_dev *dip)
907 {
908 if (!dip) return;
909 if (!dip->devbase.parent) return;
910 dip->devbase.parent = NULL;
911 device_move(&dip->devbase.dev, NULL, DPM_ORDER_NONE);
912 }
913
914
915 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
916 {
917 if (vp->dev_video) {
918 pvr2_v4l2_dev_destroy(vp->dev_video);
919 vp->dev_video = NULL;
920 }
921 if (vp->dev_radio) {
922 pvr2_v4l2_dev_destroy(vp->dev_radio);
923 vp->dev_radio = NULL;
924 }
925
926 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
927 pvr2_channel_done(&vp->channel);
928 kfree(vp);
929 }
930
931
932 static void pvr2_video_device_release(struct video_device *vdev)
933 {
934 struct pvr2_v4l2_dev *dev;
935 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
936 kfree(dev);
937 }
938
939
940 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
941 {
942 struct pvr2_v4l2 *vp;
943 vp = container_of(chp,struct pvr2_v4l2,channel);
944 if (!vp->channel.mc_head->disconnect_flag) return;
945 pvr2_v4l2_dev_disassociate_parent(vp->dev_video);
946 pvr2_v4l2_dev_disassociate_parent(vp->dev_radio);
947 if (vp->vfirst) return;
948 pvr2_v4l2_destroy_no_lock(vp);
949 }
950
951
952 static long pvr2_v4l2_ioctl(struct file *file,
953 unsigned int cmd, unsigned long arg)
954 {
955
956 return video_usercopy(file, cmd, arg, pvr2_v4l2_do_ioctl);
957 }
958
959
960 static int pvr2_v4l2_release(struct file *file)
961 {
962 struct pvr2_v4l2_fh *fhp = file->private_data;
963 struct pvr2_v4l2 *vp = fhp->vhead;
964 struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
965
966 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
967
968 if (fhp->rhp) {
969 struct pvr2_stream *sp;
970 pvr2_hdw_set_streaming(hdw,0);
971 sp = pvr2_ioread_get_stream(fhp->rhp);
972 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
973 pvr2_ioread_destroy(fhp->rhp);
974 fhp->rhp = NULL;
975 }
976
977 v4l2_prio_close(&vp->prio, fhp->prio);
978 file->private_data = NULL;
979
980 if (fhp->vnext) {
981 fhp->vnext->vprev = fhp->vprev;
982 } else {
983 vp->vlast = fhp->vprev;
984 }
985 if (fhp->vprev) {
986 fhp->vprev->vnext = fhp->vnext;
987 } else {
988 vp->vfirst = fhp->vnext;
989 }
990 fhp->vnext = NULL;
991 fhp->vprev = NULL;
992 fhp->vhead = NULL;
993 pvr2_channel_done(&fhp->channel);
994 pvr2_trace(PVR2_TRACE_STRUCT,
995 "Destroying pvr_v4l2_fh id=%p",fhp);
996 if (fhp->input_map) {
997 kfree(fhp->input_map);
998 fhp->input_map = NULL;
999 }
1000 kfree(fhp);
1001 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
1002 pvr2_v4l2_destroy_no_lock(vp);
1003 }
1004 return 0;
1005 }
1006
1007
1008 static int pvr2_v4l2_open(struct file *file)
1009 {
1010 struct pvr2_v4l2_dev *dip; /* Our own context pointer */
1011 struct pvr2_v4l2_fh *fhp;
1012 struct pvr2_v4l2 *vp;
1013 struct pvr2_hdw *hdw;
1014 unsigned int input_mask = 0;
1015 unsigned int input_cnt,idx;
1016 int ret = 0;
1017
1018 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1019
1020 vp = dip->v4lp;
1021 hdw = vp->channel.hdw;
1022
1023 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1024
1025 if (!pvr2_hdw_dev_ok(hdw)) {
1026 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
1027 "pvr2_v4l2_open: hardware not ready");
1028 return -EIO;
1029 }
1030
1031 fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1032 if (!fhp) {
1033 return -ENOMEM;
1034 }
1035
1036 init_waitqueue_head(&fhp->wait_data);
1037 fhp->pdi = dip;
1038
1039 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1040 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
1041
1042 if (dip->v4l_type == VFL_TYPE_RADIO) {
1043 /* Opening device as a radio, legal input selection subset
1044 is just the radio. */
1045 input_mask = (1 << PVR2_CVAL_INPUT_RADIO);
1046 } else {
1047 /* Opening the main V4L device, legal input selection
1048 subset includes all analog inputs. */
1049 input_mask = ((1 << PVR2_CVAL_INPUT_RADIO) |
1050 (1 << PVR2_CVAL_INPUT_TV) |
1051 (1 << PVR2_CVAL_INPUT_COMPOSITE) |
1052 (1 << PVR2_CVAL_INPUT_SVIDEO));
1053 }
1054 ret = pvr2_channel_limit_inputs(&fhp->channel,input_mask);
1055 if (ret) {
1056 pvr2_channel_done(&fhp->channel);
1057 pvr2_trace(PVR2_TRACE_STRUCT,
1058 "Destroying pvr_v4l2_fh id=%p (input mask error)",
1059 fhp);
1060
1061 kfree(fhp);
1062 return ret;
1063 }
1064
1065 input_mask &= pvr2_hdw_get_input_available(hdw);
1066 input_cnt = 0;
1067 for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1068 if (input_mask & (1 << idx)) input_cnt++;
1069 }
1070 fhp->input_cnt = input_cnt;
1071 fhp->input_map = kzalloc(input_cnt,GFP_KERNEL);
1072 if (!fhp->input_map) {
1073 pvr2_channel_done(&fhp->channel);
1074 pvr2_trace(PVR2_TRACE_STRUCT,
1075 "Destroying pvr_v4l2_fh id=%p (input map failure)",
1076 fhp);
1077 kfree(fhp);
1078 return -ENOMEM;
1079 }
1080 input_cnt = 0;
1081 for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1082 if (!(input_mask & (1 << idx))) continue;
1083 fhp->input_map[input_cnt++] = idx;
1084 }
1085
1086 fhp->vnext = NULL;
1087 fhp->vprev = vp->vlast;
1088 if (vp->vlast) {
1089 vp->vlast->vnext = fhp;
1090 } else {
1091 vp->vfirst = fhp;
1092 }
1093 vp->vlast = fhp;
1094 fhp->vhead = vp;
1095
1096 fhp->file = file;
1097 file->private_data = fhp;
1098 v4l2_prio_open(&vp->prio, &fhp->prio);
1099
1100 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
1101
1102 return 0;
1103 }
1104
1105
1106 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1107 {
1108 wake_up(&fhp->wait_data);
1109 }
1110
1111 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1112 {
1113 int ret;
1114 struct pvr2_stream *sp;
1115 struct pvr2_hdw *hdw;
1116 if (fh->rhp) return 0;
1117
1118 if (!fh->pdi->stream) {
1119 /* No stream defined for this node. This means that we're
1120 not currently allowed to stream from this node. */
1121 return -EPERM;
1122 }
1123
1124 /* First read() attempt. Try to claim the stream and start
1125 it... */
1126 if ((ret = pvr2_channel_claim_stream(&fh->channel,
1127 fh->pdi->stream)) != 0) {
1128 /* Someone else must already have it */
1129 return ret;
1130 }
1131
1132 fh->rhp = pvr2_channel_create_mpeg_stream(fh->pdi->stream);
1133 if (!fh->rhp) {
1134 pvr2_channel_claim_stream(&fh->channel,NULL);
1135 return -ENOMEM;
1136 }
1137
1138 hdw = fh->channel.mc_head->hdw;
1139 sp = fh->pdi->stream->stream;
1140 pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1141 pvr2_hdw_set_stream_type(hdw,fh->pdi->config);
1142 if ((ret = pvr2_hdw_set_streaming(hdw,!0)) < 0) return ret;
1143 return pvr2_ioread_set_enabled(fh->rhp,!0);
1144 }
1145
1146
1147 static ssize_t pvr2_v4l2_read(struct file *file,
1148 char __user *buff, size_t count, loff_t *ppos)
1149 {
1150 struct pvr2_v4l2_fh *fh = file->private_data;
1151 int ret;
1152
1153 if (fh->fw_mode_flag) {
1154 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1155 char *tbuf;
1156 int c1,c2;
1157 int tcnt = 0;
1158 unsigned int offs = *ppos;
1159
1160 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1161 if (!tbuf) return -ENOMEM;
1162
1163 while (count) {
1164 c1 = count;
1165 if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1166 c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1167 if (c2 < 0) {
1168 tcnt = c2;
1169 break;
1170 }
1171 if (!c2) break;
1172 if (copy_to_user(buff,tbuf,c2)) {
1173 tcnt = -EFAULT;
1174 break;
1175 }
1176 offs += c2;
1177 tcnt += c2;
1178 buff += c2;
1179 count -= c2;
1180 *ppos += c2;
1181 }
1182 kfree(tbuf);
1183 return tcnt;
1184 }
1185
1186 if (!fh->rhp) {
1187 ret = pvr2_v4l2_iosetup(fh);
1188 if (ret) {
1189 return ret;
1190 }
1191 }
1192
1193 for (;;) {
1194 ret = pvr2_ioread_read(fh->rhp,buff,count);
1195 if (ret >= 0) break;
1196 if (ret != -EAGAIN) break;
1197 if (file->f_flags & O_NONBLOCK) break;
1198 /* Doing blocking I/O. Wait here. */
1199 ret = wait_event_interruptible(
1200 fh->wait_data,
1201 pvr2_ioread_avail(fh->rhp) >= 0);
1202 if (ret < 0) break;
1203 }
1204
1205 return ret;
1206 }
1207
1208
1209 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1210 {
1211 unsigned int mask = 0;
1212 struct pvr2_v4l2_fh *fh = file->private_data;
1213 int ret;
1214
1215 if (fh->fw_mode_flag) {
1216 mask |= POLLIN | POLLRDNORM;
1217 return mask;
1218 }
1219
1220 if (!fh->rhp) {
1221 ret = pvr2_v4l2_iosetup(fh);
1222 if (ret) return POLLERR;
1223 }
1224
1225 poll_wait(file,&fh->wait_data,wait);
1226
1227 if (pvr2_ioread_avail(fh->rhp) >= 0) {
1228 mask |= POLLIN | POLLRDNORM;
1229 }
1230
1231 return mask;
1232 }
1233
1234
1235 static const struct v4l2_file_operations vdev_fops = {
1236 .owner = THIS_MODULE,
1237 .open = pvr2_v4l2_open,
1238 .release = pvr2_v4l2_release,
1239 .read = pvr2_v4l2_read,
1240 .ioctl = pvr2_v4l2_ioctl,
1241 .poll = pvr2_v4l2_poll,
1242 };
1243
1244
1245 static struct video_device vdev_template = {
1246 .fops = &vdev_fops,
1247 };
1248
1249
1250 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1251 struct pvr2_v4l2 *vp,
1252 int v4l_type)
1253 {
1254 struct usb_device *usbdev;
1255 int mindevnum;
1256 int unit_number;
1257 int *nr_ptr = NULL;
1258 dip->v4lp = vp;
1259
1260 usbdev = pvr2_hdw_get_dev(vp->channel.mc_head->hdw);
1261 dip->v4l_type = v4l_type;
1262 switch (v4l_type) {
1263 case VFL_TYPE_GRABBER:
1264 dip->stream = &vp->channel.mc_head->video_stream;
1265 dip->config = pvr2_config_mpeg;
1266 dip->minor_type = pvr2_v4l_type_video;
1267 nr_ptr = video_nr;
1268 if (!dip->stream) {
1269 pr_err(KBUILD_MODNAME
1270 ": Failed to set up pvrusb2 v4l video dev"
1271 " due to missing stream instance\n");
1272 return;
1273 }
1274 break;
1275 case VFL_TYPE_VBI:
1276 dip->config = pvr2_config_vbi;
1277 dip->minor_type = pvr2_v4l_type_vbi;
1278 nr_ptr = vbi_nr;
1279 break;
1280 case VFL_TYPE_RADIO:
1281 dip->stream = &vp->channel.mc_head->video_stream;
1282 dip->config = pvr2_config_mpeg;
1283 dip->minor_type = pvr2_v4l_type_radio;
1284 nr_ptr = radio_nr;
1285 break;
1286 default:
1287 /* Bail out (this should be impossible) */
1288 pr_err(KBUILD_MODNAME ": Failed to set up pvrusb2 v4l dev"
1289 " due to unrecognized config\n");
1290 return;
1291 }
1292
1293 memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1294 dip->devbase.release = pvr2_video_device_release;
1295
1296 mindevnum = -1;
1297 unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1298 if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1299 mindevnum = nr_ptr[unit_number];
1300 }
1301 dip->devbase.parent = &usbdev->dev;
1302 if ((video_register_device(&dip->devbase,
1303 dip->v4l_type, mindevnum) < 0) &&
1304 (video_register_device(&dip->devbase,
1305 dip->v4l_type, -1) < 0)) {
1306 pr_err(KBUILD_MODNAME
1307 ": Failed to register pvrusb2 v4l device\n");
1308 }
1309
1310 printk(KERN_INFO "pvrusb2: registered device %s [%s]\n",
1311 video_device_node_name(&dip->devbase),
1312 pvr2_config_get_name(dip->config));
1313
1314 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1315 dip->minor_type,dip->devbase.minor);
1316 }
1317
1318
1319 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1320 {
1321 struct pvr2_v4l2 *vp;
1322
1323 vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1324 if (!vp) return vp;
1325 pvr2_channel_init(&vp->channel,mnp);
1326 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1327
1328 vp->channel.check_func = pvr2_v4l2_internal_check;
1329
1330 /* register streams */
1331 vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1332 if (!vp->dev_video) goto fail;
1333 pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1334 if (pvr2_hdw_get_input_available(vp->channel.mc_head->hdw) &
1335 (1 << PVR2_CVAL_INPUT_RADIO)) {
1336 vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1337 if (!vp->dev_radio) goto fail;
1338 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1339 }
1340
1341 return vp;
1342 fail:
1343 pvr2_trace(PVR2_TRACE_STRUCT,"Failure creating pvr2_v4l2 id=%p",vp);
1344 pvr2_v4l2_destroy_no_lock(vp);
1345 return NULL;
1346 }
1347
1348 /*
1349 Stuff for Emacs to see, in order to encourage consistent editing style:
1350 *** Local Variables: ***
1351 *** mode: c ***
1352 *** fill-column: 75 ***
1353 *** tab-width: 8 ***
1354 *** c-basic-offset: 8 ***
1355 *** End: ***
1356 */
Linux Btrfs Development