projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (5078): Pvrusb2: It's safe to kfree() a null pointer
[linux-2.6-block.git] / drivers / media / video / pvrusb2 / pvrusb2-v4l2.c
CommitLineData
d855497e
MI		 1/*
2 *
3 * $Id$
4 *
5 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
6 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 */
22
23#include <linux/kernel.h>
ce4260c3 24#include <linux/version.h>
d855497e
MI		 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>
43e06022 32#include <media/v4l2-dev.h>
d855497e
MI		 33#include <media/v4l2-common.h>
34
35struct pvr2_v4l2_dev;
36struct pvr2_v4l2_fh;
37struct pvr2_v4l2;
38
d855497e 39struct pvr2_v4l2_dev {
75910053 40 struct video_device devbase; /* MUST be first! */
d855497e 41 struct pvr2_v4l2 *v4lp;
d855497e 42 struct pvr2_context_stream *stream;
16eb40d3
MI		 43 /* Information about this device: */
44 enum pvr2_config config; /* Expected stream format */
45 int v4l_type; /* V4L defined type for this device node */
46 enum pvr2_v4l_type minor_type; /* pvr2-understood minor device type */
d855497e
MI		 47};
48
49struct pvr2_v4l2_fh {
50 struct pvr2_channel channel;
51 struct pvr2_v4l2_dev *dev_info;
52 enum v4l2_priority prio;
53 struct pvr2_ioread *rhp;
54 struct file *file;
55 struct pvr2_v4l2 *vhead;
56 struct pvr2_v4l2_fh *vnext;
57 struct pvr2_v4l2_fh *vprev;
58 wait_queue_head_t wait_data;
59 int fw_mode_flag;
c74e0062 60 int prev_input_val;
d855497e
MI		 61};
62
63struct pvr2_v4l2 {
64 struct pvr2_channel channel;
65 struct pvr2_v4l2_fh *vfirst;
66 struct pvr2_v4l2_fh *vlast;
67
68 struct v4l2_prio_state prio;
69
0f0f257b
MI		 70 /* streams - Note that these must be separately, individually,
71 * allocated pointers. This is because the v4l core is going to
72 * manage their deletion - separately, individually... */
73 struct pvr2_v4l2_dev *dev_video;
74 struct pvr2_v4l2_dev *dev_radio;
d855497e
MI		 75};
76
77static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
78module_param_array(video_nr, int, NULL, 0444);
5e6862ce
MI		 79MODULE_PARM_DESC(video_nr, "Offset for device's video dev minor");
80static int radio_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
81module_param_array(radio_nr, int, NULL, 0444);
82MODULE_PARM_DESC(radio_nr, "Offset for device's radio dev minor");
83static int vbi_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
84module_param_array(vbi_nr, int, NULL, 0444);
85MODULE_PARM_DESC(vbi_nr, "Offset for device's vbi dev minor");
d855497e 86
07e337ee 87static struct v4l2_capability pvr_capability ={
d855497e
MI		 88 .driver = "pvrusb2",
89 .card = "Hauppauge WinTV pvr-usb2",
90 .bus_info = "usb",
91 .version = KERNEL_VERSION(0,8,0),
92 .capabilities = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE |
ae2b9e25 93 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_RADIO |
d855497e
MI		 94 V4L2_CAP_READWRITE),
95 .reserved = {0,0,0,0}
96};
97
98static struct v4l2_tuner pvr_v4l2_tuners[]= {
99 {
100 .index = 0,
101 .name = "TV Tuner",
102 .type = V4L2_TUNER_ANALOG_TV,
103 .capability = (V4L2_TUNER_CAP_NORM |
104 V4L2_TUNER_CAP_STEREO |
105 V4L2_TUNER_CAP_LANG1 |
106 V4L2_TUNER_CAP_LANG2),
107 .rangelow = 0,
108 .rangehigh = 0,
109 .rxsubchans = V4L2_TUNER_SUB_STEREO,
110 .audmode = V4L2_TUNER_MODE_STEREO,
111 .signal = 0,
112 .afc = 0,
113 .reserved = {0,0,0,0}
114 }
115};
116
07e337ee 117static struct v4l2_fmtdesc pvr_fmtdesc [] = {
d855497e
MI		 118 {
119 .index = 0,
120 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
121 .flags = V4L2_FMT_FLAG_COMPRESSED,
122 .description = "MPEG1/2",
123 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
124 // breaks when I do that.
125 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
126 .reserved = { 0, 0, 0, 0 }
127 }
128};
129
130#define PVR_FORMAT_PIX 0
131#define PVR_FORMAT_VBI 1
132
07e337ee 133static struct v4l2_format pvr_format [] = {
d855497e
MI		 134 [PVR_FORMAT_PIX] = {
135 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
136 .fmt = {
137 .pix = {
138 .width = 720,
139 .height = 576,
140 // This should really be V4L2_PIX_FMT_MPEG,
141 // but xawtv breaks when I do that.
142 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
143 .field = V4L2_FIELD_INTERLACED,
144 .bytesperline = 0, // doesn't make sense
145 // here
146 //FIXME : Don't know what to put here...
147 .sizeimage = (32*1024),
148 .colorspace = 0, // doesn't make sense here
149 .priv = 0
150 }
151 }
152 },
153 [PVR_FORMAT_VBI] = {
154 .type = V4L2_BUF_TYPE_VBI_CAPTURE,
155 .fmt = {
156 .vbi = {
157 .sampling_rate = 27000000,
158 .offset = 248,
159 .samples_per_line = 1443,
160 .sample_format = V4L2_PIX_FMT_GREY,
161 .start = { 0, 0 },
162 .count = { 0, 0 },
163 .flags = 0,
164 .reserved = { 0, 0 }
165 }
166 }
167 }
168};
169
16eb40d3
MI		 170
171static const char *get_v4l_name(int v4l_type)
172{
173 switch (v4l_type) {
174 case VFL_TYPE_GRABBER: return "video";
175 case VFL_TYPE_RADIO: return "radio";
176 case VFL_TYPE_VBI: return "vbi";
177 default: return "?";
178 }
179}
180
181
d855497e
MI		 182/*
183 * pvr_ioctl()
184 *
185 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
186 *
187 */
188static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
189 unsigned int cmd, void *arg)
190{
191 struct pvr2_v4l2_fh *fh = file->private_data;
192 struct pvr2_v4l2 *vp = fh->vhead;
193 struct pvr2_v4l2_dev *dev_info = fh->dev_info;
194 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
195 int ret = -EINVAL;
196
197 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
198 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
199 }
200
201 if (!pvr2_hdw_dev_ok(hdw)) {
202 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
203 "ioctl failed - bad or no context");
204 return -EFAULT;
205 }
206
207 /* check priority */
208 switch (cmd) {
209 case VIDIOC_S_CTRL:
210 case VIDIOC_S_STD:
211 case VIDIOC_S_INPUT:
212 case VIDIOC_S_TUNER:
213 case VIDIOC_S_FREQUENCY:
214 ret = v4l2_prio_check(&vp->prio, &fh->prio);
215 if (ret)
216 return ret;
217 }
218
219 switch (cmd) {
220 case VIDIOC_QUERYCAP:
221 {
222 struct v4l2_capability *cap = arg;
223
224 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
225
226 ret = 0;
227 break;
228 }
229
230 case VIDIOC_G_PRIORITY:
231 {
232 enum v4l2_priority *p = arg;
233
234 *p = v4l2_prio_max(&vp->prio);
235 ret = 0;
236 break;
237 }
238
239 case VIDIOC_S_PRIORITY:
240 {
241 enum v4l2_priority *prio = arg;
242
243 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
244 break;
245 }
246
247 case VIDIOC_ENUMSTD:
248 {
249 struct v4l2_standard *vs = (struct v4l2_standard *)arg;
250 int idx = vs->index;
251 ret = pvr2_hdw_get_stdenum_value(hdw,vs,idx+1);
252 break;
253 }
254
255 case VIDIOC_G_STD:
256 {
257 int val = 0;
258 ret = pvr2_ctrl_get_value(
259 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),&val);
260 *(v4l2_std_id *)arg = val;
261 break;
262 }
263
264 case VIDIOC_S_STD:
265 {
266 ret = pvr2_ctrl_set_value(
267 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
268 *(v4l2_std_id *)arg);
269 break;
270 }
271
272 case VIDIOC_ENUMINPUT:
273 {
274 struct pvr2_ctrl *cptr;
275 struct v4l2_input *vi = (struct v4l2_input *)arg;
276 struct v4l2_input tmp;
277 unsigned int cnt;
278
279 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
280
281 memset(&tmp,0,sizeof(tmp));
282 tmp.index = vi->index;
283 ret = 0;
284 switch (vi->index) {
285 case PVR2_CVAL_INPUT_TV:
286 case PVR2_CVAL_INPUT_RADIO:
287 tmp.type = V4L2_INPUT_TYPE_TUNER;
288 break;
289 case PVR2_CVAL_INPUT_SVIDEO:
290 case PVR2_CVAL_INPUT_COMPOSITE:
291 tmp.type = V4L2_INPUT_TYPE_CAMERA;
292 break;
293 default:
294 ret = -EINVAL;
295 break;
296 }
297 if (ret < 0) break;
298
299 cnt = 0;
300 pvr2_ctrl_get_valname(cptr,vi->index,
301 tmp.name,sizeof(tmp.name)-1,&cnt);
302 tmp.name[cnt] = 0;
303
304 /* Don't bother with audioset, since this driver currently
305 always switches the audio whenever the video is
306 switched. */
307
308 /* Handling std is a tougher problem. It doesn't make
309 sense in cases where a device might be multi-standard.
310 We could just copy out the current value for the
311 standard, but it can change over time. For now just
312 leave it zero. */
313
314 memcpy(vi, &tmp, sizeof(tmp));
315
316 ret = 0;
317 break;
318 }
319
320 case VIDIOC_G_INPUT:
321 {
322 struct pvr2_ctrl *cptr;
323 struct v4l2_input *vi = (struct v4l2_input *)arg;
324 int val;
325 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
326 val = 0;
327 ret = pvr2_ctrl_get_value(cptr,&val);
328 vi->index = val;
329 break;
330 }
331
332 case VIDIOC_S_INPUT:
333 {
334 struct v4l2_input *vi = (struct v4l2_input *)arg;
335 ret = pvr2_ctrl_set_value(
336 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
337 vi->index);
338 break;
339 }
340
341 case VIDIOC_ENUMAUDIO:
342 {
343 ret = -EINVAL;
344 break;
345 }
346
347 case VIDIOC_G_AUDIO:
348 {
349 ret = -EINVAL;
350 break;
351 }
352
353 case VIDIOC_S_AUDIO:
354 {
355 ret = -EINVAL;
356 break;
357 }
358 case VIDIOC_G_TUNER:
359 {
360 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
361 unsigned int status_mask;
362 int val;
363 if (vt->index !=0) break;
364
365 status_mask = pvr2_hdw_get_signal_status(hdw);
366
367 memcpy(vt, &pvr_v4l2_tuners[vt->index],
368 sizeof(struct v4l2_tuner));
369
370 vt->signal = 0;
371 if (status_mask & PVR2_SIGNAL_OK) {
372 if (status_mask & PVR2_SIGNAL_STEREO) {
373 vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
374 } else {
375 vt->rxsubchans = V4L2_TUNER_SUB_MONO;
376 }
377 if (status_mask & PVR2_SIGNAL_SAP) {
378 vt->rxsubchans |= (V4L2_TUNER_SUB_LANG1 |
379 V4L2_TUNER_SUB_LANG2);
380 }
381 vt->signal = 65535;
382 }
383
384 val = 0;
385 ret = pvr2_ctrl_get_value(
386 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
387 &val);
388 vt->audmode = val;
389 break;
390 }
391
392 case VIDIOC_S_TUNER:
393 {
394 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
395
396 if (vt->index != 0)
397 break;
398
399 ret = pvr2_ctrl_set_value(
400 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
401 vt->audmode);
402 }
403
404 case VIDIOC_S_FREQUENCY:
405 {
406 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
c0e69315
MI		 407 unsigned long fv;
408 fv = vf->frequency;
409 if (vf->type == V4L2_TUNER_RADIO) {
410 fv = (fv * 125) / 2;
411 } else {
412 fv = fv * 62500;
413 }
d855497e 414 ret = pvr2_ctrl_set_value(
c0e69315 415 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),fv);
d855497e
MI		 416 break;
417 }
418
419 case VIDIOC_G_FREQUENCY:
420 {
421 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
422 int val = 0;
c0e69315 423 int cur_input = PVR2_CVAL_INPUT_TV;
d855497e
MI		 424 ret = pvr2_ctrl_get_value(
425 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
426 &val);
c0e69315
MI		 427 if (ret != 0) break;
428 pvr2_ctrl_get_value(
429 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
430 &cur_input);
431 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
432 val = (val * 2) / 125;
433 vf->frequency = val;
434 vf->type = V4L2_TUNER_RADIO;
435 } else {
436 val /= 62500;
437 vf->frequency = val;
438 vf->type = V4L2_TUNER_ANALOG_TV;
439 }
d855497e
MI		 440 break;
441 }
442
443 case VIDIOC_ENUM_FMT:
444 {
445 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
446
447 /* Only one format is supported : mpeg.*/
448 if (fd->index != 0)
449 break;
450
451 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
452 ret = 0;
453 break;
454 }
455
456 case VIDIOC_G_FMT:
457 {
458 struct v4l2_format *vf = (struct v4l2_format *)arg;
459 int val;
460 switch(vf->type) {
461 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
462 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
463 sizeof(struct v4l2_format));
464 val = 0;
465 pvr2_ctrl_get_value(
466 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
467 &val);
468 vf->fmt.pix.width = val;
469 val = 0;
d855497e
MI		 470 pvr2_ctrl_get_value(
471 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
472 &val);
473 vf->fmt.pix.height = val;
474 ret = 0;
475 break;
476 case V4L2_BUF_TYPE_VBI_CAPTURE:
477 // ????? Still need to figure out to do VBI correctly
478 ret = -EINVAL;
479 break;
480 default:
481 ret = -EINVAL;
482 break;
483 }
484 break;
485 }
486
487 case VIDIOC_TRY_FMT:
488 case VIDIOC_S_FMT:
489 {
490 struct v4l2_format *vf = (struct v4l2_format *)arg;
491
492 ret = 0;
493 switch(vf->type) {
494 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
e95a1915
MI		 495 int lmin,lmax;
496 struct pvr2_ctrl *hcp,*vcp;
d855497e
MI		 497 int h = vf->fmt.pix.height;
498 int w = vf->fmt.pix.width;
e95a1915
MI		 499 hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
500 vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
501
502 lmin = pvr2_ctrl_get_min(hcp);
503 lmax = pvr2_ctrl_get_max(hcp);
e95a1915
MI		 504 if (w < lmin) {
505 w = lmin;
506 } else if (w > lmax) {
507 w = lmax;
d855497e 508 }
b31e341b
HV		 509 lmin = pvr2_ctrl_get_min(vcp);
510 lmax = pvr2_ctrl_get_max(vcp);
511 if (h < lmin) {
512 h = lmin;
513 } else if (h > lmax) {
514 h = lmax;
515 }
d855497e
MI		 516
517 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
518 sizeof(struct v4l2_format));
039c430f
MI		 519 vf->fmt.pix.width = w;
520 vf->fmt.pix.height = h;
d855497e
MI		 521
522 if (cmd == VIDIOC_S_FMT) {
e95a1915
MI		 523 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
524 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
d855497e
MI		 525 }
526 } break;
527 case V4L2_BUF_TYPE_VBI_CAPTURE:
528 // ????? Still need to figure out to do VBI correctly
529 ret = -EINVAL;
530 break;
531 default:
532 ret = -EINVAL;
533 break;
534 }
535 break;
536 }
537
538 case VIDIOC_STREAMON:
539 {
16eb40d3
MI		 540 if (!fh->dev_info->stream) {
541 /* No stream defined for this node. This means
542 that we're not currently allowed to stream from
543 this node. */
544 ret = -EPERM;
545 break;
546 }
d855497e
MI		 547 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
548 if (ret < 0) return ret;
549 ret = pvr2_hdw_set_streaming(hdw,!0);
550 break;
551 }
552
553 case VIDIOC_STREAMOFF:
554 {
16eb40d3
MI		 555 if (!fh->dev_info->stream) {
556 /* No stream defined for this node. This means
557 that we're not currently allowed to stream from
558 this node. */
559 ret = -EPERM;
560 break;
561 }
d855497e
MI		 562 ret = pvr2_hdw_set_streaming(hdw,0);
563 break;
564 }
565
566 case VIDIOC_QUERYCTRL:
567 {
568 struct pvr2_ctrl *cptr;
569 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
570 ret = 0;
1d9f8461
MI		 571 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
572 cptr = pvr2_hdw_get_ctrl_nextv4l(
573 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
574 if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
575 } else {
576 cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
577 }
d855497e 578 if (!cptr) {
0885ba1d 579 pvr2_trace(PVR2_TRACE_V4LIOCTL,
a761f431
MI		 580 "QUERYCTRL id=0x%x not implemented here",
581 vc->id);
d855497e
MI		 582 ret = -EINVAL;
583 break;
584 }
585
a761f431
MI		 586 pvr2_trace(PVR2_TRACE_V4LIOCTL,
587 "QUERYCTRL id=0x%x mapping name=%s (%s)",
588 vc->id,pvr2_ctrl_get_name(cptr),
589 pvr2_ctrl_get_desc(cptr));
590 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
591 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
d855497e
MI		 592 vc->default_value = pvr2_ctrl_get_def(cptr);
593 switch (pvr2_ctrl_get_type(cptr)) {
594 case pvr2_ctl_enum:
595 vc->type = V4L2_CTRL_TYPE_MENU;
596 vc->minimum = 0;
597 vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
598 vc->step = 1;
599 break;
33213963 600 case pvr2_ctl_bool:
1d9f8461 601 vc->type = V4L2_CTRL_TYPE_BOOLEAN;
33213963
MI		 602 vc->minimum = 0;
603 vc->maximum = 1;
604 vc->step = 1;
605 break;
d855497e
MI		 606 case pvr2_ctl_int:
607 vc->type = V4L2_CTRL_TYPE_INTEGER;
608 vc->minimum = pvr2_ctrl_get_min(cptr);
609 vc->maximum = pvr2_ctrl_get_max(cptr);
610 vc->step = 1;
611 break;
612 default:
0885ba1d 613 pvr2_trace(PVR2_TRACE_V4LIOCTL,
a761f431
MI		 614 "QUERYCTRL id=0x%x name=%s not mappable",
615 vc->id,pvr2_ctrl_get_name(cptr));
d855497e
MI		 616 ret = -EINVAL;
617 break;
618 }
619 break;
620 }
621
622 case VIDIOC_QUERYMENU:
623 {
624 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
625 unsigned int cnt = 0;
626 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
627 vm->index,
628 vm->name,sizeof(vm->name)-1,
629 &cnt);
630 vm->name[cnt] = 0;
631 break;
632 }
633
634 case VIDIOC_G_CTRL:
635 {
636 struct v4l2_control *vc = (struct v4l2_control *)arg;
637 int val = 0;
638 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
639 &val);
640 vc->value = val;
641 break;
642 }
643
644 case VIDIOC_S_CTRL:
645 {
646 struct v4l2_control *vc = (struct v4l2_control *)arg;
647 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
648 vc->value);
649 break;
650 }
651
1d9f8461
MI		 652 case VIDIOC_G_EXT_CTRLS:
653 {
654 struct v4l2_ext_controls *ctls =
655 (struct v4l2_ext_controls *)arg;
656 struct v4l2_ext_control *ctrl;
657 unsigned int idx;
658 int val;
659 for (idx = 0; idx < ctls->count; idx++) {
660 ctrl = ctls->controls + idx;
661 ret = pvr2_ctrl_get_value(
662 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
663 if (ret) {
664 ctls->error_idx = idx;
665 break;
666 }
667 /* Ensure that if read as a 64 bit value, the user
668 will still get a hopefully sane value */
669 ctrl->value64 = 0;
670 ctrl->value = val;
671 }
672 break;
673 }
674
675 case VIDIOC_S_EXT_CTRLS:
676 {
677 struct v4l2_ext_controls *ctls =
678 (struct v4l2_ext_controls *)arg;
679 struct v4l2_ext_control *ctrl;
680 unsigned int idx;
681 for (idx = 0; idx < ctls->count; idx++) {
682 ctrl = ctls->controls + idx;
683 ret = pvr2_ctrl_set_value(
684 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
685 ctrl->value);
686 if (ret) {
687 ctls->error_idx = idx;
688 break;
689 }
690 }
691 break;
692 }
693
694 case VIDIOC_TRY_EXT_CTRLS:
695 {
696 struct v4l2_ext_controls *ctls =
697 (struct v4l2_ext_controls *)arg;
698 struct v4l2_ext_control *ctrl;
699 struct pvr2_ctrl *pctl;
700 unsigned int idx;
701 /* For the moment just validate that the requested control
702 actually exists. */
703 for (idx = 0; idx < ctls->count; idx++) {
704 ctrl = ctls->controls + idx;
705 pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
706 if (!pctl) {
707 ret = -EINVAL;
708 ctls->error_idx = idx;
709 break;
710 }
711 }
712 break;
713 }
714
d855497e
MI		 715 case VIDIOC_LOG_STATUS:
716 {
d855497e 717 pvr2_hdw_trigger_module_log(hdw);
d855497e
MI		 718 ret = 0;
719 break;
720 }
32ffa9ae
MI		 721#ifdef CONFIG_VIDEO_ADV_DEBUG
722 case VIDIOC_INT_G_REGISTER:
723 case VIDIOC_INT_S_REGISTER:
724 {
725 u32 val;
726 struct v4l2_register *req = (struct v4l2_register *)arg;
727 if (cmd == VIDIOC_INT_S_REGISTER) val = req->val;
728 ret = pvr2_hdw_register_access(
729 hdw,req->i2c_id,req->reg,
730 cmd == VIDIOC_INT_S_REGISTER,&val);
6d98816f 731 if (cmd == VIDIOC_INT_G_REGISTER) req->val = val;
32ffa9ae
MI		 732 break;
733 }
734#endif
d855497e
MI		 735
736 default :
737 ret = v4l_compat_translate_ioctl(inode,file,cmd,
738 arg,pvr2_v4l2_do_ioctl);
739 }
740
741 pvr2_hdw_commit_ctl(hdw);
742
743 if (ret < 0) {
744 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
0885ba1d 745 pvr2_trace(PVR2_TRACE_V4LIOCTL,
d855497e
MI		 746 "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
747 } else {
0885ba1d
MI		 748 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
749 pvr2_trace(PVR2_TRACE_V4LIOCTL,
d855497e
MI		 750 "pvr2_v4l2_do_ioctl failure, ret=%d"
751 " command was:",ret);
752 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
753 cmd);
754 }
755 }
756 } else {
757 pvr2_trace(PVR2_TRACE_V4LIOCTL,
758 "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
759 ret,ret);
760 }
761 return ret;
762}
763
764
765static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
766{
0f0f257b 767 int minor_id = dip->devbase.minor;
0f0f257b 768 struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
16eb40d3
MI		 769 enum pvr2_config cfg = dip->config;
770 int v4l_type = dip->v4l_type;
0f0f257b 771
16eb40d3 772 pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
75910053
MI		 773
774 /* Paranoia */
c2625bff
RD		 775 dip->v4lp = NULL;
776 dip->stream = NULL;
75910053
MI		 777
778 /* Actual deallocation happens later when all internal references
779 are gone. */
780 video_unregister_device(&dip->devbase);
0f0f257b 781
16eb40d3
MI		 782 printk(KERN_INFO "pvrusb2: unregistered device %s%u [%s]\n",
783 get_v4l_name(v4l_type),minor_id & 0x1f,
784 pvr2_config_get_name(cfg));
0f0f257b 785
d855497e
MI		 786}
787
788
789static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
790{
0f0f257b
MI		 791 if (vp->dev_video) {
792 pvr2_v4l2_dev_destroy(vp->dev_video);
793 vp->dev_video = 0;
794 }
795 if (vp->dev_radio) {
796 pvr2_v4l2_dev_destroy(vp->dev_radio);
797 vp->dev_radio = 0;
798 }
d855497e
MI		 799
800 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
801 pvr2_channel_done(&vp->channel);
802 kfree(vp);
803}
804
805
75910053
MI		 806static void pvr2_video_device_release(struct video_device *vdev)
807{
808 struct pvr2_v4l2_dev *dev;
809 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
810 kfree(dev);
811}
812
813
07e337ee 814static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
d855497e
MI		 815{
816 struct pvr2_v4l2 *vp;
817 vp = container_of(chp,struct pvr2_v4l2,channel);
818 if (!vp->channel.mc_head->disconnect_flag) return;
819 if (vp->vfirst) return;
820 pvr2_v4l2_destroy_no_lock(vp);
821}
822
823
07e337ee
AB		 824static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
825 unsigned int cmd, unsigned long arg)
d855497e
MI		 826{
827
828/* Temporary hack : use ivtv api until a v4l2 one is available. */
829#define IVTV_IOC_G_CODEC 0xFFEE7703
830#define IVTV_IOC_S_CODEC 0xFFEE7704
831 if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
832 return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
833}
834
835
07e337ee 836static int pvr2_v4l2_release(struct inode *inode, struct file *file)
d855497e
MI		 837{
838 struct pvr2_v4l2_fh *fhp = file->private_data;
839 struct pvr2_v4l2 *vp = fhp->vhead;
840 struct pvr2_context *mp = fhp->vhead->channel.mc_head;
c74e0062 841 struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
d855497e
MI		 842
843 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
844
845 if (fhp->rhp) {
846 struct pvr2_stream *sp;
d855497e
MI		 847 pvr2_hdw_set_streaming(hdw,0);
848 sp = pvr2_ioread_get_stream(fhp->rhp);
a0fd1cb1 849 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
d855497e 850 pvr2_ioread_destroy(fhp->rhp);
a0fd1cb1 851 fhp->rhp = NULL;
d855497e 852 }
ae2b9e25 853
d855497e
MI		 854 v4l2_prio_close(&vp->prio, &fhp->prio);
855 file->private_data = NULL;
856
857 pvr2_context_enter(mp); do {
c74e0062
MI		 858 /* Restore the previous input selection, if it makes sense
859 to do so. */
860 if (fhp->dev_info->v4l_type == VFL_TYPE_RADIO) {
861 struct pvr2_ctrl *cp;
862 int pval;
863 cp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
864 pvr2_ctrl_get_value(cp,&pval);
865 /* Only restore if we're still selecting the radio */
866 if (pval == PVR2_CVAL_INPUT_RADIO) {
867 pvr2_ctrl_set_value(cp,fhp->prev_input_val);
868 pvr2_hdw_commit_ctl(hdw);
869 }
870 }
871
d855497e
MI		 872 if (fhp->vnext) {
873 fhp->vnext->vprev = fhp->vprev;
874 } else {
875 vp->vlast = fhp->vprev;
876 }
877 if (fhp->vprev) {
878 fhp->vprev->vnext = fhp->vnext;
879 } else {
880 vp->vfirst = fhp->vnext;
881 }
a0fd1cb1
MI		 882 fhp->vnext = NULL;
883 fhp->vprev = NULL;
884 fhp->vhead = NULL;
d855497e
MI		 885 pvr2_channel_done(&fhp->channel);
886 pvr2_trace(PVR2_TRACE_STRUCT,
887 "Destroying pvr_v4l2_fh id=%p",fhp);
888 kfree(fhp);
889 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
890 pvr2_v4l2_destroy_no_lock(vp);
891 }
892 } while (0); pvr2_context_exit(mp);
893 return 0;
894}
895
896
07e337ee 897static int pvr2_v4l2_open(struct inode *inode, struct file *file)
d855497e 898{
75910053 899 struct pvr2_v4l2_dev *dip; /* Our own context pointer */
d855497e
MI		 900 struct pvr2_v4l2_fh *fhp;
901 struct pvr2_v4l2 *vp;
902 struct pvr2_hdw *hdw;
903
75910053 904 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
d855497e
MI		 905
906 vp = dip->v4lp;
907 hdw = vp->channel.hdw;
908
909 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
910
911 if (!pvr2_hdw_dev_ok(hdw)) {
912 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
913 "pvr2_v4l2_open: hardware not ready");
914 return -EIO;
915 }
916
917 fhp = kmalloc(sizeof(*fhp),GFP_KERNEL);
918 if (!fhp) {
919 return -ENOMEM;
920 }
921 memset(fhp,0,sizeof(*fhp));
922
923 init_waitqueue_head(&fhp->wait_data);
924 fhp->dev_info = dip;
925
926 pvr2_context_enter(vp->channel.mc_head); do {
927 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
928 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
ae2b9e25 929
a0fd1cb1 930 fhp->vnext = NULL;
d855497e
MI		 931 fhp->vprev = vp->vlast;
932 if (vp->vlast) {
933 vp->vlast->vnext = fhp;
934 } else {
935 vp->vfirst = fhp;
936 }
937 vp->vlast = fhp;
938 fhp->vhead = vp;
c74e0062
MI		 939
940 /* Opening the /dev/radioX device implies a mode switch.
941 So execute that here. Note that you can get the
942 IDENTICAL effect merely by opening the normal video
943 device and setting the input appropriately. */
944 if (dip->v4l_type == VFL_TYPE_RADIO) {
945 struct pvr2_ctrl *cp;
946 cp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
947 pvr2_ctrl_get_value(cp,&fhp->prev_input_val);
948 pvr2_ctrl_set_value(cp,PVR2_CVAL_INPUT_RADIO);
949 pvr2_hdw_commit_ctl(hdw);
950 }
d855497e
MI		 951 } while (0); pvr2_context_exit(vp->channel.mc_head);
952
953 fhp->file = file;
954 file->private_data = fhp;
955 v4l2_prio_open(&vp->prio,&fhp->prio);
956
957 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
958
959 return 0;
960}
961
962
963static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
964{
965 wake_up(&fhp->wait_data);
966}
967
968static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
969{
970 int ret;
971 struct pvr2_stream *sp;
972 struct pvr2_hdw *hdw;
973 if (fh->rhp) return 0;
974
16eb40d3
MI		 975 if (!fh->dev_info->stream) {
976 /* No stream defined for this node. This means that we're
977 not currently allowed to stream from this node. */
978 return -EPERM;
979 }
980
d855497e
MI		 981 /* First read() attempt. Try to claim the stream and start
982 it... */
983 if ((ret = pvr2_channel_claim_stream(&fh->channel,
984 fh->dev_info->stream)) != 0) {
985 /* Someone else must already have it */
986 return ret;
987 }
988
989 fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
990 if (!fh->rhp) {
a0fd1cb1 991 pvr2_channel_claim_stream(&fh->channel,NULL);
d855497e
MI		 992 return -ENOMEM;
993 }
994
995 hdw = fh->channel.mc_head->hdw;
996 sp = fh->dev_info->stream->stream;
997 pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
998 pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
999 pvr2_hdw_set_streaming(hdw,!0);
1000 ret = pvr2_ioread_set_enabled(fh->rhp,!0);
1001
1002 return ret;
1003}
1004
1005
1006static ssize_t pvr2_v4l2_read(struct file *file,
1007 char __user *buff, size_t count, loff_t *ppos)
1008{
1009 struct pvr2_v4l2_fh *fh = file->private_data;
1010 int ret;
1011
1012 if (fh->fw_mode_flag) {
1013 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1014 char *tbuf;
1015 int c1,c2;
1016 int tcnt = 0;
1017 unsigned int offs = *ppos;
1018
1019 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1020 if (!tbuf) return -ENOMEM;
1021
1022 while (count) {
1023 c1 = count;
1024 if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1025 c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1026 if (c2 < 0) {
1027 tcnt = c2;
1028 break;
1029 }
1030 if (!c2) break;
1031 if (copy_to_user(buff,tbuf,c2)) {
1032 tcnt = -EFAULT;
1033 break;
1034 }
1035 offs += c2;
1036 tcnt += c2;
1037 buff += c2;
1038 count -= c2;
1039 *ppos += c2;
1040 }
1041 kfree(tbuf);
1042 return tcnt;
1043 }
1044
1045 if (!fh->rhp) {
1046 ret = pvr2_v4l2_iosetup(fh);
1047 if (ret) {
1048 return ret;
1049 }
1050 }
1051
1052 for (;;) {
1053 ret = pvr2_ioread_read(fh->rhp,buff,count);
1054 if (ret >= 0) break;
1055 if (ret != -EAGAIN) break;
1056 if (file->f_flags & O_NONBLOCK) break;
1057 /* Doing blocking I/O. Wait here. */
1058 ret = wait_event_interruptible(
1059 fh->wait_data,
1060 pvr2_ioread_avail(fh->rhp) >= 0);
1061 if (ret < 0) break;
1062 }
1063
1064 return ret;
1065}
1066
1067
1068static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1069{
1070 unsigned int mask = 0;
1071 struct pvr2_v4l2_fh *fh = file->private_data;
1072 int ret;
1073
1074 if (fh->fw_mode_flag) {
1075 mask |= POLLIN | POLLRDNORM;
1076 return mask;
1077 }
1078
1079 if (!fh->rhp) {
1080 ret = pvr2_v4l2_iosetup(fh);
1081 if (ret) return POLLERR;
1082 }
1083
1084 poll_wait(file,&fh->wait_data,wait);
1085
1086 if (pvr2_ioread_avail(fh->rhp) >= 0) {
1087 mask |= POLLIN | POLLRDNORM;
1088 }
1089
1090 return mask;
1091}
1092
1093
fa027c2a 1094static const struct file_operations vdev_fops = {
d855497e
MI		 1095 .owner = THIS_MODULE,
1096 .open = pvr2_v4l2_open,
1097 .release = pvr2_v4l2_release,
1098 .read = pvr2_v4l2_read,
1099 .ioctl = pvr2_v4l2_ioctl,
1100 .llseek = no_llseek,
1101 .poll = pvr2_v4l2_poll,
1102};
1103
1104
1105#define VID_HARDWARE_PVRUSB2 38 /* FIXME : need a good value */
1106
1107static struct video_device vdev_template = {
1108 .owner = THIS_MODULE,
1109 .type = VID_TYPE_CAPTURE | VID_TYPE_TUNER,
1110 .type2 = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE
1111 | V4L2_CAP_TUNER | V4L2_CAP_AUDIO
1112 | V4L2_CAP_READWRITE),
1113 .hardware = VID_HARDWARE_PVRUSB2,
1114 .fops = &vdev_fops,
1115};
1116
1117
1118static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1119 struct pvr2_v4l2 *vp,
16eb40d3 1120 int v4l_type)
d855497e
MI		 1121{
1122 int mindevnum;
1123 int unit_number;
16eb40d3 1124 int *nr_ptr = 0;
d855497e 1125 dip->v4lp = vp;
d855497e
MI		 1126
1127
16eb40d3
MI		 1128 dip->v4l_type = v4l_type;
1129 switch (v4l_type) {
1130 case VFL_TYPE_GRABBER:
d855497e 1131 dip->stream = &vp->channel.mc_head->video_stream;
16eb40d3
MI		 1132 dip->config = pvr2_config_mpeg;
1133 dip->minor_type = pvr2_v4l_type_video;
1134 nr_ptr = video_nr;
c74e0062
MI		 1135 if (!dip->stream) {
1136 err("Failed to set up pvrusb2 v4l video dev"
1137 " due to missing stream instance");
1138 return;
1139 }
d855497e 1140 break;
16eb40d3
MI		 1141 case VFL_TYPE_VBI:
1142 dip->config = pvr2_config_vbi;
1143 dip->minor_type = pvr2_v4l_type_vbi;
1144 nr_ptr = vbi_nr;
d855497e 1145 break;
16eb40d3
MI		 1146 case VFL_TYPE_RADIO:
1147 dip->config = pvr2_config_pcm;
1148 dip->minor_type = pvr2_v4l_type_radio;
1149 nr_ptr = radio_nr;
d855497e
MI		 1150 break;
1151 default:
1152 /* Bail out (this should be impossible) */
1153 err("Failed to set up pvrusb2 v4l dev"
1154 " due to unrecognized config");
1155 return;
1156 }
1157
75910053
MI		 1158 memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1159 dip->devbase.release = pvr2_video_device_release;
d855497e
MI		 1160
1161 mindevnum = -1;
1162 unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
16eb40d3
MI		 1163 if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1164 mindevnum = nr_ptr[unit_number];
d855497e 1165 }
16eb40d3
MI		 1166 if ((video_register_device(&dip->devbase,
1167 dip->v4l_type, mindevnum) < 0) &&
1168 (video_register_device(&dip->devbase,
1169 dip->v4l_type, -1) < 0)) {
ae2b9e25
PK		 1170 err("Failed to register pvrusb2 v4l device");
1171 }
16eb40d3
MI		 1172
1173 printk(KERN_INFO "pvrusb2: registered device %s%u [%s]\n",
1174 get_v4l_name(dip->v4l_type),dip->devbase.minor & 0x1f,
1175 pvr2_config_get_name(dip->config));
d855497e 1176
d855497e 1177 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
16eb40d3 1178 dip->minor_type,dip->devbase.minor);
d855497e
MI		 1179}
1180
1181
1182struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1183{
1184 struct pvr2_v4l2 *vp;
1185
1186 vp = kmalloc(sizeof(*vp),GFP_KERNEL);
1187 if (!vp) return vp;
1188 memset(vp,0,sizeof(*vp));
0f0f257b
MI		 1189 vp->dev_video = kmalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1190 vp->dev_radio = kmalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1191 if (!(vp->dev_video && vp->dev_radio)) {
6710fb86
MI		 1192 kfree(vp->dev_video);
1193 kfree(vp->dev_radio);
75910053 1194 kfree(vp);
c2625bff 1195 return NULL;
75910053 1196 }
0f0f257b
MI		 1197 memset(vp->dev_video,0,sizeof(*vp->dev_video));
1198 memset(vp->dev_radio,0,sizeof(*vp->dev_radio));
d855497e
MI		 1199 pvr2_channel_init(&vp->channel,mnp);
1200 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1201
1202 vp->channel.check_func = pvr2_v4l2_internal_check;
1203
1204 /* register streams */
16eb40d3
MI		 1205 pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1206 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
d855497e
MI		 1207
1208 return vp;
1209}
1210
1211/*
1212 Stuff for Emacs to see, in order to encourage consistent editing style:
1213 *** Local Variables: ***
1214 *** mode: c ***
1215 *** fill-column: 75 ***
1216 *** tab-width: 8 ***
1217 *** c-basic-offset: 8 ***
1218 *** End: ***
1219 */
Linux 6.x block layer and io_uring tree(s)