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