Use dentry_path() to create full path to inode object
[pohmelfs.git] / drivers / media / video / pvrusb2 / pvrusb2-v4l2.c
blob6d666174dbb4491aff05b5f2c39c065f15b00b78
1 /*
4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
5 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
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
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.
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
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>
37 struct pvr2_v4l2_dev;
38 struct pvr2_v4l2_fh;
39 struct pvr2_v4l2;
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 */
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;
67 struct pvr2_v4l2 {
68 struct pvr2_channel channel;
69 struct pvr2_v4l2_fh *vfirst;
70 struct pvr2_v4l2_fh *vlast;
72 struct v4l2_prio_state prio;
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;
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");
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}
102 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
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 }
115 #define PVR_FORMAT_PIX 0
116 #define PVR_FORMAT_VBI 1
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
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 }
157 * pvr_ioctl()
159 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
162 static long pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
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;
170 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
171 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
174 if (!pvr2_hdw_dev_ok(hdw)) {
175 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
176 "ioctl failed - bad or no context");
177 return -EFAULT;
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;
192 switch (cmd) {
193 case VIDIOC_QUERYCAP:
195 struct v4l2_capability *cap = arg;
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));
202 ret = 0;
203 break;
206 case VIDIOC_G_PRIORITY:
208 enum v4l2_priority *p = arg;
210 *p = v4l2_prio_max(&vp->prio);
211 ret = 0;
212 break;
215 case VIDIOC_S_PRIORITY:
217 enum v4l2_priority *prio = arg;
219 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
220 break;
223 case VIDIOC_ENUMSTD:
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;
231 case VIDIOC_QUERYSTD:
233 v4l2_std_id *std = arg;
234 *std = V4L2_STD_ALL;
235 ret = pvr2_hdw_get_detected_std(hdw, std);
236 break;
239 case VIDIOC_G_STD:
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;
248 case VIDIOC_S_STD:
250 ret = pvr2_ctrl_set_value(
251 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
252 *(v4l2_std_id *)arg);
253 break;
256 case VIDIOC_ENUMINPUT:
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;
264 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
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;
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;
288 if (ret < 0) break;
290 cnt = 0;
291 pvr2_ctrl_get_valname(cptr,val,
292 tmp.name,sizeof(tmp.name)-1,&cnt);
293 tmp.name[cnt] = 0;
295 /* Don't bother with audioset, since this driver currently
296 always switches the audio whenever the video is
297 switched. */
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. */
305 memcpy(vi, &tmp, sizeof(tmp));
307 ret = 0;
308 break;
311 case VIDIOC_G_INPUT:
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;
327 break;
330 case VIDIOC_S_INPUT:
332 struct v4l2_input *vi = (struct v4l2_input *)arg;
333 if (vi->index >= fh->input_cnt) {
334 ret = -ERANGE;
335 break;
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;
343 case VIDIOC_ENUMAUDIO:
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.
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.
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;
369 case VIDIOC_G_AUDIO:
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;
381 case VIDIOC_G_TUNER:
383 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
385 if (vt->index != 0) break; /* Only answer for the 1st tuner */
387 pvr2_hdw_execute_tuner_poll(hdw);
388 ret = pvr2_hdw_get_tuner_status(hdw,vt);
389 break;
392 case VIDIOC_S_TUNER:
394 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
396 if (vt->index != 0)
397 break;
399 ret = pvr2_ctrl_set_value(
400 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
401 vt->audmode);
402 break;
405 case VIDIOC_S_FREQUENCY:
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);
422 } else {
423 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
424 pvr2_ctrl_set_value(ctrlp,
425 PVR2_CVAL_INPUT_TV);
428 fv = vf->frequency;
429 if (vt.capability & V4L2_TUNER_CAP_LOW) {
430 fv = (fv * 125) / 2;
431 } else {
432 fv = fv * 62500;
434 ret = pvr2_ctrl_set_value(
435 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),fv);
436 break;
439 case VIDIOC_G_FREQUENCY:
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;
459 if (vt.capability & V4L2_TUNER_CAP_LOW) {
460 val = (val * 2) / 125;
461 } else {
462 val /= 62500;
464 vf->frequency = val;
465 break;
468 case VIDIOC_ENUM_FMT:
470 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
472 /* Only one format is supported : mpeg.*/
473 if (fd->index != 0)
474 break;
476 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
477 ret = 0;
478 break;
481 case VIDIOC_G_FMT:
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;
509 break;
512 case VIDIOC_TRY_FMT:
513 case VIDIOC_S_FMT:
515 struct v4l2_format *vf = (struct v4l2_format *)arg;
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);
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;
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;
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;
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);
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;
566 break;
569 case VIDIOC_STREAMON:
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;
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;
584 case VIDIOC_STREAMOFF:
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;
593 ret = pvr2_hdw_set_streaming(hdw,0);
594 break;
597 case VIDIOC_QUERYCTRL:
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);
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;
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;
652 break;
655 case VIDIOC_QUERYMENU:
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;
667 case VIDIOC_G_CTRL:
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;
677 case VIDIOC_S_CTRL:
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;
685 case VIDIOC_G_EXT_CTRLS:
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;
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;
706 break;
709 case VIDIOC_S_EXT_CTRLS:
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;
726 break;
729 case VIDIOC_TRY_EXT_CTRLS:
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;
748 break;
751 case VIDIOC_CROPCAP:
753 struct v4l2_cropcap *cap = (struct v4l2_cropcap *)arg;
754 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
755 ret = -EINVAL;
756 break;
758 ret = pvr2_hdw_get_cropcap(hdw, cap);
759 cap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* paranoia */
760 break;
762 case VIDIOC_G_CROP:
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;
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;
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;
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;
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;
797 crop->c.height = val;
799 case VIDIOC_S_CROP:
801 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
802 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
803 ret = -EINVAL;
804 break;
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;
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;
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;
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;
835 case VIDIOC_LOG_STATUS:
837 pvr2_hdw_trigger_module_log(hdw);
838 ret = 0;
839 break;
841 #ifdef CONFIG_VIDEO_ADV_DEBUG
842 case VIDIOC_DBG_S_REGISTER:
843 case VIDIOC_DBG_G_REGISTER:
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;
854 #endif
856 default :
857 ret = -ENOTTY;
858 break;
861 pvr2_hdw_commit_ctl(hdw);
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);
876 } else {
877 pvr2_trace(PVR2_TRACE_V4LIOCTL,
878 "pvr2_v4l2_do_ioctl complete, ret=%ld (0x%lx)",
879 ret, ret);
881 return ret;
884 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
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;
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;
900 pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
902 /* Paranoia */
903 dip->v4lp = NULL;
904 dip->stream = NULL;
906 /* Actual deallocation happens later when all internal references
907 are gone. */
908 video_unregister_device(&dip->devbase);
910 printk(KERN_INFO "%s\n", msg);
915 static void pvr2_v4l2_dev_disassociate_parent(struct pvr2_v4l2_dev *dip)
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);
924 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
926 if (vp->dev_video) {
927 pvr2_v4l2_dev_destroy(vp->dev_video);
928 vp->dev_video = NULL;
930 if (vp->dev_radio) {
931 pvr2_v4l2_dev_destroy(vp->dev_radio);
932 vp->dev_radio = NULL;
935 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
936 pvr2_channel_done(&vp->channel);
937 kfree(vp);
941 static void pvr2_video_device_release(struct video_device *vdev)
943 struct pvr2_v4l2_dev *dev;
944 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
945 kfree(dev);
949 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
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);
961 static long pvr2_v4l2_ioctl(struct file *file,
962 unsigned int cmd, unsigned long arg)
965 return video_usercopy(file, cmd, arg, pvr2_v4l2_do_ioctl);
969 static int pvr2_v4l2_release(struct file *file)
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;
975 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
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;
986 v4l2_prio_close(&vp->prio, fhp->prio);
987 file->private_data = NULL;
989 if (fhp->vnext) {
990 fhp->vnext->vprev = fhp->vprev;
991 } else {
992 vp->vlast = fhp->vprev;
994 if (fhp->vprev) {
995 fhp->vprev->vnext = fhp->vnext;
996 } else {
997 vp->vfirst = fhp->vnext;
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;
1009 kfree(fhp);
1010 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
1011 pvr2_v4l2_destroy_no_lock(vp);
1013 return 0;
1017 static int pvr2_v4l2_open(struct file *file)
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;
1027 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1029 vp = dip->v4lp;
1030 hdw = vp->channel.hdw;
1032 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1034 if (!pvr2_hdw_dev_ok(hdw)) {
1035 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
1036 "pvr2_v4l2_open: hardware not ready");
1037 return -EIO;
1040 fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1041 if (!fhp) {
1042 return -ENOMEM;
1045 init_waitqueue_head(&fhp->wait_data);
1046 fhp->pdi = dip;
1048 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1049 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
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));
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);
1070 kfree(fhp);
1071 return ret;
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++;
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;
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;
1095 fhp->vnext = NULL;
1096 fhp->vprev = vp->vlast;
1097 if (vp->vlast) {
1098 vp->vlast->vnext = fhp;
1099 } else {
1100 vp->vfirst = fhp;
1102 vp->vlast = fhp;
1103 fhp->vhead = vp;
1105 fhp->file = file;
1106 file->private_data = fhp;
1107 v4l2_prio_open(&vp->prio, &fhp->prio);
1109 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
1111 return 0;
1115 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1117 wake_up(&fhp->wait_data);
1120 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1122 int ret;
1123 struct pvr2_stream *sp;
1124 struct pvr2_hdw *hdw;
1125 if (fh->rhp) return 0;
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;
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;
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;
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);
1156 static ssize_t pvr2_v4l2_read(struct file *file,
1157 char __user *buff, size_t count, loff_t *ppos)
1159 struct pvr2_v4l2_fh *fh = file->private_data;
1160 int ret;
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;
1169 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1170 if (!tbuf) return -ENOMEM;
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;
1180 if (!c2) break;
1181 if (copy_to_user(buff,tbuf,c2)) {
1182 tcnt = -EFAULT;
1183 break;
1185 offs += c2;
1186 tcnt += c2;
1187 buff += c2;
1188 count -= c2;
1189 *ppos += c2;
1191 kfree(tbuf);
1192 return tcnt;
1195 if (!fh->rhp) {
1196 ret = pvr2_v4l2_iosetup(fh);
1197 if (ret) {
1198 return ret;
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;
1214 return ret;
1218 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1220 unsigned int mask = 0;
1221 struct pvr2_v4l2_fh *fh = file->private_data;
1222 int ret;
1224 if (fh->fw_mode_flag) {
1225 mask |= POLLIN | POLLRDNORM;
1226 return mask;
1229 if (!fh->rhp) {
1230 ret = pvr2_v4l2_iosetup(fh);
1231 if (ret) return POLLERR;
1234 poll_wait(file,&fh->wait_data,wait);
1236 if (pvr2_ioread_avail(fh->rhp) >= 0) {
1237 mask |= POLLIN | POLLRDNORM;
1240 return mask;
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,
1254 static struct video_device vdev_template = {
1255 .fops = &vdev_fops,
1259 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1260 struct pvr2_v4l2 *vp,
1261 int v4l_type)
1263 struct usb_device *usbdev;
1264 int mindevnum;
1265 int unit_number;
1266 int *nr_ptr = NULL;
1267 dip->v4lp = vp;
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;
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;
1302 memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1303 dip->devbase.release = pvr2_video_device_release;
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];
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");
1319 printk(KERN_INFO "pvrusb2: registered device %s [%s]\n",
1320 video_device_node_name(&dip->devbase),
1321 pvr2_config_get_name(dip->config));
1323 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1324 dip->minor_type,dip->devbase.minor);
1328 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1330 struct pvr2_v4l2 *vp;
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);
1337 vp->channel.check_func = pvr2_v4l2_internal_check;
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);
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;
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: ***