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