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