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