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