?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (4664): Pvrusb2: Don't use videodev.h; use v4l2-dev.h in its place
[linux-2.6/kvm.git] / drivers / media / video / pvrusb2 / pvrusb2-v4l2.c
blob49186984a0d783a2b754dd5131b7ed163f5e9bf2
1 /*
2 *
3 * $Id$
4 *
5 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
6 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 */
22
23 #include <linux/kernel.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
35 struct pvr2_v4l2_dev;
36 struct pvr2_v4l2_fh;
37 struct pvr2_v4l2;
38
39 struct pvr2_v4l2_dev {
40 struct video_device devbase; /* MUST be first! */
41 struct pvr2_v4l2 *v4lp;
42 struct pvr2_context_stream *stream;
43 enum pvr2_config config;
44 };
45
46 struct pvr2_v4l2_fh {
47 struct pvr2_channel channel;
48 struct pvr2_v4l2_dev *dev_info;
49 enum v4l2_priority prio;
50 struct pvr2_ioread *rhp;
51 struct file *file;
52 struct pvr2_v4l2 *vhead;
53 struct pvr2_v4l2_fh *vnext;
54 struct pvr2_v4l2_fh *vprev;
55 wait_queue_head_t wait_data;
56 int fw_mode_flag;
57 };
58
59 struct pvr2_v4l2 {
60 struct pvr2_channel channel;
61 struct pvr2_v4l2_fh *vfirst;
62 struct pvr2_v4l2_fh *vlast;
63
64 struct v4l2_prio_state prio;
65
66 /* streams */
67 struct pvr2_v4l2_dev *vdev;
68 };
69
70 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
71 module_param_array(video_nr, int, NULL, 0444);
72 MODULE_PARM_DESC(video_nr, "Offset for device's minor");
73
74 static struct v4l2_capability pvr_capability ={
75 .driver = "pvrusb2",
76 .card = "Hauppauge WinTV pvr-usb2",
77 .bus_info = "usb",
78 .version = KERNEL_VERSION(0,8,0),
79 .capabilities = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE |
80 V4L2_CAP_TUNER | V4L2_CAP_AUDIO |
81 V4L2_CAP_READWRITE),
82 .reserved = {0,0,0,0}
83 };
84
85 static struct v4l2_tuner pvr_v4l2_tuners[]= {
86 {
87 .index = 0,
88 .name = "TV Tuner",
89 .type = V4L2_TUNER_ANALOG_TV,
90 .capability = (V4L2_TUNER_CAP_NORM |
91 V4L2_TUNER_CAP_STEREO |
92 V4L2_TUNER_CAP_LANG1 |
93 V4L2_TUNER_CAP_LANG2),
94 .rangelow = 0,
95 .rangehigh = 0,
96 .rxsubchans = V4L2_TUNER_SUB_STEREO,
97 .audmode = V4L2_TUNER_MODE_STEREO,
98 .signal = 0,
99 .afc = 0,
100 .reserved = {0,0,0,0}
101 }
102 };
103
104 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
105 {
106 .index = 0,
107 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
108 .flags = V4L2_FMT_FLAG_COMPRESSED,
109 .description = "MPEG1/2",
110 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
111 // breaks when I do that.
112 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
113 .reserved = { 0, 0, 0, 0 }
114 }
115 };
116
117 #define PVR_FORMAT_PIX 0
118 #define PVR_FORMAT_VBI 1
119
120 static struct v4l2_format pvr_format [] = {
121 [PVR_FORMAT_PIX] = {
122 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
123 .fmt = {
124 .pix = {
125 .width = 720,
126 .height = 576,
127 // This should really be V4L2_PIX_FMT_MPEG,
128 // but xawtv breaks when I do that.
129 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
130 .field = V4L2_FIELD_INTERLACED,
131 .bytesperline = 0, // doesn't make sense
132 // here
133 //FIXME : Don't know what to put here...
134 .sizeimage = (32*1024),
135 .colorspace = 0, // doesn't make sense here
136 .priv = 0
137 }
138 }
139 },
140 [PVR_FORMAT_VBI] = {
141 .type = V4L2_BUF_TYPE_VBI_CAPTURE,
142 .fmt = {
143 .vbi = {
144 .sampling_rate = 27000000,
145 .offset = 248,
146 .samples_per_line = 1443,
147 .sample_format = V4L2_PIX_FMT_GREY,
148 .start = { 0, 0 },
149 .count = { 0, 0 },
150 .flags = 0,
151 .reserved = { 0, 0 }
152 }
153 }
154 }
155 };
156
157 /*
158 * pvr_ioctl()
159 *
160 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
161 *
162 */
163 static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
164 unsigned int cmd, void *arg)
165 {
166 struct pvr2_v4l2_fh *fh = file->private_data;
167 struct pvr2_v4l2 *vp = fh->vhead;
168 struct pvr2_v4l2_dev *dev_info = fh->dev_info;
169 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
170 int ret = -EINVAL;
171
172 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
173 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
174 }
175
176 if (!pvr2_hdw_dev_ok(hdw)) {
177 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
178 "ioctl failed - bad or no context");
179 return -EFAULT;
180 }
181
182 /* check priority */
183 switch (cmd) {
184 case VIDIOC_S_CTRL:
185 case VIDIOC_S_STD:
186 case VIDIOC_S_INPUT:
187 case VIDIOC_S_TUNER:
188 case VIDIOC_S_FREQUENCY:
189 ret = v4l2_prio_check(&vp->prio, &fh->prio);
190 if (ret)
191 return ret;
192 }
193
194 switch (cmd) {
195 case VIDIOC_QUERYCAP:
196 {
197 struct v4l2_capability *cap = arg;
198
199 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
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
254 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
255
256 memset(&tmp,0,sizeof(tmp));
257 tmp.index = vi->index;
258 ret = 0;
259 switch (vi->index) {
260 case PVR2_CVAL_INPUT_TV:
261 case PVR2_CVAL_INPUT_RADIO:
262 tmp.type = V4L2_INPUT_TYPE_TUNER;
263 break;
264 case PVR2_CVAL_INPUT_SVIDEO:
265 case PVR2_CVAL_INPUT_COMPOSITE:
266 tmp.type = V4L2_INPUT_TYPE_CAMERA;
267 break;
268 default:
269 ret = -EINVAL;
270 break;
271 }
272 if (ret < 0) break;
273
274 cnt = 0;
275 pvr2_ctrl_get_valname(cptr,vi->index,
276 tmp.name,sizeof(tmp.name)-1,&cnt);
277 tmp.name[cnt] = 0;
278
279 /* Don't bother with audioset, since this driver currently
280 always switches the audio whenever the video is
281 switched. */
282
283 /* Handling std is a tougher problem. It doesn't make
284 sense in cases where a device might be multi-standard.
285 We could just copy out the current value for the
286 standard, but it can change over time. For now just
287 leave it zero. */
288
289 memcpy(vi, &tmp, sizeof(tmp));
290
291 ret = 0;
292 break;
293 }
294
295 case VIDIOC_G_INPUT:
296 {
297 struct pvr2_ctrl *cptr;
298 struct v4l2_input *vi = (struct v4l2_input *)arg;
299 int val;
300 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
301 val = 0;
302 ret = pvr2_ctrl_get_value(cptr,&val);
303 vi->index = val;
304 break;
305 }
306
307 case VIDIOC_S_INPUT:
308 {
309 struct v4l2_input *vi = (struct v4l2_input *)arg;
310 ret = pvr2_ctrl_set_value(
311 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
312 vi->index);
313 break;
314 }
315
316 case VIDIOC_ENUMAUDIO:
317 {
318 ret = -EINVAL;
319 break;
320 }
321
322 case VIDIOC_G_AUDIO:
323 {
324 ret = -EINVAL;
325 break;
326 }
327
328 case VIDIOC_S_AUDIO:
329 {
330 ret = -EINVAL;
331 break;
332 }
333 case VIDIOC_G_TUNER:
334 {
335 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
336 unsigned int status_mask;
337 int val;
338 if (vt->index !=0) break;
339
340 status_mask = pvr2_hdw_get_signal_status(hdw);
341
342 memcpy(vt, &pvr_v4l2_tuners[vt->index],
343 sizeof(struct v4l2_tuner));
344
345 vt->signal = 0;
346 if (status_mask & PVR2_SIGNAL_OK) {
347 if (status_mask & PVR2_SIGNAL_STEREO) {
348 vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
349 } else {
350 vt->rxsubchans = V4L2_TUNER_SUB_MONO;
351 }
352 if (status_mask & PVR2_SIGNAL_SAP) {
353 vt->rxsubchans |= (V4L2_TUNER_SUB_LANG1 |
354 V4L2_TUNER_SUB_LANG2);
355 }
356 vt->signal = 65535;
357 }
358
359 val = 0;
360 ret = pvr2_ctrl_get_value(
361 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
362 &val);
363 vt->audmode = val;
364 break;
365 }
366
367 case VIDIOC_S_TUNER:
368 {
369 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
370
371 if (vt->index != 0)
372 break;
373
374 ret = pvr2_ctrl_set_value(
375 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
376 vt->audmode);
377 }
378
379 case VIDIOC_S_FREQUENCY:
380 {
381 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
382 ret = pvr2_ctrl_set_value(
383 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
384 vf->frequency * 62500);
385 break;
386 }
387
388 case VIDIOC_G_FREQUENCY:
389 {
390 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
391 int val = 0;
392 ret = pvr2_ctrl_get_value(
393 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
394 &val);
395 val /= 62500;
396 vf->frequency = val;
397 break;
398 }
399
400 case VIDIOC_ENUM_FMT:
401 {
402 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
403
404 /* Only one format is supported : mpeg.*/
405 if (fd->index != 0)
406 break;
407
408 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
409 ret = 0;
410 break;
411 }
412
413 case VIDIOC_G_FMT:
414 {
415 struct v4l2_format *vf = (struct v4l2_format *)arg;
416 int val;
417 switch(vf->type) {
418 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
419 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
420 sizeof(struct v4l2_format));
421 val = 0;
422 pvr2_ctrl_get_value(
423 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
424 &val);
425 vf->fmt.pix.width = val;
426 val = 0;
427 pvr2_ctrl_get_value(
428 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
429 &val);
430 vf->fmt.pix.height = val;
431 ret = 0;
432 break;
433 case V4L2_BUF_TYPE_VBI_CAPTURE:
434 // ????? Still need to figure out to do VBI correctly
435 ret = -EINVAL;
436 break;
437 default:
438 ret = -EINVAL;
439 break;
440 }
441 break;
442 }
443
444 case VIDIOC_TRY_FMT:
445 case VIDIOC_S_FMT:
446 {
447 struct v4l2_format *vf = (struct v4l2_format *)arg;
448
449 ret = 0;
450 switch(vf->type) {
451 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
452 int lmin,lmax;
453 struct pvr2_ctrl *hcp,*vcp;
454 int h = vf->fmt.pix.height;
455 int w = vf->fmt.pix.width;
456 hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
457 vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
458
459 lmin = pvr2_ctrl_get_min(hcp);
460 lmax = pvr2_ctrl_get_max(hcp);
461 if (w < lmin) {
462 w = lmin;
463 } else if (w > lmax) {
464 w = lmax;
465 }
466 lmin = pvr2_ctrl_get_min(vcp);
467 lmax = pvr2_ctrl_get_max(vcp);
468 if (h < lmin) {
469 h = lmin;
470 } else if (h > lmax) {
471 h = lmax;
472 }
473
474 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
475 sizeof(struct v4l2_format));
476 vf->fmt.pix.width = w;
477 vf->fmt.pix.height = h;
478
479 if (cmd == VIDIOC_S_FMT) {
480 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
481 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
482 }
483 } break;
484 case V4L2_BUF_TYPE_VBI_CAPTURE:
485 // ????? Still need to figure out to do VBI correctly
486 ret = -EINVAL;
487 break;
488 default:
489 ret = -EINVAL;
490 break;
491 }
492 break;
493 }
494
495 case VIDIOC_STREAMON:
496 {
497 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
498 if (ret < 0) return ret;
499 ret = pvr2_hdw_set_streaming(hdw,!0);
500 break;
501 }
502
503 case VIDIOC_STREAMOFF:
504 {
505 ret = pvr2_hdw_set_streaming(hdw,0);
506 break;
507 }
508
509 case VIDIOC_QUERYCTRL:
510 {
511 struct pvr2_ctrl *cptr;
512 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
513 ret = 0;
514 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
515 cptr = pvr2_hdw_get_ctrl_nextv4l(
516 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
517 if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
518 } else {
519 cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
520 }
521 if (!cptr) {
522 pvr2_trace(PVR2_TRACE_V4LIOCTL,
523 "QUERYCTRL id=0x%x not implemented here",
524 vc->id);
525 ret = -EINVAL;
526 break;
527 }
528
529 pvr2_trace(PVR2_TRACE_V4LIOCTL,
530 "QUERYCTRL id=0x%x mapping name=%s (%s)",
531 vc->id,pvr2_ctrl_get_name(cptr),
532 pvr2_ctrl_get_desc(cptr));
533 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
534 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
535 vc->default_value = pvr2_ctrl_get_def(cptr);
536 switch (pvr2_ctrl_get_type(cptr)) {
537 case pvr2_ctl_enum:
538 vc->type = V4L2_CTRL_TYPE_MENU;
539 vc->minimum = 0;
540 vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
541 vc->step = 1;
542 break;
543 case pvr2_ctl_bool:
544 vc->type = V4L2_CTRL_TYPE_BOOLEAN;
545 vc->minimum = 0;
546 vc->maximum = 1;
547 vc->step = 1;
548 break;
549 case pvr2_ctl_int:
550 vc->type = V4L2_CTRL_TYPE_INTEGER;
551 vc->minimum = pvr2_ctrl_get_min(cptr);
552 vc->maximum = pvr2_ctrl_get_max(cptr);
553 vc->step = 1;
554 break;
555 default:
556 pvr2_trace(PVR2_TRACE_V4LIOCTL,
557 "QUERYCTRL id=0x%x name=%s not mappable",
558 vc->id,pvr2_ctrl_get_name(cptr));
559 ret = -EINVAL;
560 break;
561 }
562 break;
563 }
564
565 case VIDIOC_QUERYMENU:
566 {
567 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
568 unsigned int cnt = 0;
569 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
570 vm->index,
571 vm->name,sizeof(vm->name)-1,
572 &cnt);
573 vm->name[cnt] = 0;
574 break;
575 }
576
577 case VIDIOC_G_CTRL:
578 {
579 struct v4l2_control *vc = (struct v4l2_control *)arg;
580 int val = 0;
581 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
582 &val);
583 vc->value = val;
584 break;
585 }
586
587 case VIDIOC_S_CTRL:
588 {
589 struct v4l2_control *vc = (struct v4l2_control *)arg;
590 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
591 vc->value);
592 break;
593 }
594
595 case VIDIOC_G_EXT_CTRLS:
596 {
597 struct v4l2_ext_controls *ctls =
598 (struct v4l2_ext_controls *)arg;
599 struct v4l2_ext_control *ctrl;
600 unsigned int idx;
601 int val;
602 for (idx = 0; idx < ctls->count; idx++) {
603 ctrl = ctls->controls + idx;
604 ret = pvr2_ctrl_get_value(
605 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
606 if (ret) {
607 ctls->error_idx = idx;
608 break;
609 }
610 /* Ensure that if read as a 64 bit value, the user
611 will still get a hopefully sane value */
612 ctrl->value64 = 0;
613 ctrl->value = val;
614 }
615 break;
616 }
617
618 case VIDIOC_S_EXT_CTRLS:
619 {
620 struct v4l2_ext_controls *ctls =
621 (struct v4l2_ext_controls *)arg;
622 struct v4l2_ext_control *ctrl;
623 unsigned int idx;
624 for (idx = 0; idx < ctls->count; idx++) {
625 ctrl = ctls->controls + idx;
626 ret = pvr2_ctrl_set_value(
627 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
628 ctrl->value);
629 if (ret) {
630 ctls->error_idx = idx;
631 break;
632 }
633 }
634 break;
635 }
636
637 case VIDIOC_TRY_EXT_CTRLS:
638 {
639 struct v4l2_ext_controls *ctls =
640 (struct v4l2_ext_controls *)arg;
641 struct v4l2_ext_control *ctrl;
642 struct pvr2_ctrl *pctl;
643 unsigned int idx;
644 /* For the moment just validate that the requested control
645 actually exists. */
646 for (idx = 0; idx < ctls->count; idx++) {
647 ctrl = ctls->controls + idx;
648 pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
649 if (!pctl) {
650 ret = -EINVAL;
651 ctls->error_idx = idx;
652 break;
653 }
654 }
655 break;
656 }
657
658 case VIDIOC_LOG_STATUS:
659 {
660 pvr2_hdw_trigger_module_log(hdw);
661 ret = 0;
662 break;
663 }
664 #ifdef CONFIG_VIDEO_ADV_DEBUG
665 case VIDIOC_INT_G_REGISTER:
666 case VIDIOC_INT_S_REGISTER:
667 {
668 u32 val;
669 struct v4l2_register *req = (struct v4l2_register *)arg;
670 if (cmd == VIDIOC_INT_S_REGISTER) val = req->val;
671 ret = pvr2_hdw_register_access(
672 hdw,req->i2c_id,req->reg,
673 cmd == VIDIOC_INT_S_REGISTER,&val);
674 if (cmd == 0) req->val = val;
675 break;
676 }
677 #endif
678
679 default :
680 ret = v4l_compat_translate_ioctl(inode,file,cmd,
681 arg,pvr2_v4l2_do_ioctl);
682 }
683
684 pvr2_hdw_commit_ctl(hdw);
685
686 if (ret < 0) {
687 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
688 pvr2_trace(PVR2_TRACE_V4LIOCTL,
689 "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
690 } else {
691 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
692 pvr2_trace(PVR2_TRACE_V4LIOCTL,
693 "pvr2_v4l2_do_ioctl failure, ret=%d"
694 " command was:",ret);
695 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
696 cmd);
697 }
698 }
699 } else {
700 pvr2_trace(PVR2_TRACE_V4LIOCTL,
701 "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
702 ret,ret);
703 }
704 return ret;
705 }
706
707
708 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
709 {
710 printk(KERN_INFO "pvrusb2: unregistering device video%d [%s]\n",
711 dip->devbase.minor,pvr2_config_get_name(dip->config));
712
713 /* Paranoia */
714 dip->v4lp = 0;
715 dip->stream = 0;
716
717 /* Actual deallocation happens later when all internal references
718 are gone. */
719 video_unregister_device(&dip->devbase);
720 }
721
722
723 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
724 {
725 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,-1);
726 pvr2_v4l2_dev_destroy(vp->vdev);
727
728 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
729 pvr2_channel_done(&vp->channel);
730 kfree(vp);
731 }
732
733
734 static void pvr2_video_device_release(struct video_device *vdev)
735 {
736 struct pvr2_v4l2_dev *dev;
737 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
738 kfree(dev);
739 }
740
741
742 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
743 {
744 struct pvr2_v4l2 *vp;
745 vp = container_of(chp,struct pvr2_v4l2,channel);
746 if (!vp->channel.mc_head->disconnect_flag) return;
747 if (vp->vfirst) return;
748 pvr2_v4l2_destroy_no_lock(vp);
749 }
750
751
752 static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
753 unsigned int cmd, unsigned long arg)
754 {
755
756 /* Temporary hack : use ivtv api until a v4l2 one is available. */
757 #define IVTV_IOC_G_CODEC 0xFFEE7703
758 #define IVTV_IOC_S_CODEC 0xFFEE7704
759 if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
760 return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
761 }
762
763
764 static int pvr2_v4l2_release(struct inode *inode, struct file *file)
765 {
766 struct pvr2_v4l2_fh *fhp = file->private_data;
767 struct pvr2_v4l2 *vp = fhp->vhead;
768 struct pvr2_context *mp = fhp->vhead->channel.mc_head;
769
770 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
771
772 if (fhp->rhp) {
773 struct pvr2_stream *sp;
774 struct pvr2_hdw *hdw;
775 hdw = fhp->channel.mc_head->hdw;
776 pvr2_hdw_set_streaming(hdw,0);
777 sp = pvr2_ioread_get_stream(fhp->rhp);
778 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
779 pvr2_ioread_destroy(fhp->rhp);
780 fhp->rhp = NULL;
781 }
782 v4l2_prio_close(&vp->prio, &fhp->prio);
783 file->private_data = NULL;
784
785 pvr2_context_enter(mp); do {
786 if (fhp->vnext) {
787 fhp->vnext->vprev = fhp->vprev;
788 } else {
789 vp->vlast = fhp->vprev;
790 }
791 if (fhp->vprev) {
792 fhp->vprev->vnext = fhp->vnext;
793 } else {
794 vp->vfirst = fhp->vnext;
795 }
796 fhp->vnext = NULL;
797 fhp->vprev = NULL;
798 fhp->vhead = NULL;
799 pvr2_channel_done(&fhp->channel);
800 pvr2_trace(PVR2_TRACE_STRUCT,
801 "Destroying pvr_v4l2_fh id=%p",fhp);
802 kfree(fhp);
803 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
804 pvr2_v4l2_destroy_no_lock(vp);
805 }
806 } while (0); pvr2_context_exit(mp);
807 return 0;
808 }
809
810
811 static int pvr2_v4l2_open(struct inode *inode, struct file *file)
812 {
813 struct pvr2_v4l2_dev *dip; /* Our own context pointer */
814 struct pvr2_v4l2_fh *fhp;
815 struct pvr2_v4l2 *vp;
816 struct pvr2_hdw *hdw;
817
818 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
819
820 vp = dip->v4lp;
821 hdw = vp->channel.hdw;
822
823 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
824
825 if (!pvr2_hdw_dev_ok(hdw)) {
826 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
827 "pvr2_v4l2_open: hardware not ready");
828 return -EIO;
829 }
830
831 fhp = kmalloc(sizeof(*fhp),GFP_KERNEL);
832 if (!fhp) {
833 return -ENOMEM;
834 }
835 memset(fhp,0,sizeof(*fhp));
836
837 init_waitqueue_head(&fhp->wait_data);
838 fhp->dev_info = dip;
839
840 pvr2_context_enter(vp->channel.mc_head); do {
841 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
842 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
843 fhp->vnext = NULL;
844 fhp->vprev = vp->vlast;
845 if (vp->vlast) {
846 vp->vlast->vnext = fhp;
847 } else {
848 vp->vfirst = fhp;
849 }
850 vp->vlast = fhp;
851 fhp->vhead = vp;
852 } while (0); pvr2_context_exit(vp->channel.mc_head);
853
854 fhp->file = file;
855 file->private_data = fhp;
856 v4l2_prio_open(&vp->prio,&fhp->prio);
857
858 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
859
860 return 0;
861 }
862
863
864 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
865 {
866 wake_up(&fhp->wait_data);
867 }
868
869 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
870 {
871 int ret;
872 struct pvr2_stream *sp;
873 struct pvr2_hdw *hdw;
874 if (fh->rhp) return 0;
875
876 /* First read() attempt. Try to claim the stream and start
877 it... */
878 if ((ret = pvr2_channel_claim_stream(&fh->channel,
879 fh->dev_info->stream)) != 0) {
880 /* Someone else must already have it */
881 return ret;
882 }
883
884 fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
885 if (!fh->rhp) {
886 pvr2_channel_claim_stream(&fh->channel,NULL);
887 return -ENOMEM;
888 }
889
890 hdw = fh->channel.mc_head->hdw;
891 sp = fh->dev_info->stream->stream;
892 pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
893 pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
894 pvr2_hdw_set_streaming(hdw,!0);
895 ret = pvr2_ioread_set_enabled(fh->rhp,!0);
896
897 return ret;
898 }
899
900
901 static ssize_t pvr2_v4l2_read(struct file *file,
902 char __user *buff, size_t count, loff_t *ppos)
903 {
904 struct pvr2_v4l2_fh *fh = file->private_data;
905 int ret;
906
907 if (fh->fw_mode_flag) {
908 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
909 char *tbuf;
910 int c1,c2;
911 int tcnt = 0;
912 unsigned int offs = *ppos;
913
914 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
915 if (!tbuf) return -ENOMEM;
916
917 while (count) {
918 c1 = count;
919 if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
920 c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
921 if (c2 < 0) {
922 tcnt = c2;
923 break;
924 }
925 if (!c2) break;
926 if (copy_to_user(buff,tbuf,c2)) {
927 tcnt = -EFAULT;
928 break;
929 }
930 offs += c2;
931 tcnt += c2;
932 buff += c2;
933 count -= c2;
934 *ppos += c2;
935 }
936 kfree(tbuf);
937 return tcnt;
938 }
939
940 if (!fh->rhp) {
941 ret = pvr2_v4l2_iosetup(fh);
942 if (ret) {
943 return ret;
944 }
945 }
946
947 for (;;) {
948 ret = pvr2_ioread_read(fh->rhp,buff,count);
949 if (ret >= 0) break;
950 if (ret != -EAGAIN) break;
951 if (file->f_flags & O_NONBLOCK) break;
952 /* Doing blocking I/O. Wait here. */
953 ret = wait_event_interruptible(
954 fh->wait_data,
955 pvr2_ioread_avail(fh->rhp) >= 0);
956 if (ret < 0) break;
957 }
958
959 return ret;
960 }
961
962
963 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
964 {
965 unsigned int mask = 0;
966 struct pvr2_v4l2_fh *fh = file->private_data;
967 int ret;
968
969 if (fh->fw_mode_flag) {
970 mask |= POLLIN | POLLRDNORM;
971 return mask;
972 }
973
974 if (!fh->rhp) {
975 ret = pvr2_v4l2_iosetup(fh);
976 if (ret) return POLLERR;
977 }
978
979 poll_wait(file,&fh->wait_data,wait);
980
981 if (pvr2_ioread_avail(fh->rhp) >= 0) {
982 mask |= POLLIN | POLLRDNORM;
983 }
984
985 return mask;
986 }
987
988
989 static struct file_operations vdev_fops = {
990 .owner = THIS_MODULE,
991 .open = pvr2_v4l2_open,
992 .release = pvr2_v4l2_release,
993 .read = pvr2_v4l2_read,
994 .ioctl = pvr2_v4l2_ioctl,
995 .llseek = no_llseek,
996 .poll = pvr2_v4l2_poll,
997 };
998
999
1000 #define VID_HARDWARE_PVRUSB2 38 /* FIXME : need a good value */
1001
1002 static struct video_device vdev_template = {
1003 .owner = THIS_MODULE,
1004 .type = VID_TYPE_CAPTURE | VID_TYPE_TUNER,
1005 .type2 = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE
1006 | V4L2_CAP_TUNER | V4L2_CAP_AUDIO
1007 | V4L2_CAP_READWRITE),
1008 .hardware = VID_HARDWARE_PVRUSB2,
1009 .fops = &vdev_fops,
1010 };
1011
1012
1013 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1014 struct pvr2_v4l2 *vp,
1015 enum pvr2_config cfg)
1016 {
1017 int mindevnum;
1018 int unit_number;
1019 int v4l_type;
1020 dip->v4lp = vp;
1021 dip->config = cfg;
1022
1023
1024 switch (cfg) {
1025 case pvr2_config_mpeg:
1026 v4l_type = VFL_TYPE_GRABBER;
1027 dip->stream = &vp->channel.mc_head->video_stream;
1028 break;
1029 case pvr2_config_vbi:
1030 v4l_type = VFL_TYPE_VBI;
1031 break;
1032 case pvr2_config_radio:
1033 v4l_type = VFL_TYPE_RADIO;
1034 break;
1035 default:
1036 /* Bail out (this should be impossible) */
1037 err("Failed to set up pvrusb2 v4l dev"
1038 " due to unrecognized config");
1039 return;
1040 }
1041
1042 if (!dip->stream) {
1043 err("Failed to set up pvrusb2 v4l dev"
1044 " due to missing stream instance");
1045 return;
1046 }
1047
1048 memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1049 dip->devbase.release = pvr2_video_device_release;
1050
1051 mindevnum = -1;
1052 unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1053 if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1054 mindevnum = video_nr[unit_number];
1055 }
1056 if ((video_register_device(&dip->devbase, v4l_type, mindevnum) < 0) &&
1057 (video_register_device(&dip->devbase, v4l_type, -1) < 0)) {
1058 err("Failed to register pvrusb2 v4l video device");
1059 } else {
1060 printk(KERN_INFO "pvrusb2: registered device video%d [%s]\n",
1061 dip->devbase.minor,pvr2_config_get_name(dip->config));
1062 }
1063
1064 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1065 dip->devbase.minor);
1066 }
1067
1068
1069 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1070 {
1071 struct pvr2_v4l2 *vp;
1072
1073 vp = kmalloc(sizeof(*vp),GFP_KERNEL);
1074 if (!vp) return vp;
1075 memset(vp,0,sizeof(*vp));
1076 vp->vdev = kmalloc(sizeof(*vp->vdev),GFP_KERNEL);
1077 if (!vp->vdev) {
1078 kfree(vp);
1079 return 0;
1080 }
1081 memset(vp->vdev,0,sizeof(*vp->vdev));
1082 pvr2_channel_init(&vp->channel,mnp);
1083 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1084
1085 vp->channel.check_func = pvr2_v4l2_internal_check;
1086
1087 /* register streams */
1088 pvr2_v4l2_dev_init(vp->vdev,vp,pvr2_config_mpeg);
1089
1090 return vp;
1091 }
1092
1093 /*
1094 Stuff for Emacs to see, in order to encourage consistent editing style:
1095 *** Local Variables: ***
1096 *** mode: c ***
1097 *** fill-column: 75 ***
1098 *** tab-width: 8 ***
1099 *** c-basic-offset: 8 ***
1100 *** End: ***
1101 */
kernel-based virtual machine