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