drivers/media/usb/dvb-usb/cxusb-analog.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 //
   3 // DVB USB compliant linux driver for Conexant USB reference design -
   4 // (analog part).
   5 //
   6 // Copyright (C) 2011, 2017, 2018
   7 //      Maciej S. Szmigiero (mail@maciej.szmigiero.name)
   8 //
   9 // In case there are new analog / DVB-T hybrid devices released in the market
  10 // using the same general design as Medion MD95700: a CX25840 video decoder
  11 // outputting a BT.656 stream to a USB bridge chip which then forwards it to
  12 // the host in isochronous USB packets this code should be made generic, with
  13 // board specific bits implemented via separate card structures.
  14 //
  15 // This is, however, unlikely as the Medion model was released
  16 // years ago (in 2005).
  17 //
  18 // TODO:
  19 //  * audio support,
  20 //  * finish radio support (requires audio of course),
  21 //  * VBI support,
  22 //  * controls support
  23
  24 #include <linux/bitops.h>
  25 #include <linux/device.h>
  26 #include <linux/slab.h>
  27 #include <linux/string.h>
  28 #include <linux/ktime.h>
  29 #include <linux/vmalloc.h>
  30 #include <media/drv-intf/cx25840.h>
  31 #include <media/tuner.h>
  32 #include <media/v4l2-fh.h>
  33 #include <media/v4l2-ioctl.h>
  34 #include <media/v4l2-subdev.h>
  35 #include <media/videobuf2-vmalloc.h>
  36
  37 #include "cxusb.h"
  38
  39 static int cxusb_medion_v_queue_setup(struct vb2_queue *q,
  40                                       unsigned int *num_buffers,
  41                                       unsigned int *num_planes,
  42                                       unsigned int sizes[],
  43                                       struct device *alloc_devs[])
  44 {
  45         struct dvb_usb_device *dvbdev = vb2_get_drv_priv(q);
  46         struct cxusb_medion_dev *cxdev = dvbdev->priv;
  47         unsigned int size = cxdev->width * cxdev->height * 2;
  48
  49         if (*num_planes > 0) {
  50                 if (*num_planes != 1)
  51                         return -EINVAL;
  52
  53                 if (sizes[0] < size)
  54                         return -EINVAL;
  55         } else {
  56                 *num_planes = 1;
  57                 sizes[0] = size;
  58         }
  59
  60         return 0;
  61 }
  62
  63 static int cxusb_medion_v_buf_init(struct vb2_buffer *vb)
  64 {
  65         struct dvb_usb_device *dvbdev = vb2_get_drv_priv(vb->vb2_queue);
  66         struct cxusb_medion_dev *cxdev = dvbdev->priv;
  67
  68         cxusb_vprintk(dvbdev, OPS, "buffer init\n");
  69
  70         if (vb2_plane_size(vb, 0) < cxdev->width * cxdev->height * 2)
  71                 return -ENOMEM;
  72
  73         cxusb_vprintk(dvbdev, OPS, "buffer OK\n");
  74
  75         return 0;
  76 }
  77
  78 static void cxusb_auxbuf_init(struct dvb_usb_device *dvbdev,
  79                               struct cxusb_medion_auxbuf *auxbuf,
  80                               u8 *buf, unsigned int len)
  81 {
  82         cxusb_vprintk(dvbdev, AUXB, "initializing auxbuf of len %u\n", len);
  83
  84         auxbuf->buf = buf;
  85         auxbuf->len = len;
  86         auxbuf->paylen = 0;
  87 }
  88
  89 static void cxusb_auxbuf_head_trim(struct dvb_usb_device *dvbdev,
  90                                    struct cxusb_medion_auxbuf *auxbuf,
  91                                    unsigned int pos)
  92 {
  93         if (pos == 0)
  94                 return;
  95
  96         if (WARN_ON(pos > auxbuf->paylen))
  97                 return;
  98
  99         cxusb_vprintk(dvbdev, AUXB,
 100                       "trimming auxbuf len by %u to %u\n",
 101                       pos, auxbuf->paylen - pos);
 102
 103         memmove(auxbuf->buf, auxbuf->buf + pos, auxbuf->paylen - pos);
 104         auxbuf->paylen -= pos;
 105 }
 106
 107 static unsigned int cxusb_auxbuf_paylen(struct cxusb_medion_auxbuf *auxbuf)
 108 {
 109         return auxbuf->paylen;
 110 }
 111
 112 static bool cxusb_auxbuf_make_space(struct dvb_usb_device *dvbdev,
 113                                     struct cxusb_medion_auxbuf *auxbuf,
 114                                     unsigned int howmuch)
 115 {
 116         unsigned int freespace;
 117
 118         if (WARN_ON(howmuch >= auxbuf->len))
 119                 howmuch = auxbuf->len - 1;
 120
 121         freespace = auxbuf->len - cxusb_auxbuf_paylen(auxbuf);
 122
 123         cxusb_vprintk(dvbdev, AUXB, "freespace is %u\n", freespace);
 124
 125         if (freespace >= howmuch)
 126                 return true;
 127
 128         howmuch -= freespace;
 129
 130         cxusb_vprintk(dvbdev, AUXB, "will overwrite %u bytes of buffer\n",
 131                       howmuch);
 132
 133         cxusb_auxbuf_head_trim(dvbdev, auxbuf, howmuch);
 134
 135         return false;
 136 }
 137
 138 /* returns false if some data was overwritten */
 139 static bool cxusb_auxbuf_append_urb(struct dvb_usb_device *dvbdev,
 140                                     struct cxusb_medion_auxbuf *auxbuf,
 141                                     struct urb *urb)
 142 {
 143         unsigned long len;
 144         int i;
 145         bool ret;
 146
 147         for (i = 0, len = 0; i < urb->number_of_packets; i++)
 148                 len += urb->iso_frame_desc[i].actual_length;
 149
 150         ret = cxusb_auxbuf_make_space(dvbdev, auxbuf, len);
 151
 152         for (i = 0; i < urb->number_of_packets; i++) {
 153                 unsigned int to_copy;
 154
 155                 to_copy = urb->iso_frame_desc[i].actual_length;
 156
 157                 memcpy(auxbuf->buf + auxbuf->paylen, urb->transfer_buffer +
 158                        urb->iso_frame_desc[i].offset, to_copy);
 159
 160                 auxbuf->paylen += to_copy;
 161         }
 162
 163         return ret;
 164 }
 165
 166 static bool cxusb_auxbuf_copy(struct cxusb_medion_auxbuf *auxbuf,
 167                               unsigned int pos, unsigned char *dest,
 168                               unsigned int len)
 169 {
 170         if (pos + len > auxbuf->paylen)
 171                 return false;
 172
 173         memcpy(dest, auxbuf->buf + pos, len);
 174
 175         return true;
 176 }
 177
 178 static bool cxusb_medion_cf_refc_fld_chg(struct dvb_usb_device *dvbdev,
 179                                          struct cxusb_bt656_params *bt656,
 180                                          bool firstfield,
 181                                          unsigned int maxlines,
 182                                          unsigned int maxlinesamples,
 183                                          unsigned char buf[4])
 184 {
 185         bool firstfield_code = (buf[3] & CXUSB_BT656_FIELD_MASK) ==
 186                 CXUSB_BT656_FIELD_1;
 187         unsigned int remlines;
 188
 189         if (bt656->line == 0 || firstfield == firstfield_code)
 190                 return false;
 191
 192         if (bt656->fmode == LINE_SAMPLES) {
 193                 unsigned int remsamples = maxlinesamples -
 194                         bt656->linesamples;
 195
 196                 cxusb_vprintk(dvbdev, BT656,
 197                               "field %c after line %u field change\n",
 198                               firstfield ? '1' : '2', bt656->line);
 199
 200                 if (bt656->buf && remsamples > 0) {
 201                         memset(bt656->buf, 0, remsamples);
 202                         bt656->buf += remsamples;
 203
 204                         cxusb_vprintk(dvbdev, BT656,
 205                                       "field %c line %u %u samples still remaining (of %u)\n",
 206                                       firstfield ? '1' : '2',
 207                                       bt656->line, remsamples,
 208                                       maxlinesamples);
 209                 }
 210
 211                 bt656->line++;
 212         }
 213
 214         remlines = maxlines - bt656->line;
 215         if (bt656->buf && remlines > 0) {
 216                 memset(bt656->buf, 0, remlines * maxlinesamples);
 217                 bt656->buf += remlines * maxlinesamples;
 218
 219                 cxusb_vprintk(dvbdev, BT656,
 220                               "field %c %u lines still remaining (of %u)\n",
 221                               firstfield ? '1' : '2', remlines,
 222                               maxlines);
 223         }
 224
 225         return true;
 226 }
 227
 228 static void cxusb_medion_cf_refc_start_sch(struct dvb_usb_device *dvbdev,
 229                                            struct cxusb_bt656_params *bt656,
 230                                            bool firstfield,
 231                                            unsigned char buf[4])
 232 {
 233         bool firstfield_code = (buf[3] & CXUSB_BT656_FIELD_MASK) ==
 234                 CXUSB_BT656_FIELD_1;
 235         bool sav_code = (buf[3] & CXUSB_BT656_SEAV_MASK) ==
 236                 CXUSB_BT656_SEAV_SAV;
 237         bool vbi_code = (buf[3] & CXUSB_BT656_VBI_MASK) ==
 238                 CXUSB_BT656_VBI_ON;
 239
 240         if (!sav_code || firstfield != firstfield_code)
 241                 return;
 242
 243         if (!vbi_code) {
 244                 cxusb_vprintk(dvbdev, BT656, "line start @ pos %u\n",
 245                               bt656->pos);
 246
 247                 bt656->linesamples = 0;
 248                 bt656->fmode = LINE_SAMPLES;
 249         } else {
 250                 cxusb_vprintk(dvbdev, BT656, "VBI start @ pos %u\n",
 251                               bt656->pos);
 252
 253                 bt656->fmode = VBI_SAMPLES;
 254         }
 255 }
 256
 257 static void cxusb_medion_cf_refc_line_smpl(struct dvb_usb_device *dvbdev,
 258                                            struct cxusb_bt656_params *bt656,
 259                                            bool firstfield,
 260                                            unsigned int maxlinesamples,
 261                                            unsigned char buf[4])
 262 {
 263         bool sav_code = (buf[3] & CXUSB_BT656_SEAV_MASK) ==
 264                 CXUSB_BT656_SEAV_SAV;
 265         unsigned int remsamples;
 266
 267         if (sav_code)
 268                 cxusb_vprintk(dvbdev, BT656,
 269                               "SAV in line samples @ line %u, pos %u\n",
 270                               bt656->line, bt656->pos);
 271
 272         remsamples = maxlinesamples - bt656->linesamples;
 273         if (bt656->buf && remsamples > 0) {
 274                 memset(bt656->buf, 0, remsamples);
 275                 bt656->buf += remsamples;
 276
 277                 cxusb_vprintk(dvbdev, BT656,
 278                               "field %c line %u %u samples still remaining (of %u)\n",
 279                               firstfield ? '1' : '2', bt656->line, remsamples,
 280                               maxlinesamples);
 281         }
 282
 283         bt656->fmode = START_SEARCH;
 284         bt656->line++;
 285 }
 286
 287 static void cxusb_medion_cf_refc_vbi_smpl(struct dvb_usb_device *dvbdev,
 288                                           struct cxusb_bt656_params *bt656,
 289                                           unsigned char buf[4])
 290 {
 291         bool sav_code = (buf[3] & CXUSB_BT656_SEAV_MASK) ==
 292                 CXUSB_BT656_SEAV_SAV;
 293
 294         if (sav_code)
 295                 cxusb_vprintk(dvbdev, BT656, "SAV in VBI samples @ pos %u\n",
 296                               bt656->pos);
 297
 298         bt656->fmode = START_SEARCH;
 299 }
 300
 301 /* returns whether the whole 4-byte code should be skipped in the buffer */
 302 static bool cxusb_medion_cf_ref_code(struct dvb_usb_device *dvbdev,
 303                                      struct cxusb_bt656_params *bt656,
 304                                      bool firstfield,
 305                                      unsigned int maxlines,
 306                                      unsigned int maxlinesamples,
 307                                      unsigned char buf[4])
 308 {
 309         if (bt656->fmode == START_SEARCH) {
 310                 cxusb_medion_cf_refc_start_sch(dvbdev, bt656, firstfield, buf);
 311         } else if (bt656->fmode == LINE_SAMPLES) {
 312                 cxusb_medion_cf_refc_line_smpl(dvbdev, bt656, firstfield,
 313                                                maxlinesamples, buf);
 314                 return false;
 315         } else if (bt656->fmode == VBI_SAMPLES) {
 316                 cxusb_medion_cf_refc_vbi_smpl(dvbdev, bt656, buf);
 317                 return false;
 318         }
 319
 320         return true;
 321 }
 322
 323 static bool cxusb_medion_cs_start_sch(struct dvb_usb_device *dvbdev,
 324                                       struct cxusb_medion_auxbuf *auxbuf,
 325                                       struct cxusb_bt656_params *bt656,
 326                                       unsigned int maxlinesamples)
 327 {
 328         unsigned char buf[64];
 329         unsigned int idx;
 330         unsigned int tocheck = clamp_t(size_t, maxlinesamples / 4, 3,
 331                                        sizeof(buf));
 332
 333         if (!cxusb_auxbuf_copy(auxbuf, bt656->pos + 1, buf, tocheck))
 334                 return false;
 335
 336         for (idx = 0; idx <= tocheck - 3; idx++)
 337                 if (memcmp(buf + idx, CXUSB_BT656_PREAMBLE, 3) == 0) {
 338                         bt656->pos += (1 + idx);
 339                         return true;
 340                 }
 341
 342         cxusb_vprintk(dvbdev, BT656, "line %u early start, pos %u\n",
 343                       bt656->line, bt656->pos);
 344
 345         bt656->linesamples = 0;
 346         bt656->fmode = LINE_SAMPLES;
 347
 348         return true;
 349 }
 350
 351 static void cxusb_medion_cs_line_smpl(struct cxusb_bt656_params *bt656,
 352                                       unsigned int maxlinesamples,
 353                                       unsigned char val)
 354 {
 355         if (bt656->buf)
 356                 *(bt656->buf++) = val;
 357
 358         bt656->linesamples++;
 359         bt656->pos++;
 360
 361         if (bt656->linesamples >= maxlinesamples) {
 362                 bt656->fmode = START_SEARCH;
 363                 bt656->line++;
 364         }
 365 }
 366
 367 static bool cxusb_medion_copy_samples(struct dvb_usb_device *dvbdev,
 368                                       struct cxusb_medion_auxbuf *auxbuf,
 369                                       struct cxusb_bt656_params *bt656,
 370                                       unsigned int maxlinesamples,
 371                                       unsigned char val)
 372 {
 373         if (bt656->fmode == START_SEARCH && bt656->line > 0)
 374                 return cxusb_medion_cs_start_sch(dvbdev, auxbuf, bt656,
 375                                                  maxlinesamples);
 376         else if (bt656->fmode == LINE_SAMPLES)
 377                 cxusb_medion_cs_line_smpl(bt656, maxlinesamples, val);
 378         else /* TODO: copy VBI samples */
 379                 bt656->pos++;
 380
 381         return true;
 382 }
 383
 384 static bool cxusb_medion_copy_field(struct dvb_usb_device *dvbdev,
 385                                     struct cxusb_medion_auxbuf *auxbuf,
 386                                     struct cxusb_bt656_params *bt656,
 387                                     bool firstfield,
 388                                     unsigned int maxlines,
 389                                     unsigned int maxlinesmpls)
 390 {
 391         while (bt656->line < maxlines) {
 392                 unsigned char val;
 393
 394                 if (!cxusb_auxbuf_copy(auxbuf, bt656->pos, &val, 1))
 395                         break;
 396
 397                 if (val == CXUSB_BT656_PREAMBLE[0]) {
 398                         unsigned char buf[4];
 399
 400                         buf[0] = val;
 401                         if (!cxusb_auxbuf_copy(auxbuf, bt656->pos + 1,
 402                                                buf + 1, 3))
 403                                 break;
 404
 405                         if (buf[1] == CXUSB_BT656_PREAMBLE[1] &&
 406                             buf[2] == CXUSB_BT656_PREAMBLE[2]) {
 407                                 /*
 408                                  * is this a field change?
 409                                  * if so, terminate copying the current field
 410                                  */
 411                                 if (cxusb_medion_cf_refc_fld_chg(dvbdev,
 412                                                                  bt656,
 413                                                                  firstfield,
 414                                                                  maxlines,
 415                                                                  maxlinesmpls,
 416                                                                  buf))
 417                                         return true;
 418
 419                                 if (cxusb_medion_cf_ref_code(dvbdev, bt656,
 420                                                              firstfield,
 421                                                              maxlines,
 422                                                              maxlinesmpls,
 423                                                              buf))
 424                                         bt656->pos += 4;
 425
 426                                 continue;
 427                         }
 428                 }
 429
 430                 if (!cxusb_medion_copy_samples(dvbdev, auxbuf, bt656,
 431                                                maxlinesmpls, val))
 432                         break;
 433         }
 434
 435         if (bt656->line < maxlines) {
 436                 cxusb_vprintk(dvbdev, BT656,
 437                               "end of buffer pos = %u, line = %u\n",
 438                               bt656->pos, bt656->line);
 439                 return false;
 440         }
 441
 442         return true;
 443 }
 444
 445 static bool cxusb_medion_v_process_auxbuf(struct cxusb_medion_dev *cxdev,
 446                                           bool reset)
 447 {
 448         struct dvb_usb_device *dvbdev = cxdev->dvbdev;
 449         struct cxusb_bt656_params *bt656 = &cxdev->bt656;
 450
 451         /*
 452          * if this is a new frame
 453          * fetch a buffer from list
 454          */
 455         if (bt656->mode == NEW_FRAME) {
 456                 if (!list_empty(&cxdev->buflist)) {
 457                         cxdev->vbuf =
 458                                 list_first_entry(&cxdev->buflist,
 459                                                  struct cxusb_medion_vbuffer,
 460                                                  list);
 461                         list_del(&cxdev->vbuf->list);
 462                 } else {
 463                         dev_warn(&dvbdev->udev->dev, "no free buffers\n");
 464                 }
 465         }
 466
 467         if (bt656->mode == NEW_FRAME || reset) {
 468                 cxusb_vprintk(dvbdev, URB, "will copy field 1\n");
 469                 bt656->pos = 0;
 470                 bt656->mode = FIRST_FIELD;
 471                 bt656->fmode = START_SEARCH;
 472                 bt656->line = 0;
 473
 474                 if (cxdev->vbuf) {
 475                         cxdev->vbuf->vb2.vb2_buf.timestamp = ktime_get_ns();
 476                         bt656->buf = vb2_plane_vaddr(&cxdev->vbuf->vb2.vb2_buf,
 477                                                      0);
 478                 }
 479         }
 480
 481         if (bt656->mode == FIRST_FIELD) {
 482                 if (!cxusb_medion_copy_field(dvbdev, &cxdev->auxbuf, bt656,
 483                                              true, cxdev->height / 2,
 484                                              cxdev->width * 2))
 485                         return false;
 486
 487                 /*
 488                  * do not trim buffer there in case
 489                  * we need to reset the search later
 490                  */
 491
 492                 cxusb_vprintk(dvbdev, URB, "will copy field 2\n");
 493                 bt656->mode = SECOND_FIELD;
 494                 bt656->fmode = START_SEARCH;
 495                 bt656->line = 0;
 496         }
 497
 498         if (bt656->mode == SECOND_FIELD) {
 499                 if (!cxusb_medion_copy_field(dvbdev, &cxdev->auxbuf, bt656,
 500                                              false, cxdev->height / 2,
 501                                              cxdev->width * 2))
 502                         return false;
 503
 504                 cxusb_auxbuf_head_trim(dvbdev, &cxdev->auxbuf, bt656->pos);
 505
 506                 bt656->mode = NEW_FRAME;
 507
 508                 if (cxdev->vbuf) {
 509                         vb2_set_plane_payload(&cxdev->vbuf->vb2.vb2_buf, 0,
 510                                               cxdev->width * cxdev->height * 2);
 511
 512                         cxdev->vbuf->vb2.field = cxdev->field_order;
 513                         cxdev->vbuf->vb2.sequence = cxdev->vbuf_sequence++;
 514
 515                         vb2_buffer_done(&cxdev->vbuf->vb2.vb2_buf,
 516                                         VB2_BUF_STATE_DONE);
 517
 518                         cxdev->vbuf = NULL;
 519                         cxdev->bt656.buf = NULL;
 520
 521                         cxusb_vprintk(dvbdev, URB, "frame done\n");
 522                 } else {
 523                         cxusb_vprintk(dvbdev, URB, "frame skipped\n");
 524                         cxdev->vbuf_sequence++;
 525                 }
 526         }
 527
 528         return true;
 529 }
 530
 531 static bool cxusb_medion_v_complete_handle_urb(struct cxusb_medion_dev *cxdev,
 532                                                bool *auxbuf_reset)
 533 {
 534         struct dvb_usb_device *dvbdev = cxdev->dvbdev;
 535         unsigned int urbn;
 536         struct urb *urb;
 537         int ret;
 538
 539         *auxbuf_reset = false;
 540
 541         urbn = cxdev->nexturb;
 542         if (!test_bit(urbn, &cxdev->urbcomplete))
 543                 return false;
 544
 545         clear_bit(urbn, &cxdev->urbcomplete);
 546
 547         do {
 548                 cxdev->nexturb++;
 549                 cxdev->nexturb %= CXUSB_VIDEO_URBS;
 550                 urb = cxdev->streamurbs[cxdev->nexturb];
 551         } while (!urb);
 552
 553         urb = cxdev->streamurbs[urbn];
 554         cxusb_vprintk(dvbdev, URB, "URB %u status = %d\n", urbn, urb->status);
 555
 556         if (urb->status == 0 || urb->status == -EXDEV) {
 557                 int i;
 558                 unsigned long len;
 559
 560                 for (i = 0, len = 0; i < urb->number_of_packets; i++)
 561                         len += urb->iso_frame_desc[i].actual_length;
 562
 563                 cxusb_vprintk(dvbdev, URB, "URB %u data len = %lu\n", urbn,
 564                               len);
 565
 566                 if (len > 0) {
 567                         cxusb_vprintk(dvbdev, URB, "appending URB\n");
 568
 569                         /*
 570                          * append new data to auxbuf while
 571                          * overwriting old data if necessary
 572                          *
 573                          * if any overwrite happens then we can no
 574                          * longer rely on consistency of the whole
 575                          * data so let's start again the current
 576                          * auxbuf frame assembling process from
 577                          * the beginning
 578                          */
 579                         *auxbuf_reset =
 580                                 !cxusb_auxbuf_append_urb(dvbdev,
 581                                                          &cxdev->auxbuf,
 582                                                          urb);
 583                 }
 584         }
 585
 586         cxusb_vprintk(dvbdev, URB, "URB %u resubmit\n", urbn);
 587
 588         ret = usb_submit_urb(urb, GFP_KERNEL);
 589         if (ret != 0)
 590                 dev_err(&dvbdev->udev->dev,
 591                         "unable to resubmit URB %u (%d), you'll have to restart streaming\n",
 592                         urbn, ret);
 593
 594         /* next URB is complete already? reschedule us then to handle it */
 595         return test_bit(cxdev->nexturb, &cxdev->urbcomplete);
 596 }
 597
 598 static void cxusb_medion_v_complete_work(struct work_struct *work)
 599 {
 600         struct cxusb_medion_dev *cxdev = container_of(work,
 601                                                       struct cxusb_medion_dev,
 602                                                       urbwork);
 603         struct dvb_usb_device *dvbdev = cxdev->dvbdev;
 604         bool auxbuf_reset;
 605         bool reschedule;
 606
 607         mutex_lock(cxdev->videodev->lock);
 608
 609         cxusb_vprintk(dvbdev, URB, "worker called, stop_streaming = %d\n",
 610                       (int)cxdev->stop_streaming);
 611
 612         if (cxdev->stop_streaming)
 613                 goto unlock;
 614
 615         reschedule = cxusb_medion_v_complete_handle_urb(cxdev, &auxbuf_reset);
 616
 617         if (cxusb_medion_v_process_auxbuf(cxdev, auxbuf_reset))
 618                 /* reschedule us until auxbuf no longer can produce any frame */
 619                 reschedule = true;
 620
 621         if (reschedule) {
 622                 cxusb_vprintk(dvbdev, URB, "rescheduling worker\n");
 623                 schedule_work(&cxdev->urbwork);
 624         }
 625
 626 unlock:
 627         mutex_unlock(cxdev->videodev->lock);
 628 }
 629
 630 static void cxusb_medion_v_complete(struct urb *u)
 631 {
 632         struct dvb_usb_device *dvbdev = u->context;
 633         struct cxusb_medion_dev *cxdev = dvbdev->priv;
 634         unsigned int i;
 635
 636         for (i = 0; i < CXUSB_VIDEO_URBS; i++)
 637                 if (cxdev->streamurbs[i] == u)
 638                         break;
 639
 640         if (i >= CXUSB_VIDEO_URBS) {
 641                 dev_err(&dvbdev->udev->dev,
 642                         "complete on unknown URB\n");
 643                 return;
 644         }
 645
 646         cxusb_vprintk(dvbdev, URB, "URB %u complete\n", i);
 647
 648         set_bit(i, &cxdev->urbcomplete);
 649         schedule_work(&cxdev->urbwork);
 650 }
 651
 652 static void cxusb_medion_urbs_free(struct cxusb_medion_dev *cxdev)
 653 {
 654         unsigned int i;
 655
 656         for (i = 0; i < CXUSB_VIDEO_URBS; i++)
 657                 if (cxdev->streamurbs[i]) {
 658                         kfree(cxdev->streamurbs[i]->transfer_buffer);
 659                         usb_free_urb(cxdev->streamurbs[i]);
 660                         cxdev->streamurbs[i] = NULL;
 661                 }
 662 }
 663
 664 static void cxusb_medion_return_buffers(struct cxusb_medion_dev *cxdev,
 665                                         bool requeue)
 666 {
 667         struct cxusb_medion_vbuffer *vbuf, *vbuf_tmp;
 668
 669         list_for_each_entry_safe(vbuf, vbuf_tmp, &cxdev->buflist,
 670                                  list) {
 671                 list_del(&vbuf->list);
 672                 vb2_buffer_done(&vbuf->vb2.vb2_buf,
 673                                 requeue ? VB2_BUF_STATE_QUEUED :
 674                                 VB2_BUF_STATE_ERROR);
 675         }
 676
 677         if (cxdev->vbuf) {
 678                 vb2_buffer_done(&cxdev->vbuf->vb2.vb2_buf,
 679                                 requeue ? VB2_BUF_STATE_QUEUED :
 680                                 VB2_BUF_STATE_ERROR);
 681
 682                 cxdev->vbuf = NULL;
 683                 cxdev->bt656.buf = NULL;
 684         }
 685 }
 686
 687 static int cxusb_medion_v_ss_auxbuf_alloc(struct cxusb_medion_dev *cxdev,
 688                                           int *npackets)
 689 {
 690         struct dvb_usb_device *dvbdev = cxdev->dvbdev;
 691         u8 *buf;
 692         unsigned int framelen, urblen, auxbuflen;
 693
 694         framelen = (cxdev->width * 2 + 4 + 4) *
 695                 (cxdev->height + 50 /* VBI lines */);
 696
 697         /*
 698          * try to fit a whole frame into each URB, as long as doing so
 699          * does not require very high order memory allocations
 700          */
 701         BUILD_BUG_ON(CXUSB_VIDEO_URB_MAX_SIZE / CXUSB_VIDEO_PKT_SIZE >
 702                      CXUSB_VIDEO_MAX_FRAME_PKTS);
 703         *npackets = min_t(int, (framelen + CXUSB_VIDEO_PKT_SIZE - 1) /
 704                           CXUSB_VIDEO_PKT_SIZE,
 705                           CXUSB_VIDEO_URB_MAX_SIZE / CXUSB_VIDEO_PKT_SIZE);
 706         urblen = *npackets * CXUSB_VIDEO_PKT_SIZE;
 707
 708         cxusb_vprintk(dvbdev, URB,
 709                       "each URB will have %d packets for total of %u bytes (%u x %u @ %u)\n",
 710                       *npackets, urblen, (unsigned int)cxdev->width,
 711                       (unsigned int)cxdev->height, framelen);
 712
 713         auxbuflen = framelen + urblen;
 714
 715         buf = vmalloc(auxbuflen);
 716         if (!buf)
 717                 return -ENOMEM;
 718
 719         cxusb_auxbuf_init(dvbdev, &cxdev->auxbuf, buf, auxbuflen);
 720
 721         return 0;
 722 }
 723
 724 static u32 cxusb_medion_norm2field_order(v4l2_std_id norm)
 725 {
 726         bool is625 = norm & V4L2_STD_625_50;
 727         bool is525 = norm & V4L2_STD_525_60;
 728
 729         if (!is625 && !is525)
 730                 return V4L2_FIELD_NONE;
 731
 732         if (is625 && is525)
 733                 return V4L2_FIELD_NONE;
 734
 735         if (is625)
 736                 return V4L2_FIELD_SEQ_TB;
 737         else /* is525 */
 738                 return V4L2_FIELD_SEQ_BT;
 739 }
 740
 741 static u32 cxusb_medion_field_order(struct cxusb_medion_dev *cxdev)
 742 {
 743         struct dvb_usb_device *dvbdev = cxdev->dvbdev;
 744         u32 field;
 745         int ret;
 746         v4l2_std_id norm;
 747
 748         /* TV tuner is PAL-only so it is always TB */
 749         if (cxdev->input == 0)
 750                 return V4L2_FIELD_SEQ_TB;
 751
 752         field = cxusb_medion_norm2field_order(cxdev->norm);
 753         if (field != V4L2_FIELD_NONE)
 754                 return field;
 755
 756         ret = v4l2_subdev_call(cxdev->cx25840, video, g_std, &norm);
 757         if (ret != 0) {
 758                 cxusb_vprintk(dvbdev, OPS,
 759                               "cannot get current standard for input %u\n",
 760                               (unsigned int)cxdev->input);
 761         } else {
 762                 field = cxusb_medion_norm2field_order(norm);
 763                 if (field != V4L2_FIELD_NONE)
 764                         return field;
 765         }
 766
 767         dev_warn(&dvbdev->udev->dev,
 768                  "cannot determine field order for the current standard setup and received signal, using TB\n");
 769         return V4L2_FIELD_SEQ_TB;
 770 }
 771
 772 static int cxusb_medion_v_start_streaming(struct vb2_queue *q,
 773                                           unsigned int count)
 774 {
 775         struct dvb_usb_device *dvbdev = vb2_get_drv_priv(q);
 776         struct cxusb_medion_dev *cxdev = dvbdev->priv;
 777         u8 streamon_params[2] = { 0x03, 0x00 };
 778         int npackets, i;
 779         int ret;
 780
 781         cxusb_vprintk(dvbdev, OPS, "should start streaming\n");
 782
 783         if (cxdev->stop_streaming) {
 784                 /* stream is being stopped */
 785                 ret = -EBUSY;
 786                 goto ret_retbufs;
 787         }
 788
 789         cxdev->field_order = cxusb_medion_field_order(cxdev);
 790
 791         ret = v4l2_subdev_call(cxdev->cx25840, video, s_stream, 1);
 792         if (ret != 0) {
 793                 dev_err(&dvbdev->udev->dev,
 794                         "unable to start stream (%d)\n", ret);
 795                 goto ret_retbufs;
 796         }
 797
 798         ret = cxusb_ctrl_msg(dvbdev, CMD_STREAMING_ON, streamon_params, 2,
 799                              NULL, 0);
 800         if (ret != 0) {
 801                 dev_err(&dvbdev->udev->dev,
 802                         "unable to start streaming (%d)\n", ret);
 803                 goto ret_unstream_cx;
 804         }
 805
 806         ret = cxusb_medion_v_ss_auxbuf_alloc(cxdev, &npackets);
 807         if (ret != 0)
 808                 goto ret_unstream_md;
 809
 810         for (i = 0; i < CXUSB_VIDEO_URBS; i++) {
 811                 int framen;
 812                 u8 *streambuf;
 813                 struct urb *surb;
 814
 815                 /*
 816                  * TODO: change this to an array of single pages to avoid
 817                  * doing a large continuous allocation when (if)
 818                  * s-g isochronous USB transfers are supported
 819                  */
 820                 streambuf = kmalloc(npackets * CXUSB_VIDEO_PKT_SIZE,
 821                                     GFP_KERNEL);
 822                 if (!streambuf) {
 823                         if (i < 2) {
 824                                 ret = -ENOMEM;
 825                                 goto ret_freeab;
 826                         }
 827                         break;
 828                 }
 829
 830                 surb = usb_alloc_urb(npackets, GFP_KERNEL);
 831                 if (!surb) {
 832                         kfree(streambuf);
 833                         ret = -ENOMEM;
 834                         goto ret_freeu;
 835                 }
 836
 837                 cxdev->streamurbs[i] = surb;
 838                 surb->dev = dvbdev->udev;
 839                 surb->context = dvbdev;
 840                 surb->pipe = usb_rcvisocpipe(dvbdev->udev, 2);
 841
 842                 surb->interval = 1;
 843                 surb->transfer_flags = URB_ISO_ASAP;
 844
 845                 surb->transfer_buffer = streambuf;
 846
 847                 surb->complete = cxusb_medion_v_complete;
 848                 surb->number_of_packets = npackets;
 849                 surb->transfer_buffer_length = npackets * CXUSB_VIDEO_PKT_SIZE;
 850
 851                 for (framen = 0; framen < npackets; framen++) {
 852                         surb->iso_frame_desc[framen].offset =
 853                                 CXUSB_VIDEO_PKT_SIZE * framen;
 854
 855                         surb->iso_frame_desc[framen].length =
 856                                 CXUSB_VIDEO_PKT_SIZE;
 857                 }
 858         }
 859
 860         cxdev->urbcomplete = 0;
 861         cxdev->nexturb = 0;
 862         cxdev->vbuf_sequence = 0;
 863
 864         cxdev->vbuf = NULL;
 865         cxdev->bt656.mode = NEW_FRAME;
 866         cxdev->bt656.buf = NULL;
 867
 868         for (i = 0; i < CXUSB_VIDEO_URBS; i++)
 869                 if (cxdev->streamurbs[i]) {
 870                         ret = usb_submit_urb(cxdev->streamurbs[i],
 871                                              GFP_KERNEL);
 872                         if (ret != 0)
 873                                 dev_err(&dvbdev->udev->dev,
 874                                         "URB %d submission failed (%d)\n", i,
 875                                         ret);
 876                 }
 877
 878         return 0;
 879
 880 ret_freeu:
 881         cxusb_medion_urbs_free(cxdev);
 882
 883 ret_freeab:
 884         vfree(cxdev->auxbuf.buf);
 885
 886 ret_unstream_md:
 887         cxusb_ctrl_msg(dvbdev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
 888
 889 ret_unstream_cx:
 890         v4l2_subdev_call(cxdev->cx25840, video, s_stream, 0);
 891
 892 ret_retbufs:
 893         cxusb_medion_return_buffers(cxdev, true);
 894
 895         return ret;
 896 }
 897
 898 static void cxusb_medion_v_stop_streaming(struct vb2_queue *q)
 899 {
 900         struct dvb_usb_device *dvbdev = vb2_get_drv_priv(q);
 901         struct cxusb_medion_dev *cxdev = dvbdev->priv;
 902         int ret;
 903         unsigned int i;
 904
 905         cxusb_vprintk(dvbdev, OPS, "should stop streaming\n");
 906
 907         if (WARN_ON(cxdev->stop_streaming))
 908                 return;
 909
 910         cxdev->stop_streaming = true;
 911
 912         cxusb_ctrl_msg(dvbdev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
 913
 914         ret = v4l2_subdev_call(cxdev->cx25840, video, s_stream, 0);
 915         if (ret != 0)
 916                 dev_err(&dvbdev->udev->dev, "unable to stop stream (%d)\n",
 917                         ret);
 918
 919         /* let URB completion run */
 920         mutex_unlock(cxdev->videodev->lock);
 921
 922         for (i = 0; i < CXUSB_VIDEO_URBS; i++)
 923                 if (cxdev->streamurbs[i])
 924                         usb_kill_urb(cxdev->streamurbs[i]);
 925
 926         flush_work(&cxdev->urbwork);
 927
 928         mutex_lock(cxdev->videodev->lock);
 929
 930         /* free transfer buffer and URB */
 931         vfree(cxdev->auxbuf.buf);
 932
 933         cxusb_medion_urbs_free(cxdev);
 934
 935         cxusb_medion_return_buffers(cxdev, false);
 936
 937         cxdev->stop_streaming = false;
 938 }
 939
 940 static void cxusub_medion_v_buf_queue(struct vb2_buffer *vb)
 941 {
 942         struct vb2_v4l2_buffer *v4l2buf = to_vb2_v4l2_buffer(vb);
 943         struct cxusb_medion_vbuffer *vbuf =
 944                 container_of(v4l2buf, struct cxusb_medion_vbuffer, vb2);
 945         struct dvb_usb_device *dvbdev = vb2_get_drv_priv(vb->vb2_queue);
 946         struct cxusb_medion_dev *cxdev = dvbdev->priv;
 947
 948         /* cxusb_vprintk(dvbdev, OPS, "mmmm.. a fresh buffer...\n"); */
 949
 950         list_add_tail(&vbuf->list, &cxdev->buflist);
 951 }
 952
 953 static const struct vb2_ops cxdev_video_qops = {
 954         .queue_setup = cxusb_medion_v_queue_setup,
 955         .buf_init = cxusb_medion_v_buf_init,
 956         .start_streaming = cxusb_medion_v_start_streaming,
 957         .stop_streaming = cxusb_medion_v_stop_streaming,
 958         .buf_queue = cxusub_medion_v_buf_queue,
 959         .wait_prepare = vb2_ops_wait_prepare,
 960         .wait_finish = vb2_ops_wait_finish
 961 };
 962
 963 static const __u32 videocaps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
 964         V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
 965 static const __u32 radiocaps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
 966
 967 static int cxusb_medion_v_querycap(struct file *file, void *fh,
 968                                    struct v4l2_capability *cap)
 969 {
 970         struct dvb_usb_device *dvbdev = video_drvdata(file);
 971
 972         strscpy(cap->driver, dvbdev->udev->dev.driver->name,
 973                 sizeof(cap->driver));
 974         strscpy(cap->card, "Medion 95700", sizeof(cap->card));
 975         usb_make_path(dvbdev->udev, cap->bus_info, sizeof(cap->bus_info));
 976
 977         cap->capabilities = videocaps | radiocaps | V4L2_CAP_DEVICE_CAPS;
 978
 979         return 0;
 980 }
 981
 982 static int cxusb_medion_v_enum_fmt_vid_cap(struct file *file, void *fh,
 983                                            struct v4l2_fmtdesc *f)
 984 {
 985         if (f->index != 0)
 986                 return -EINVAL;
 987
 988         f->pixelformat = V4L2_PIX_FMT_UYVY;
 989
 990         return 0;
 991 }
 992
 993 static int cxusb_medion_g_fmt_vid_cap(struct file *file, void *fh,
 994                                       struct v4l2_format *f)
 995 {
 996         struct dvb_usb_device *dvbdev = video_drvdata(file);
 997         struct cxusb_medion_dev *cxdev = dvbdev->priv;
 998
 999         f->fmt.pix.width = cxdev->width;
1000         f->fmt.pix.height = cxdev->height;
1001         f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1002         f->fmt.pix.field = vb2_start_streaming_called(&cxdev->videoqueue) ?
1003                 cxdev->field_order : cxusb_medion_field_order(cxdev);
1004         f->fmt.pix.bytesperline = cxdev->width * 2;
1005         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1006         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height;
1007
1008         return 0;
1009 }
1010
1011 static int cxusb_medion_try_s_fmt_vid_cap(struct file *file,
1012                                           struct v4l2_format *f,
1013                                           bool isset)
1014 {
1015         struct dvb_usb_device *dvbdev = video_drvdata(file);
1016         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1017         struct v4l2_subdev_format subfmt;
1018         u32 field;
1019         int ret;
1020
1021         if (isset && vb2_is_busy(&cxdev->videoqueue))
1022                 return -EBUSY;
1023
1024         field = vb2_start_streaming_called(&cxdev->videoqueue) ?
1025                 cxdev->field_order : cxusb_medion_field_order(cxdev);
1026
1027         memset(&subfmt, 0, sizeof(subfmt));
1028         subfmt.which = isset ? V4L2_SUBDEV_FORMAT_ACTIVE :
1029                 V4L2_SUBDEV_FORMAT_TRY;
1030         subfmt.format.width = f->fmt.pix.width & ~1;
1031         subfmt.format.height = f->fmt.pix.height & ~1;
1032         subfmt.format.code = MEDIA_BUS_FMT_FIXED;
1033         subfmt.format.field = field;
1034         subfmt.format.colorspace = V4L2_COLORSPACE_SMPTE170M;
1035
1036         ret = v4l2_subdev_call(cxdev->cx25840, pad, set_fmt, NULL, &subfmt);
1037         if (ret != 0)
1038                 return ret;
1039
1040         f->fmt.pix.width = subfmt.format.width;
1041         f->fmt.pix.height = subfmt.format.height;
1042         f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1043         f->fmt.pix.field = field;
1044         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1045         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height;
1046         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1047
1048         if (isset) {
1049                 cxdev->width = f->fmt.pix.width;
1050                 cxdev->height = f->fmt.pix.height;
1051         }
1052
1053         return 0;
1054 }
1055
1056 static int cxusb_medion_try_fmt_vid_cap(struct file *file, void *fh,
1057                                         struct v4l2_format *f)
1058 {
1059         return cxusb_medion_try_s_fmt_vid_cap(file, f, false);
1060 }
1061
1062 static int cxusb_medion_s_fmt_vid_cap(struct file *file, void *fh,
1063                                       struct v4l2_format *f)
1064 {
1065         return cxusb_medion_try_s_fmt_vid_cap(file, f, true);
1066 }
1067
1068 static const struct {
1069         struct v4l2_input input;
1070         u32 inputcfg;
1071 } cxusb_medion_inputs[] = {
1072         { .input = { .name = "TV tuner", .type = V4L2_INPUT_TYPE_TUNER,
1073                      .tuner = 0, .std = V4L2_STD_PAL },
1074           .inputcfg = CX25840_COMPOSITE2, },
1075
1076         {  .input = { .name = "Composite", .type = V4L2_INPUT_TYPE_CAMERA,
1077                      .std = V4L2_STD_ALL },
1078            .inputcfg = CX25840_COMPOSITE1, },
1079
1080         {  .input = { .name = "S-Video", .type = V4L2_INPUT_TYPE_CAMERA,
1081                       .std = V4L2_STD_ALL },
1082            .inputcfg = CX25840_SVIDEO_LUMA3 | CX25840_SVIDEO_CHROMA4 }
1083 };
1084
1085 #define CXUSB_INPUT_CNT ARRAY_SIZE(cxusb_medion_inputs)
1086
1087 static int cxusb_medion_enum_input(struct file *file, void *fh,
1088                                    struct v4l2_input *inp)
1089 {
1090         struct dvb_usb_device *dvbdev = video_drvdata(file);
1091         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1092         u32 index = inp->index;
1093
1094         if (index >= CXUSB_INPUT_CNT)
1095                 return -EINVAL;
1096
1097         *inp = cxusb_medion_inputs[index].input;
1098         inp->index = index;
1099         inp->capabilities |= V4L2_IN_CAP_STD;
1100
1101         if (index == cxdev->input) {
1102                 int ret;
1103                 u32 status = 0;
1104
1105                 ret = v4l2_subdev_call(cxdev->cx25840, video, g_input_status,
1106                                        &status);
1107                 if (ret != 0)
1108                         dev_warn(&dvbdev->udev->dev,
1109                                  "cx25840 input status query failed (%d)\n",
1110                                  ret);
1111                 else
1112                         inp->status = status;
1113         }
1114
1115         return 0;
1116 }
1117
1118 static int cxusb_medion_g_input(struct file *file, void *fh,
1119                                 unsigned int *i)
1120 {
1121         struct dvb_usb_device *dvbdev = video_drvdata(file);
1122         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1123
1124         *i = cxdev->input;
1125
1126         return 0;
1127 }
1128
1129 static int cxusb_medion_set_norm(struct cxusb_medion_dev *cxdev,
1130                                  v4l2_std_id norm)
1131 {
1132         struct dvb_usb_device *dvbdev = cxdev->dvbdev;
1133         int ret;
1134
1135         cxusb_vprintk(dvbdev, OPS,
1136                       "trying to set standard for input %u to %lx\n",
1137                       (unsigned int)cxdev->input,
1138                       (unsigned long)norm);
1139
1140         /* no autodetection support */
1141         if (norm == V4L2_STD_UNKNOWN)
1142                 return -EINVAL;
1143
1144         /* on composite or S-Video any std is acceptable */
1145         if (cxdev->input != 0) {
1146                 ret = v4l2_subdev_call(cxdev->cx25840, video, s_std, norm);
1147                 if (ret)
1148                         return ret;
1149
1150                 goto ret_savenorm;
1151         }
1152
1153         /* TV tuner is only able to demodulate PAL */
1154         if ((norm & ~V4L2_STD_PAL) != 0)
1155                 return -EINVAL;
1156
1157         ret = v4l2_subdev_call(cxdev->tda9887, video, s_std, norm);
1158         if (ret != 0) {
1159                 dev_err(&dvbdev->udev->dev,
1160                         "tda9887 norm setup failed (%d)\n",
1161                         ret);
1162                 return ret;
1163         }
1164
1165         ret = v4l2_subdev_call(cxdev->tuner, video, s_std, norm);
1166         if (ret != 0) {
1167                 dev_err(&dvbdev->udev->dev,
1168                         "tuner norm setup failed (%d)\n",
1169                         ret);
1170                 return ret;
1171         }
1172
1173         ret = v4l2_subdev_call(cxdev->cx25840, video, s_std, norm);
1174         if (ret != 0) {
1175                 dev_err(&dvbdev->udev->dev,
1176                         "cx25840 norm setup failed (%d)\n",
1177                         ret);
1178                 return ret;
1179         }
1180
1181 ret_savenorm:
1182         cxdev->norm = norm;
1183
1184         return 0;
1185 }
1186
1187 static int cxusb_medion_s_input(struct file *file, void *fh,
1188                                 unsigned int i)
1189 {
1190         struct dvb_usb_device *dvbdev = video_drvdata(file);
1191         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1192         int ret;
1193         v4l2_std_id norm;
1194
1195         if (i >= CXUSB_INPUT_CNT)
1196                 return -EINVAL;
1197
1198         ret = v4l2_subdev_call(cxdev->cx25840, video, s_routing,
1199                                cxusb_medion_inputs[i].inputcfg, 0, 0);
1200         if (ret != 0)
1201                 return ret;
1202
1203         cxdev->input = i;
1204         cxdev->videodev->tvnorms = cxusb_medion_inputs[i].input.std;
1205
1206         norm = cxdev->norm & cxusb_medion_inputs[i].input.std;
1207         if (norm == 0)
1208                 norm = cxusb_medion_inputs[i].input.std;
1209
1210         cxusb_medion_set_norm(cxdev, norm);
1211
1212         return 0;
1213 }
1214
1215 static int cxusb_medion_g_tuner(struct file *file, void *fh,
1216                                 struct v4l2_tuner *tuner)
1217 {
1218         struct dvb_usb_device *dvbdev = video_drvdata(file);
1219         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1220         struct video_device *vdev = video_devdata(file);
1221         int ret;
1222
1223         if (tuner->index != 0)
1224                 return -EINVAL;
1225
1226         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1227                 tuner->type = V4L2_TUNER_ANALOG_TV;
1228         else
1229                 tuner->type = V4L2_TUNER_RADIO;
1230
1231         tuner->capability = 0;
1232         tuner->afc = 0;
1233
1234         /*
1235          * fills:
1236          * always: capability (static), rangelow (static), rangehigh (static)
1237          * radio mode: afc (may fail silently), rxsubchans (static), audmode
1238          */
1239         ret = v4l2_subdev_call(cxdev->tda9887, tuner, g_tuner, tuner);
1240         if (ret != 0)
1241                 return ret;
1242
1243         /*
1244          * fills:
1245          * always: capability (static), rangelow (static), rangehigh (static)
1246          * radio mode: rxsubchans (always stereo), audmode,
1247          * signal (might be wrong)
1248          */
1249         ret = v4l2_subdev_call(cxdev->tuner, tuner, g_tuner, tuner);
1250         if (ret != 0)
1251                 return ret;
1252
1253         tuner->signal = 0;
1254
1255         /*
1256          * fills: TV mode: capability, rxsubchans, audmode, signal
1257          */
1258         ret = v4l2_subdev_call(cxdev->cx25840, tuner, g_tuner, tuner);
1259         if (ret != 0)
1260                 return ret;
1261
1262         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1263                 strscpy(tuner->name, "TV tuner", sizeof(tuner->name));
1264         else
1265                 strscpy(tuner->name, "Radio tuner", sizeof(tuner->name));
1266
1267         memset(tuner->reserved, 0, sizeof(tuner->reserved));
1268
1269         return 0;
1270 }
1271
1272 static int cxusb_medion_s_tuner(struct file *file, void *fh,
1273                                 const struct v4l2_tuner *tuner)
1274 {
1275         struct dvb_usb_device *dvbdev = video_drvdata(file);
1276         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1277         struct video_device *vdev = video_devdata(file);
1278         int ret;
1279
1280         if (tuner->index != 0)
1281                 return -EINVAL;
1282
1283         ret = v4l2_subdev_call(cxdev->tda9887, tuner, s_tuner, tuner);
1284         if (ret != 0)
1285                 return ret;
1286
1287         ret = v4l2_subdev_call(cxdev->tuner, tuner, s_tuner, tuner);
1288         if (ret != 0)
1289                 return ret;
1290
1291         /*
1292          * make sure that cx25840 is in a correct TV / radio mode,
1293          * since calls above may have changed it for tuner / IF demod
1294          */
1295         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1296                 v4l2_subdev_call(cxdev->cx25840, video, s_std, cxdev->norm);
1297         else
1298                 v4l2_subdev_call(cxdev->cx25840, tuner, s_radio);
1299
1300         return v4l2_subdev_call(cxdev->cx25840, tuner, s_tuner, tuner);
1301 }
1302
1303 static int cxusb_medion_g_frequency(struct file *file, void *fh,
1304                                     struct v4l2_frequency *freq)
1305 {
1306         struct dvb_usb_device *dvbdev = video_drvdata(file);
1307         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1308
1309         if (freq->tuner != 0)
1310                 return -EINVAL;
1311
1312         return v4l2_subdev_call(cxdev->tuner, tuner, g_frequency, freq);
1313 }
1314
1315 static int cxusb_medion_s_frequency(struct file *file, void *fh,
1316                                     const struct v4l2_frequency *freq)
1317 {
1318         struct dvb_usb_device *dvbdev = video_drvdata(file);
1319         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1320         struct video_device *vdev = video_devdata(file);
1321         int ret;
1322
1323         if (freq->tuner != 0)
1324                 return -EINVAL;
1325
1326         ret = v4l2_subdev_call(cxdev->tda9887, tuner, s_frequency, freq);
1327         if (ret != 0)
1328                 return ret;
1329
1330         ret = v4l2_subdev_call(cxdev->tuner, tuner, s_frequency, freq);
1331         if (ret != 0)
1332                 return ret;
1333
1334         /*
1335          * make sure that cx25840 is in a correct TV / radio mode,
1336          * since calls above may have changed it for tuner / IF demod
1337          */
1338         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1339                 v4l2_subdev_call(cxdev->cx25840, video, s_std, cxdev->norm);
1340         else
1341                 v4l2_subdev_call(cxdev->cx25840, tuner, s_radio);
1342
1343         return v4l2_subdev_call(cxdev->cx25840, tuner, s_frequency, freq);
1344 }
1345
1346 static int cxusb_medion_g_std(struct file *file, void *fh,
1347                               v4l2_std_id *norm)
1348 {
1349         struct dvb_usb_device *dvbdev = video_drvdata(file);
1350         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1351
1352         *norm = cxdev->norm;
1353
1354         if (*norm == V4L2_STD_UNKNOWN)
1355                 return -ENODATA;
1356
1357         return 0;
1358 }
1359
1360 static int cxusb_medion_s_std(struct file *file, void *fh,
1361                               v4l2_std_id norm)
1362 {
1363         struct dvb_usb_device *dvbdev = video_drvdata(file);
1364         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1365
1366         return cxusb_medion_set_norm(cxdev, norm);
1367 }
1368
1369 static int cxusb_medion_querystd(struct file *file, void *fh,
1370                                  v4l2_std_id *norm)
1371 {
1372         struct dvb_usb_device *dvbdev = video_drvdata(file);
1373         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1374         v4l2_std_id norm_mask;
1375         int ret;
1376
1377         /*
1378          * make sure we don't have improper std bits set for the TV tuner
1379          * (could happen when no signal was present yet after reset)
1380          */
1381         if (cxdev->input == 0)
1382                 norm_mask = V4L2_STD_PAL;
1383         else
1384                 norm_mask = V4L2_STD_ALL;
1385
1386         ret = v4l2_subdev_call(cxdev->cx25840, video, querystd, norm);
1387         if (ret != 0) {
1388                 cxusb_vprintk(dvbdev, OPS,
1389                               "cannot get detected standard for input %u\n",
1390                               (unsigned int)cxdev->input);
1391                 return ret;
1392         }
1393
1394         cxusb_vprintk(dvbdev, OPS, "input %u detected standard is %lx\n",
1395                       (unsigned int)cxdev->input, (unsigned long)*norm);
1396         *norm &= norm_mask;
1397
1398         return 0;
1399 }
1400
1401 static int cxusb_medion_log_status(struct file *file, void *fh)
1402 {
1403         struct dvb_usb_device *dvbdev = video_drvdata(file);
1404         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1405
1406         v4l2_device_call_all(&cxdev->v4l2dev, 0, core, log_status);
1407
1408         return 0;
1409 }
1410
1411 static const struct v4l2_ioctl_ops cxusb_video_ioctl = {
1412         .vidioc_querycap = cxusb_medion_v_querycap,
1413         .vidioc_enum_fmt_vid_cap = cxusb_medion_v_enum_fmt_vid_cap,
1414         .vidioc_g_fmt_vid_cap = cxusb_medion_g_fmt_vid_cap,
1415         .vidioc_s_fmt_vid_cap = cxusb_medion_s_fmt_vid_cap,
1416         .vidioc_try_fmt_vid_cap = cxusb_medion_try_fmt_vid_cap,
1417         .vidioc_enum_input = cxusb_medion_enum_input,
1418         .vidioc_g_input = cxusb_medion_g_input,
1419         .vidioc_s_input = cxusb_medion_s_input,
1420         .vidioc_g_tuner = cxusb_medion_g_tuner,
1421         .vidioc_s_tuner = cxusb_medion_s_tuner,
1422         .vidioc_g_frequency = cxusb_medion_g_frequency,
1423         .vidioc_s_frequency = cxusb_medion_s_frequency,
1424         .vidioc_g_std = cxusb_medion_g_std,
1425         .vidioc_s_std = cxusb_medion_s_std,
1426         .vidioc_querystd = cxusb_medion_querystd,
1427         .vidioc_log_status = cxusb_medion_log_status,
1428         .vidioc_reqbufs = vb2_ioctl_reqbufs,
1429         .vidioc_querybuf = vb2_ioctl_querybuf,
1430         .vidioc_qbuf = vb2_ioctl_qbuf,
1431         .vidioc_dqbuf = vb2_ioctl_dqbuf,
1432         .vidioc_create_bufs = vb2_ioctl_create_bufs,
1433         .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1434         .vidioc_streamon = vb2_ioctl_streamon,
1435         .vidioc_streamoff = vb2_ioctl_streamoff
1436 };
1437
1438 static const struct v4l2_ioctl_ops cxusb_radio_ioctl = {
1439         .vidioc_querycap = cxusb_medion_v_querycap,
1440         .vidioc_g_tuner = cxusb_medion_g_tuner,
1441         .vidioc_s_tuner = cxusb_medion_s_tuner,
1442         .vidioc_g_frequency = cxusb_medion_g_frequency,
1443         .vidioc_s_frequency = cxusb_medion_s_frequency,
1444         .vidioc_log_status = cxusb_medion_log_status
1445 };
1446
1447 /*
1448  * in principle, this should be const, but s_io_pin_config is declared
1449  * to take non-const, and gcc complains
1450  */
1451 static struct v4l2_subdev_io_pin_config cxusub_medion_pin_config[] = {
1452         { .pin = CX25840_PIN_DVALID_PRGM0, .function = CX25840_PAD_DEFAULT,
1453           .strength = CX25840_PIN_DRIVE_MEDIUM },
1454         { .pin = CX25840_PIN_PLL_CLK_PRGM7, .function = CX25840_PAD_AUX_PLL },
1455         { .pin = CX25840_PIN_HRESET_PRGM2, .function = CX25840_PAD_ACTIVE,
1456           .strength = CX25840_PIN_DRIVE_MEDIUM }
1457 };
1458
1459 int cxusb_medion_analog_init(struct dvb_usb_device *dvbdev)
1460 {
1461         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1462         u8 tuner_analog_msg_data[] = { 0x9c, 0x60, 0x85, 0x54 };
1463         struct i2c_msg tuner_analog_msg = { .addr = 0x61, .flags = 0,
1464                                             .buf = tuner_analog_msg_data,
1465                                             .len =
1466                                             sizeof(tuner_analog_msg_data) };
1467         struct v4l2_subdev_format subfmt;
1468         int ret;
1469
1470         /* switch tuner to analog mode so IF demod will become accessible */
1471         ret = i2c_transfer(&dvbdev->i2c_adap, &tuner_analog_msg, 1);
1472         if (ret != 1)
1473                 dev_warn(&dvbdev->udev->dev,
1474                          "tuner analog switch failed (%d)\n", ret);
1475
1476         /*
1477          * cx25840 might have lost power during mode switching so we need
1478          * to set it again
1479          */
1480         ret = v4l2_subdev_call(cxdev->cx25840, core, reset, 0);
1481         if (ret != 0)
1482                 dev_warn(&dvbdev->udev->dev,
1483                          "cx25840 reset failed (%d)\n", ret);
1484
1485         ret = v4l2_subdev_call(cxdev->cx25840, video, s_routing,
1486                                CX25840_COMPOSITE1, 0, 0);
1487         if (ret != 0)
1488                 dev_warn(&dvbdev->udev->dev,
1489                          "cx25840 initial input setting failed (%d)\n", ret);
1490
1491         /* composite */
1492         cxdev->input = 1;
1493         cxdev->videodev->tvnorms = V4L2_STD_ALL;
1494         cxdev->norm = V4L2_STD_PAL;
1495
1496         /* TODO: setup audio samples insertion */
1497
1498         ret = v4l2_subdev_call(cxdev->cx25840, core, s_io_pin_config,
1499                                ARRAY_SIZE(cxusub_medion_pin_config),
1500                                cxusub_medion_pin_config);
1501         if (ret != 0)
1502                 dev_warn(&dvbdev->udev->dev,
1503                          "cx25840 pin config failed (%d)\n", ret);
1504
1505         /* make sure that we aren't in radio mode */
1506         v4l2_subdev_call(cxdev->tda9887, video, s_std, cxdev->norm);
1507         v4l2_subdev_call(cxdev->tuner, video, s_std, cxdev->norm);
1508         v4l2_subdev_call(cxdev->cx25840, video, s_std, cxdev->norm);
1509
1510         memset(&subfmt, 0, sizeof(subfmt));
1511         subfmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1512         subfmt.format.width = cxdev->width;
1513         subfmt.format.height = cxdev->height;
1514         subfmt.format.code = MEDIA_BUS_FMT_FIXED;
1515         subfmt.format.field = V4L2_FIELD_SEQ_TB;
1516         subfmt.format.colorspace = V4L2_COLORSPACE_SMPTE170M;
1517
1518         ret = v4l2_subdev_call(cxdev->cx25840, pad, set_fmt, NULL, &subfmt);
1519         if (ret != 0)
1520                 dev_warn(&dvbdev->udev->dev,
1521                          "cx25840 format set failed (%d)\n", ret);
1522
1523         if (ret == 0) {
1524                 cxdev->width = subfmt.format.width;
1525                 cxdev->height = subfmt.format.height;
1526         }
1527
1528         return 0;
1529 }
1530
1531 static int cxusb_videoradio_open(struct file *f)
1532 {
1533         struct dvb_usb_device *dvbdev = video_drvdata(f);
1534         int ret;
1535
1536         /*
1537          * no locking needed since this call only modifies analog
1538          * state if there are no other analog handles currenly
1539          * opened so ops done via them cannot create a conflict
1540          */
1541         ret = cxusb_medion_get(dvbdev, CXUSB_OPEN_ANALOG);
1542         if (ret != 0)
1543                 return ret;
1544
1545         ret = v4l2_fh_open(f);
1546         if (ret != 0)
1547                 goto ret_release;
1548
1549         cxusb_vprintk(dvbdev, OPS, "got open\n");
1550
1551         return 0;
1552
1553 ret_release:
1554         cxusb_medion_put(dvbdev);
1555
1556         return ret;
1557 }
1558
1559 static int cxusb_videoradio_release(struct file *f)
1560 {
1561         struct video_device *vdev = video_devdata(f);
1562         struct dvb_usb_device *dvbdev = video_drvdata(f);
1563         int ret;
1564
1565         cxusb_vprintk(dvbdev, OPS, "got release\n");
1566
1567         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1568                 ret = vb2_fop_release(f);
1569         else
1570                 ret = v4l2_fh_release(f);
1571
1572         cxusb_medion_put(dvbdev);
1573
1574         return ret;
1575 }
1576
1577 static const struct v4l2_file_operations cxusb_video_fops = {
1578         .owner = THIS_MODULE,
1579         .read = vb2_fop_read,
1580         .poll = vb2_fop_poll,
1581         .unlocked_ioctl = video_ioctl2,
1582         .mmap = vb2_fop_mmap,
1583         .open = cxusb_videoradio_open,
1584         .release = cxusb_videoradio_release
1585 };
1586
1587 static const struct v4l2_file_operations cxusb_radio_fops = {
1588         .owner = THIS_MODULE,
1589         .unlocked_ioctl = video_ioctl2,
1590         .open = cxusb_videoradio_open,
1591         .release = cxusb_videoradio_release
1592 };
1593
1594 static void cxusb_medion_v4l2_release(struct v4l2_device *v4l2_dev)
1595 {
1596         struct cxusb_medion_dev *cxdev =
1597                 container_of(v4l2_dev, struct cxusb_medion_dev, v4l2dev);
1598         struct dvb_usb_device *dvbdev = cxdev->dvbdev;
1599
1600         cxusb_vprintk(dvbdev, OPS, "v4l2 device release\n");
1601
1602         v4l2_device_unregister(&cxdev->v4l2dev);
1603
1604         mutex_destroy(&cxdev->dev_lock);
1605
1606         while (completion_done(&cxdev->v4l2_release))
1607                 schedule();
1608
1609         complete(&cxdev->v4l2_release);
1610 }
1611
1612 static void cxusb_medion_videodev_release(struct video_device *vdev)
1613 {
1614         struct dvb_usb_device *dvbdev = video_get_drvdata(vdev);
1615
1616         cxusb_vprintk(dvbdev, OPS, "video device release\n");
1617
1618         vb2_queue_release(vdev->queue);
1619
1620         video_device_release(vdev);
1621 }
1622
1623 static int cxusb_medion_register_analog_video(struct dvb_usb_device *dvbdev)
1624 {
1625         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1626         int ret;
1627
1628         cxdev->videoqueue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1629         cxdev->videoqueue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ |
1630                 VB2_DMABUF;
1631         cxdev->videoqueue.ops = &cxdev_video_qops;
1632         cxdev->videoqueue.mem_ops = &vb2_vmalloc_memops;
1633         cxdev->videoqueue.drv_priv = dvbdev;
1634         cxdev->videoqueue.buf_struct_size =
1635                 sizeof(struct cxusb_medion_vbuffer);
1636         cxdev->videoqueue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1637         cxdev->videoqueue.min_buffers_needed = 6;
1638         cxdev->videoqueue.lock = &cxdev->dev_lock;
1639
1640         ret = vb2_queue_init(&cxdev->videoqueue);
1641         if (ret) {
1642                 dev_err(&dvbdev->udev->dev,
1643                         "video queue init failed, ret = %d\n", ret);
1644                 return ret;
1645         }
1646
1647         cxdev->videodev = video_device_alloc();
1648         if (!cxdev->videodev) {
1649                 dev_err(&dvbdev->udev->dev, "video device alloc failed\n");
1650                 ret = -ENOMEM;
1651                 goto ret_qrelease;
1652         }
1653
1654         cxdev->videodev->device_caps = videocaps;
1655         cxdev->videodev->fops = &cxusb_video_fops;
1656         cxdev->videodev->v4l2_dev = &cxdev->v4l2dev;
1657         cxdev->videodev->queue = &cxdev->videoqueue;
1658         strscpy(cxdev->videodev->name, "cxusb", sizeof(cxdev->videodev->name));
1659         cxdev->videodev->vfl_dir = VFL_DIR_RX;
1660         cxdev->videodev->ioctl_ops = &cxusb_video_ioctl;
1661         cxdev->videodev->tvnorms = V4L2_STD_ALL;
1662         cxdev->videodev->release = cxusb_medion_videodev_release;
1663         cxdev->videodev->lock = &cxdev->dev_lock;
1664         video_set_drvdata(cxdev->videodev, dvbdev);
1665
1666         ret = video_register_device(cxdev->videodev, VFL_TYPE_GRABBER, -1);
1667         if (ret) {
1668                 dev_err(&dvbdev->udev->dev,
1669                         "video device register failed, ret = %d\n", ret);
1670                 goto ret_vrelease;
1671         }
1672
1673         return 0;
1674
1675 ret_vrelease:
1676         video_device_release(cxdev->videodev);
1677
1678 ret_qrelease:
1679         vb2_queue_release(&cxdev->videoqueue);
1680
1681         return ret;
1682 }
1683
1684 static int cxusb_medion_register_analog_radio(struct dvb_usb_device *dvbdev)
1685 {
1686         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1687         int ret;
1688
1689         cxdev->radiodev = video_device_alloc();
1690         if (!cxdev->radiodev) {
1691                 dev_err(&dvbdev->udev->dev, "radio device alloc failed\n");
1692                 return -ENOMEM;
1693         }
1694
1695         cxdev->radiodev->device_caps = radiocaps;
1696         cxdev->radiodev->fops = &cxusb_radio_fops;
1697         cxdev->radiodev->v4l2_dev = &cxdev->v4l2dev;
1698         strscpy(cxdev->radiodev->name, "cxusb", sizeof(cxdev->radiodev->name));
1699         cxdev->radiodev->vfl_dir = VFL_DIR_RX;
1700         cxdev->radiodev->ioctl_ops = &cxusb_radio_ioctl;
1701         cxdev->radiodev->release = video_device_release;
1702         cxdev->radiodev->lock = &cxdev->dev_lock;
1703         video_set_drvdata(cxdev->radiodev, dvbdev);
1704
1705         ret = video_register_device(cxdev->radiodev, VFL_TYPE_RADIO, -1);
1706         if (ret) {
1707                 dev_err(&dvbdev->udev->dev,
1708                         "radio device register failed, ret = %d\n", ret);
1709                 video_device_release(cxdev->radiodev);
1710                 return ret;
1711         }
1712
1713         return 0;
1714 }
1715
1716 static int cxusb_medion_register_analog_subdevs(struct dvb_usb_device *dvbdev)
1717 {
1718         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1719         int ret;
1720         struct tuner_setup tun_setup;
1721
1722         /* attach cx25840 capture chip */
1723         cxdev->cx25840 = v4l2_i2c_new_subdev(&cxdev->v4l2dev,
1724                                              &dvbdev->i2c_adap,
1725                                              "cx25840", 0x44, NULL);
1726         if (!cxdev->cx25840) {
1727                 dev_err(&dvbdev->udev->dev, "cx25840 not found\n");
1728                 return -ENODEV;
1729         }
1730
1731         /*
1732          * Initialize cx25840 chip by calling its subdevice init core op.
1733          *
1734          * This switches it into the generic mode that disables some of
1735          * ivtv-related hacks in the cx25840 driver while allowing setting
1736          * of the chip video output configuration (passed in the call below
1737          * as the last argument).
1738          */
1739         ret = v4l2_subdev_call(cxdev->cx25840, core, init,
1740                                CX25840_VCONFIG_FMT_BT656 |
1741                                CX25840_VCONFIG_RES_8BIT |
1742                                CX25840_VCONFIG_VBIRAW_DISABLED |
1743                                CX25840_VCONFIG_ANCDATA_DISABLED |
1744                                CX25840_VCONFIG_ACTIVE_COMPOSITE |
1745                                CX25840_VCONFIG_VALID_ANDACTIVE |
1746                                CX25840_VCONFIG_HRESETW_NORMAL |
1747                                CX25840_VCONFIG_CLKGATE_NONE |
1748                                CX25840_VCONFIG_DCMODE_DWORDS);
1749         if (ret != 0) {
1750                 dev_err(&dvbdev->udev->dev,
1751                         "cx25840 init failed (%d)\n", ret);
1752                 return ret;
1753         }
1754
1755         /* attach analog tuner */
1756         cxdev->tuner = v4l2_i2c_new_subdev(&cxdev->v4l2dev,
1757                                            &dvbdev->i2c_adap,
1758                                            "tuner", 0x61, NULL);
1759         if (!cxdev->tuner) {
1760                 dev_err(&dvbdev->udev->dev, "tuner not found\n");
1761                 return -ENODEV;
1762         }
1763
1764         /* configure it */
1765         memset(&tun_setup, 0, sizeof(tun_setup));
1766         tun_setup.addr = 0x61;
1767         tun_setup.type = TUNER_PHILIPS_FMD1216ME_MK3;
1768         tun_setup.mode_mask = T_RADIO | T_ANALOG_TV;
1769         v4l2_subdev_call(cxdev->tuner, tuner, s_type_addr, &tun_setup);
1770
1771         /* attach IF demod */
1772         cxdev->tda9887 = v4l2_i2c_new_subdev(&cxdev->v4l2dev,
1773                                              &dvbdev->i2c_adap,
1774                                              "tuner", 0x43, NULL);
1775         if (!cxdev->tda9887) {
1776                 dev_err(&dvbdev->udev->dev, "tda9887 not found\n");
1777                 return -ENODEV;
1778         }
1779
1780         return 0;
1781 }
1782
1783 int cxusb_medion_register_analog(struct dvb_usb_device *dvbdev)
1784 {
1785         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1786         int ret;
1787
1788         mutex_init(&cxdev->dev_lock);
1789
1790         init_completion(&cxdev->v4l2_release);
1791
1792         cxdev->v4l2dev.release = cxusb_medion_v4l2_release;
1793
1794         ret = v4l2_device_register(&dvbdev->udev->dev, &cxdev->v4l2dev);
1795         if (ret != 0) {
1796                 dev_err(&dvbdev->udev->dev,
1797                         "V4L2 device registration failed, ret = %d\n", ret);
1798                 mutex_destroy(&cxdev->dev_lock);
1799                 return ret;
1800         }
1801
1802         ret = cxusb_medion_register_analog_subdevs(dvbdev);
1803         if (ret)
1804                 goto ret_unregister;
1805
1806         INIT_WORK(&cxdev->urbwork, cxusb_medion_v_complete_work);
1807         INIT_LIST_HEAD(&cxdev->buflist);
1808
1809         cxdev->width = 320;
1810         cxdev->height = 240;
1811
1812         ret = cxusb_medion_register_analog_video(dvbdev);
1813         if (ret)
1814                 goto ret_unregister;
1815
1816         ret = cxusb_medion_register_analog_radio(dvbdev);
1817         if (ret)
1818                 goto ret_vunreg;
1819
1820         return 0;
1821
1822 ret_vunreg:
1823         video_unregister_device(cxdev->videodev);
1824
1825 ret_unregister:
1826         v4l2_device_put(&cxdev->v4l2dev);
1827         wait_for_completion(&cxdev->v4l2_release);
1828
1829         return ret;
1830 }
1831
1832 void cxusb_medion_unregister_analog(struct dvb_usb_device *dvbdev)
1833 {
1834         struct cxusb_medion_dev *cxdev = dvbdev->priv;
1835
1836         cxusb_vprintk(dvbdev, OPS, "unregistering analog\n");
1837
1838         video_unregister_device(cxdev->radiodev);
1839         video_unregister_device(cxdev->videodev);
1840
1841         v4l2_device_put(&cxdev->v4l2dev);
1842         wait_for_completion(&cxdev->v4l2_release);
1843
1844         cxusb_vprintk(dvbdev, OPS, "analog unregistered\n");
1845 }