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