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