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