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