drivers/media/dvb-frontends/rtl2832_sdr.c

   1 /*
   2  * Realtek RTL2832U SDR driver
   3  *
   4  * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
   5  *
   6  *    This program is free software; you can redistribute it and/or modify
   7  *    it under the terms of the GNU General Public License as published by
   8  *    the Free Software Foundation; either version 2 of the License, or
   9  *    (at your option) any later version.
  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 along
  17  *    with this program; if not, write to the Free Software Foundation, Inc.,
  18  *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * GNU Radio plugin "gr-kernel" for device usage will be on:
  21  * http://git.linuxtv.org/anttip/gr-kernel.git
  22  *
  23  */
  24
  25 #include "rtl2832_sdr.h"
  26 #include "dvb_usb.h"
  27
  28 #include <media/v4l2-device.h>
  29 #include <media/v4l2-ioctl.h>
  30 #include <media/v4l2-ctrls.h>
  31 #include <media/v4l2-event.h>
  32 #include <media/videobuf2-vmalloc.h>
  33
  34 #include <linux/platform_device.h>
  35 #include <linux/jiffies.h>
  36 #include <linux/math64.h>
  37
  38 static bool rtl2832_sdr_emulated_fmt;
  39 module_param_named(emulated_formats, rtl2832_sdr_emulated_fmt, bool, 0644);
  40 MODULE_PARM_DESC(emulated_formats, "enable emulated formats (disappears in future)");
  41
  42 /* Original macro does not contain enough null pointer checks for our need */
  43 #define V4L2_SUBDEV_HAS_OP(sd, o, f) \
  44         ((sd) && (sd)->ops && (sd)->ops->o && (sd)->ops->o->f)
  45
  46 #define MAX_BULK_BUFS            (10)
  47 #define BULK_BUFFER_SIZE         (128 * 512)
  48
  49 static const struct v4l2_frequency_band bands_adc[] = {
  50         {
  51                 .tuner = 0,
  52                 .type = V4L2_TUNER_ADC,
  53                 .index = 0,
  54                 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
  55                 .rangelow   =  300000,
  56                 .rangehigh  =  300000,
  57         },
  58         {
  59                 .tuner = 0,
  60                 .type = V4L2_TUNER_ADC,
  61                 .index = 1,
  62                 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
  63                 .rangelow   =  900001,
  64                 .rangehigh  = 2800000,
  65         },
  66         {
  67                 .tuner = 0,
  68                 .type = V4L2_TUNER_ADC,
  69                 .index = 2,
  70                 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
  71                 .rangelow   = 3200000,
  72                 .rangehigh  = 3200000,
  73         },
  74 };
  75
  76 static const struct v4l2_frequency_band bands_fm[] = {
  77         {
  78                 .tuner = 1,
  79                 .type = V4L2_TUNER_RF,
  80                 .index = 0,
  81                 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
  82                 .rangelow   =    50000000,
  83                 .rangehigh  =  2000000000,
  84         },
  85 };
  86
  87 /* stream formats */
  88 struct rtl2832_sdr_format {
  89         char    *name;
  90         u32     pixelformat;
  91         u32     buffersize;
  92 };
  93
  94 static struct rtl2832_sdr_format formats[] = {
  95         {
  96                 .name           = "Complex U8",
  97                 .pixelformat    = V4L2_SDR_FMT_CU8,
  98                 .buffersize     = BULK_BUFFER_SIZE,
  99         }, {
 100                 .name           = "Complex U16LE (emulated)",
 101                 .pixelformat    = V4L2_SDR_FMT_CU16LE,
 102                 .buffersize     = BULK_BUFFER_SIZE * 2,
 103         },
 104 };
 105
 106 static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats);
 107
 108 /* intermediate buffers with raw data from the USB device */
 109 struct rtl2832_sdr_frame_buf {
 110         struct vb2_buffer vb;   /* common v4l buffer stuff -- must be first */
 111         struct list_head list;
 112 };
 113
 114 struct rtl2832_sdr_dev {
 115 #define POWER_ON           0  /* BIT(0) */
 116 #define URB_BUF            1  /* BIT(1) */
 117         unsigned long flags;
 118
 119         struct platform_device *pdev;
 120
 121         struct video_device vdev;
 122         struct v4l2_device v4l2_dev;
 123         struct v4l2_subdev *v4l2_subdev;
 124
 125         /* videobuf2 queue and queued buffers list */
 126         struct vb2_queue vb_queue;
 127         struct list_head queued_bufs;
 128         spinlock_t queued_bufs_lock; /* Protects queued_bufs */
 129         unsigned sequence;           /* buffer sequence counter */
 130
 131         /* Note if taking both locks v4l2_lock must always be locked first! */
 132         struct mutex v4l2_lock;      /* Protects everything else */
 133         struct mutex vb_queue_lock;  /* Protects vb_queue and capt_file */
 134
 135         /* Pointer to our usb_device, will be NULL after unplug */
 136         struct usb_device *udev; /* Both mutexes most be hold when setting! */
 137
 138         unsigned int vb_full; /* vb is full and packets dropped */
 139
 140         struct urb     *urb_list[MAX_BULK_BUFS];
 141         int            buf_num;
 142         unsigned long  buf_size;
 143         u8             *buf_list[MAX_BULK_BUFS];
 144         dma_addr_t     dma_addr[MAX_BULK_BUFS];
 145         int urbs_initialized;
 146         int urbs_submitted;
 147
 148         unsigned int f_adc, f_tuner;
 149         u32 pixelformat;
 150         u32 buffersize;
 151         unsigned int num_formats;
 152
 153         /* Controls */
 154         struct v4l2_ctrl_handler hdl;
 155         struct v4l2_ctrl *bandwidth_auto;
 156         struct v4l2_ctrl *bandwidth;
 157
 158         /* for sample rate calc */
 159         unsigned int sample;
 160         unsigned int sample_measured;
 161         unsigned long jiffies_next;
 162 };
 163
 164 /* write multiple registers */
 165 static int rtl2832_sdr_wr_regs(struct rtl2832_sdr_dev *dev, u16 reg,
 166                 const u8 *val, int len)
 167 {
 168         struct platform_device *pdev = dev->pdev;
 169         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 170         struct i2c_client *client = pdata->i2c_client;
 171
 172         return pdata->bulk_write(client, reg, val, len);
 173 }
 174
 175 #if 0
 176 /* read multiple registers */
 177 static int rtl2832_sdr_rd_regs(struct rtl2832_sdr_dev *dev, u16 reg, u8 *val,
 178                 int len)
 179 {
 180         struct platform_device *pdev = dev->pdev;
 181         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 182         struct i2c_client *client = pdata->i2c_client;
 183
 184         return pdata->bulk_read(client, reg, val, len);
 185 }
 186 #endif
 187
 188 /* write single register */
 189 static int rtl2832_sdr_wr_reg(struct rtl2832_sdr_dev *dev, u16 reg, u8 val)
 190 {
 191         return rtl2832_sdr_wr_regs(dev, reg, &val, 1);
 192 }
 193
 194 /* write single register with mask */
 195 static int rtl2832_sdr_wr_reg_mask(struct rtl2832_sdr_dev *dev, u16 reg,
 196                 u8 val, u8 mask)
 197 {
 198         struct platform_device *pdev = dev->pdev;
 199         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 200         struct i2c_client *client = pdata->i2c_client;
 201
 202         return pdata->update_bits(client, reg, mask, val);
 203 }
 204
 205 /* Private functions */
 206 static struct rtl2832_sdr_frame_buf *rtl2832_sdr_get_next_fill_buf(
 207                 struct rtl2832_sdr_dev *dev)
 208 {
 209         unsigned long flags;
 210         struct rtl2832_sdr_frame_buf *buf = NULL;
 211
 212         spin_lock_irqsave(&dev->queued_bufs_lock, flags);
 213         if (list_empty(&dev->queued_bufs))
 214                 goto leave;
 215
 216         buf = list_entry(dev->queued_bufs.next,
 217                         struct rtl2832_sdr_frame_buf, list);
 218         list_del(&buf->list);
 219 leave:
 220         spin_unlock_irqrestore(&dev->queued_bufs_lock, flags);
 221         return buf;
 222 }
 223
 224 static unsigned int rtl2832_sdr_convert_stream(struct rtl2832_sdr_dev *dev,
 225                 void *dst, const u8 *src, unsigned int src_len)
 226 {
 227         struct platform_device *pdev = dev->pdev;
 228         unsigned int dst_len;
 229
 230         if (dev->pixelformat ==  V4L2_SDR_FMT_CU8) {
 231                 /* native stream, no need to convert */
 232                 memcpy(dst, src, src_len);
 233                 dst_len = src_len;
 234         } else if (dev->pixelformat == V4L2_SDR_FMT_CU16LE) {
 235                 /* convert u8 to u16 */
 236                 unsigned int i;
 237                 u16 *u16dst = dst;
 238
 239                 for (i = 0; i < src_len; i++)
 240                         *u16dst++ = (src[i] << 8) | (src[i] >> 0);
 241                 dst_len = 2 * src_len;
 242         } else {
 243                 dst_len = 0;
 244         }
 245
 246         /* calculate sample rate and output it in 10 seconds intervals */
 247         if (unlikely(time_is_before_jiffies(dev->jiffies_next))) {
 248                 #define MSECS 10000UL
 249                 unsigned int msecs = jiffies_to_msecs(jiffies -
 250                                 dev->jiffies_next + msecs_to_jiffies(MSECS));
 251                 unsigned int samples = dev->sample - dev->sample_measured;
 252
 253                 dev->jiffies_next = jiffies + msecs_to_jiffies(MSECS);
 254                 dev->sample_measured = dev->sample;
 255                 dev_dbg(&pdev->dev,
 256                         "slen=%u samples=%u msecs=%u sample rate=%lu\n",
 257                         src_len, samples, msecs, samples * 1000UL / msecs);
 258         }
 259
 260         /* total number of I+Q pairs */
 261         dev->sample += src_len / 2;
 262
 263         return dst_len;
 264 }
 265
 266 /*
 267  * This gets called for the bulk stream pipe. This is done in interrupt
 268  * time, so it has to be fast, not crash, and not stall. Neat.
 269  */
 270 static void rtl2832_sdr_urb_complete(struct urb *urb)
 271 {
 272         struct rtl2832_sdr_dev *dev = urb->context;
 273         struct platform_device *pdev = dev->pdev;
 274         struct rtl2832_sdr_frame_buf *fbuf;
 275
 276         dev_dbg_ratelimited(&pdev->dev, "status=%d length=%d/%d errors=%d\n",
 277                             urb->status, urb->actual_length,
 278                             urb->transfer_buffer_length, urb->error_count);
 279
 280         switch (urb->status) {
 281         case 0:             /* success */
 282         case -ETIMEDOUT:    /* NAK */
 283                 break;
 284         case -ECONNRESET:   /* kill */
 285         case -ENOENT:
 286         case -ESHUTDOWN:
 287                 return;
 288         default:            /* error */
 289                 dev_err_ratelimited(&pdev->dev, "urb failed=%d\n", urb->status);
 290                 break;
 291         }
 292
 293         if (likely(urb->actual_length > 0)) {
 294                 void *ptr;
 295                 unsigned int len;
 296                 /* get free framebuffer */
 297                 fbuf = rtl2832_sdr_get_next_fill_buf(dev);
 298                 if (unlikely(fbuf == NULL)) {
 299                         dev->vb_full++;
 300                         dev_notice_ratelimited(&pdev->dev,
 301                                                "videobuf is full, %d packets dropped\n",
 302                                                dev->vb_full);
 303                         goto skip;
 304                 }
 305
 306                 /* fill framebuffer */
 307                 ptr = vb2_plane_vaddr(&fbuf->vb, 0);
 308                 len = rtl2832_sdr_convert_stream(dev, ptr, urb->transfer_buffer,
 309                                 urb->actual_length);
 310                 vb2_set_plane_payload(&fbuf->vb, 0, len);
 311                 v4l2_get_timestamp(&fbuf->vb.v4l2_buf.timestamp);
 312                 fbuf->vb.v4l2_buf.sequence = dev->sequence++;
 313                 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
 314         }
 315 skip:
 316         usb_submit_urb(urb, GFP_ATOMIC);
 317 }
 318
 319 static int rtl2832_sdr_kill_urbs(struct rtl2832_sdr_dev *dev)
 320 {
 321         struct platform_device *pdev = dev->pdev;
 322         int i;
 323
 324         for (i = dev->urbs_submitted - 1; i >= 0; i--) {
 325                 dev_dbg(&pdev->dev, "kill urb=%d\n", i);
 326                 /* stop the URB */
 327                 usb_kill_urb(dev->urb_list[i]);
 328         }
 329         dev->urbs_submitted = 0;
 330
 331         return 0;
 332 }
 333
 334 static int rtl2832_sdr_submit_urbs(struct rtl2832_sdr_dev *dev)
 335 {
 336         struct platform_device *pdev = dev->pdev;
 337         int i, ret;
 338
 339         for (i = 0; i < dev->urbs_initialized; i++) {
 340                 dev_dbg(&pdev->dev, "submit urb=%d\n", i);
 341                 ret = usb_submit_urb(dev->urb_list[i], GFP_ATOMIC);
 342                 if (ret) {
 343                         dev_err(&pdev->dev,
 344                                 "Could not submit urb no. %d - get them all back\n",
 345                                 i);
 346                         rtl2832_sdr_kill_urbs(dev);
 347                         return ret;
 348                 }
 349                 dev->urbs_submitted++;
 350         }
 351
 352         return 0;
 353 }
 354
 355 static int rtl2832_sdr_free_stream_bufs(struct rtl2832_sdr_dev *dev)
 356 {
 357         struct platform_device *pdev = dev->pdev;
 358
 359         if (test_bit(URB_BUF, &dev->flags)) {
 360                 while (dev->buf_num) {
 361                         dev->buf_num--;
 362                         dev_dbg(&pdev->dev, "free buf=%d\n", dev->buf_num);
 363                         usb_free_coherent(dev->udev, dev->buf_size,
 364                                           dev->buf_list[dev->buf_num],
 365                                           dev->dma_addr[dev->buf_num]);
 366                 }
 367         }
 368         clear_bit(URB_BUF, &dev->flags);
 369
 370         return 0;
 371 }
 372
 373 static int rtl2832_sdr_alloc_stream_bufs(struct rtl2832_sdr_dev *dev)
 374 {
 375         struct platform_device *pdev = dev->pdev;
 376
 377         dev->buf_num = 0;
 378         dev->buf_size = BULK_BUFFER_SIZE;
 379
 380         dev_dbg(&pdev->dev, "all in all I will use %u bytes for streaming\n",
 381                 MAX_BULK_BUFS * BULK_BUFFER_SIZE);
 382
 383         for (dev->buf_num = 0; dev->buf_num < MAX_BULK_BUFS; dev->buf_num++) {
 384                 dev->buf_list[dev->buf_num] = usb_alloc_coherent(dev->udev,
 385                                 BULK_BUFFER_SIZE, GFP_ATOMIC,
 386                                 &dev->dma_addr[dev->buf_num]);
 387                 if (!dev->buf_list[dev->buf_num]) {
 388                         dev_dbg(&pdev->dev, "alloc buf=%d failed\n",
 389                                 dev->buf_num);
 390                         rtl2832_sdr_free_stream_bufs(dev);
 391                         return -ENOMEM;
 392                 }
 393
 394                 dev_dbg(&pdev->dev, "alloc buf=%d %p (dma %llu)\n",
 395                         dev->buf_num, dev->buf_list[dev->buf_num],
 396                         (long long)dev->dma_addr[dev->buf_num]);
 397                 set_bit(URB_BUF, &dev->flags);
 398         }
 399
 400         return 0;
 401 }
 402
 403 static int rtl2832_sdr_free_urbs(struct rtl2832_sdr_dev *dev)
 404 {
 405         struct platform_device *pdev = dev->pdev;
 406         int i;
 407
 408         rtl2832_sdr_kill_urbs(dev);
 409
 410         for (i = dev->urbs_initialized - 1; i >= 0; i--) {
 411                 if (dev->urb_list[i]) {
 412                         dev_dbg(&pdev->dev, "free urb=%d\n", i);
 413                         /* free the URBs */
 414                         usb_free_urb(dev->urb_list[i]);
 415                 }
 416         }
 417         dev->urbs_initialized = 0;
 418
 419         return 0;
 420 }
 421
 422 static int rtl2832_sdr_alloc_urbs(struct rtl2832_sdr_dev *dev)
 423 {
 424         struct platform_device *pdev = dev->pdev;
 425         int i, j;
 426
 427         /* allocate the URBs */
 428         for (i = 0; i < MAX_BULK_BUFS; i++) {
 429                 dev_dbg(&pdev->dev, "alloc urb=%d\n", i);
 430                 dev->urb_list[i] = usb_alloc_urb(0, GFP_ATOMIC);
 431                 if (!dev->urb_list[i]) {
 432                         dev_dbg(&pdev->dev, "failed\n");
 433                         for (j = 0; j < i; j++)
 434                                 usb_free_urb(dev->urb_list[j]);
 435                         return -ENOMEM;
 436                 }
 437                 usb_fill_bulk_urb(dev->urb_list[i],
 438                                 dev->udev,
 439                                 usb_rcvbulkpipe(dev->udev, 0x81),
 440                                 dev->buf_list[i],
 441                                 BULK_BUFFER_SIZE,
 442                                 rtl2832_sdr_urb_complete, dev);
 443
 444                 dev->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 445                 dev->urb_list[i]->transfer_dma = dev->dma_addr[i];
 446                 dev->urbs_initialized++;
 447         }
 448
 449         return 0;
 450 }
 451
 452 /* Must be called with vb_queue_lock hold */
 453 static void rtl2832_sdr_cleanup_queued_bufs(struct rtl2832_sdr_dev *dev)
 454 {
 455         struct platform_device *pdev = dev->pdev;
 456         unsigned long flags;
 457
 458         dev_dbg(&pdev->dev, "\n");
 459
 460         spin_lock_irqsave(&dev->queued_bufs_lock, flags);
 461         while (!list_empty(&dev->queued_bufs)) {
 462                 struct rtl2832_sdr_frame_buf *buf;
 463
 464                 buf = list_entry(dev->queued_bufs.next,
 465                                 struct rtl2832_sdr_frame_buf, list);
 466                 list_del(&buf->list);
 467                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 468         }
 469         spin_unlock_irqrestore(&dev->queued_bufs_lock, flags);
 470 }
 471
 472 static int rtl2832_sdr_querycap(struct file *file, void *fh,
 473                 struct v4l2_capability *cap)
 474 {
 475         struct rtl2832_sdr_dev *dev = video_drvdata(file);
 476         struct platform_device *pdev = dev->pdev;
 477
 478         dev_dbg(&pdev->dev, "\n");
 479
 480         strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
 481         strlcpy(cap->card, dev->vdev.name, sizeof(cap->card));
 482         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 483         cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
 484                         V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
 485         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 486         return 0;
 487 }
 488
 489 /* Videobuf2 operations */
 490 static int rtl2832_sdr_queue_setup(struct vb2_queue *vq,
 491                 const struct v4l2_format *fmt, unsigned int *nbuffers,
 492                 unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
 493 {
 494         struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vq);
 495         struct platform_device *pdev = dev->pdev;
 496
 497         dev_dbg(&pdev->dev, "nbuffers=%d\n", *nbuffers);
 498
 499         /* Need at least 8 buffers */
 500         if (vq->num_buffers + *nbuffers < 8)
 501                 *nbuffers = 8 - vq->num_buffers;
 502         *nplanes = 1;
 503         sizes[0] = PAGE_ALIGN(dev->buffersize);
 504         dev_dbg(&pdev->dev, "nbuffers=%d sizes[0]=%d\n", *nbuffers, sizes[0]);
 505         return 0;
 506 }
 507
 508 static int rtl2832_sdr_buf_prepare(struct vb2_buffer *vb)
 509 {
 510         struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 511
 512         /* Don't allow queing new buffers after device disconnection */
 513         if (!dev->udev)
 514                 return -ENODEV;
 515
 516         return 0;
 517 }
 518
 519 static void rtl2832_sdr_buf_queue(struct vb2_buffer *vb)
 520 {
 521         struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 522         struct rtl2832_sdr_frame_buf *buf =
 523                         container_of(vb, struct rtl2832_sdr_frame_buf, vb);
 524         unsigned long flags;
 525
 526         /* Check the device has not disconnected between prep and queuing */
 527         if (!dev->udev) {
 528                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 529                 return;
 530         }
 531
 532         spin_lock_irqsave(&dev->queued_bufs_lock, flags);
 533         list_add_tail(&buf->list, &dev->queued_bufs);
 534         spin_unlock_irqrestore(&dev->queued_bufs_lock, flags);
 535 }
 536
 537 static int rtl2832_sdr_set_adc(struct rtl2832_sdr_dev *dev)
 538 {
 539         struct platform_device *pdev = dev->pdev;
 540         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 541         struct dvb_frontend *fe = pdata->dvb_frontend;
 542         int ret;
 543         unsigned int f_sr, f_if;
 544         u8 buf[4], u8tmp1, u8tmp2;
 545         u64 u64tmp;
 546         u32 u32tmp;
 547
 548         dev_dbg(&pdev->dev, "f_adc=%u\n", dev->f_adc);
 549
 550         if (!test_bit(POWER_ON, &dev->flags))
 551                 return 0;
 552
 553         if (dev->f_adc == 0)
 554                 return 0;
 555
 556         f_sr = dev->f_adc;
 557
 558         ret = rtl2832_sdr_wr_regs(dev, 0x13e, "\x00\x00", 2);
 559         if (ret)
 560                 goto err;
 561
 562         ret = rtl2832_sdr_wr_regs(dev, 0x115, "\x00\x00\x00\x00", 4);
 563         if (ret)
 564                 goto err;
 565
 566         /* get IF from tuner */
 567         if (fe->ops.tuner_ops.get_if_frequency)
 568                 ret = fe->ops.tuner_ops.get_if_frequency(fe, &f_if);
 569         else
 570                 ret = -EINVAL;
 571
 572         if (ret)
 573                 goto err;
 574
 575         /* program IF */
 576         u64tmp = f_if % pdata->clk;
 577         u64tmp *= 0x400000;
 578         u64tmp = div_u64(u64tmp, pdata->clk);
 579         u64tmp = -u64tmp;
 580         u32tmp = u64tmp & 0x3fffff;
 581
 582         dev_dbg(&pdev->dev, "f_if=%u if_ctl=%08x\n", f_if, u32tmp);
 583
 584         buf[0] = (u32tmp >> 16) & 0xff;
 585         buf[1] = (u32tmp >>  8) & 0xff;
 586         buf[2] = (u32tmp >>  0) & 0xff;
 587
 588         ret = rtl2832_sdr_wr_regs(dev, 0x119, buf, 3);
 589         if (ret)
 590                 goto err;
 591
 592         /* BB / IF mode */
 593         /* POR: 0x1b1=0x1f, 0x008=0x0d, 0x006=0x80 */
 594         if (f_if) {
 595                 u8tmp1 = 0x1a; /* disable Zero-IF */
 596                 u8tmp2 = 0x8d; /* enable ADC I */
 597         } else {
 598                 u8tmp1 = 0x1b; /* enable Zero-IF, DC, IQ */
 599                 u8tmp2 = 0xcd; /* enable ADC I, ADC Q */
 600         }
 601
 602         ret = rtl2832_sdr_wr_reg(dev, 0x1b1, u8tmp1);
 603         if (ret)
 604                 goto err;
 605
 606         ret = rtl2832_sdr_wr_reg(dev, 0x008, u8tmp2);
 607         if (ret)
 608                 goto err;
 609
 610         ret = rtl2832_sdr_wr_reg(dev, 0x006, 0x80);
 611         if (ret)
 612                 goto err;
 613
 614         /* program sampling rate (resampling down) */
 615         u32tmp = div_u64(pdata->clk * 0x400000ULL, f_sr * 4U);
 616         u32tmp <<= 2;
 617         buf[0] = (u32tmp >> 24) & 0xff;
 618         buf[1] = (u32tmp >> 16) & 0xff;
 619         buf[2] = (u32tmp >>  8) & 0xff;
 620         buf[3] = (u32tmp >>  0) & 0xff;
 621         ret = rtl2832_sdr_wr_regs(dev, 0x19f, buf, 4);
 622         if (ret)
 623                 goto err;
 624
 625         /* low-pass filter */
 626         ret = rtl2832_sdr_wr_regs(dev, 0x11c,
 627                         "\xca\xdc\xd7\xd8\xe0\xf2\x0e\x35\x06\x50\x9c\x0d\x71\x11\x14\x71\x74\x19\x41\xa5",
 628                         20);
 629         if (ret)
 630                 goto err;
 631
 632         ret = rtl2832_sdr_wr_regs(dev, 0x017, "\x11\x10", 2);
 633         if (ret)
 634                 goto err;
 635
 636         /* mode */
 637         ret = rtl2832_sdr_wr_regs(dev, 0x019, "\x05", 1);
 638         if (ret)
 639                 goto err;
 640
 641         ret = rtl2832_sdr_wr_regs(dev, 0x01a, "\x1b\x16\x0d\x06\x01\xff", 6);
 642         if (ret)
 643                 goto err;
 644
 645         /* FSM */
 646         ret = rtl2832_sdr_wr_regs(dev, 0x192, "\x00\xf0\x0f", 3);
 647         if (ret)
 648                 goto err;
 649
 650         /* PID filter */
 651         ret = rtl2832_sdr_wr_regs(dev, 0x061, "\x60", 1);
 652         if (ret)
 653                 goto err;
 654
 655         /* used RF tuner based settings */
 656         switch (pdata->tuner) {
 657         case RTL2832_SDR_TUNER_E4000:
 658                 ret = rtl2832_sdr_wr_regs(dev, 0x112, "\x5a", 1);
 659                 ret = rtl2832_sdr_wr_regs(dev, 0x102, "\x40", 1);
 660                 ret = rtl2832_sdr_wr_regs(dev, 0x103, "\x5a", 1);
 661                 ret = rtl2832_sdr_wr_regs(dev, 0x1c7, "\x30", 1);
 662                 ret = rtl2832_sdr_wr_regs(dev, 0x104, "\xd0", 1);
 663                 ret = rtl2832_sdr_wr_regs(dev, 0x105, "\xbe", 1);
 664                 ret = rtl2832_sdr_wr_regs(dev, 0x1c8, "\x18", 1);
 665                 ret = rtl2832_sdr_wr_regs(dev, 0x106, "\x35", 1);
 666                 ret = rtl2832_sdr_wr_regs(dev, 0x1c9, "\x21", 1);
 667                 ret = rtl2832_sdr_wr_regs(dev, 0x1ca, "\x21", 1);
 668                 ret = rtl2832_sdr_wr_regs(dev, 0x1cb, "\x00", 1);
 669                 ret = rtl2832_sdr_wr_regs(dev, 0x107, "\x40", 1);
 670                 ret = rtl2832_sdr_wr_regs(dev, 0x1cd, "\x10", 1);
 671                 ret = rtl2832_sdr_wr_regs(dev, 0x1ce, "\x10", 1);
 672                 ret = rtl2832_sdr_wr_regs(dev, 0x108, "\x80", 1);
 673                 ret = rtl2832_sdr_wr_regs(dev, 0x109, "\x7f", 1);
 674                 ret = rtl2832_sdr_wr_regs(dev, 0x10a, "\x80", 1);
 675                 ret = rtl2832_sdr_wr_regs(dev, 0x10b, "\x7f", 1);
 676                 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
 677                 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
 678                 ret = rtl2832_sdr_wr_regs(dev, 0x011, "\xd4", 1);
 679                 ret = rtl2832_sdr_wr_regs(dev, 0x1e5, "\xf0", 1);
 680                 ret = rtl2832_sdr_wr_regs(dev, 0x1d9, "\x00", 1);
 681                 ret = rtl2832_sdr_wr_regs(dev, 0x1db, "\x00", 1);
 682                 ret = rtl2832_sdr_wr_regs(dev, 0x1dd, "\x14", 1);
 683                 ret = rtl2832_sdr_wr_regs(dev, 0x1de, "\xec", 1);
 684                 ret = rtl2832_sdr_wr_regs(dev, 0x1d8, "\x0c", 1);
 685                 ret = rtl2832_sdr_wr_regs(dev, 0x1e6, "\x02", 1);
 686                 ret = rtl2832_sdr_wr_regs(dev, 0x1d7, "\x09", 1);
 687                 ret = rtl2832_sdr_wr_regs(dev, 0x00d, "\x83", 1);
 688                 ret = rtl2832_sdr_wr_regs(dev, 0x010, "\x49", 1);
 689                 ret = rtl2832_sdr_wr_regs(dev, 0x00d, "\x87", 1);
 690                 ret = rtl2832_sdr_wr_regs(dev, 0x00d, "\x85", 1);
 691                 ret = rtl2832_sdr_wr_regs(dev, 0x013, "\x02", 1);
 692                 break;
 693         case RTL2832_SDR_TUNER_FC0012:
 694         case RTL2832_SDR_TUNER_FC0013:
 695                 ret = rtl2832_sdr_wr_regs(dev, 0x112, "\x5a", 1);
 696                 ret = rtl2832_sdr_wr_regs(dev, 0x102, "\x40", 1);
 697                 ret = rtl2832_sdr_wr_regs(dev, 0x103, "\x5a", 1);
 698                 ret = rtl2832_sdr_wr_regs(dev, 0x1c7, "\x2c", 1);
 699                 ret = rtl2832_sdr_wr_regs(dev, 0x104, "\xcc", 1);
 700                 ret = rtl2832_sdr_wr_regs(dev, 0x105, "\xbe", 1);
 701                 ret = rtl2832_sdr_wr_regs(dev, 0x1c8, "\x16", 1);
 702                 ret = rtl2832_sdr_wr_regs(dev, 0x106, "\x35", 1);
 703                 ret = rtl2832_sdr_wr_regs(dev, 0x1c9, "\x21", 1);
 704                 ret = rtl2832_sdr_wr_regs(dev, 0x1ca, "\x21", 1);
 705                 ret = rtl2832_sdr_wr_regs(dev, 0x1cb, "\x00", 1);
 706                 ret = rtl2832_sdr_wr_regs(dev, 0x107, "\x40", 1);
 707                 ret = rtl2832_sdr_wr_regs(dev, 0x1cd, "\x10", 1);
 708                 ret = rtl2832_sdr_wr_regs(dev, 0x1ce, "\x10", 1);
 709                 ret = rtl2832_sdr_wr_regs(dev, 0x108, "\x80", 1);
 710                 ret = rtl2832_sdr_wr_regs(dev, 0x109, "\x7f", 1);
 711                 ret = rtl2832_sdr_wr_regs(dev, 0x10a, "\x80", 1);
 712                 ret = rtl2832_sdr_wr_regs(dev, 0x10b, "\x7f", 1);
 713                 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
 714                 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
 715                 ret = rtl2832_sdr_wr_regs(dev, 0x011, "\xe9\xbf", 2);
 716                 ret = rtl2832_sdr_wr_regs(dev, 0x1e5, "\xf0", 1);
 717                 ret = rtl2832_sdr_wr_regs(dev, 0x1d9, "\x00", 1);
 718                 ret = rtl2832_sdr_wr_regs(dev, 0x1db, "\x00", 1);
 719                 ret = rtl2832_sdr_wr_regs(dev, 0x1dd, "\x11", 1);
 720                 ret = rtl2832_sdr_wr_regs(dev, 0x1de, "\xef", 1);
 721                 ret = rtl2832_sdr_wr_regs(dev, 0x1d8, "\x0c", 1);
 722                 ret = rtl2832_sdr_wr_regs(dev, 0x1e6, "\x02", 1);
 723                 ret = rtl2832_sdr_wr_regs(dev, 0x1d7, "\x09", 1);
 724                 break;
 725         case RTL2832_SDR_TUNER_R820T:
 726         case RTL2832_SDR_TUNER_R828D:
 727                 ret = rtl2832_sdr_wr_regs(dev, 0x112, "\x5a", 1);
 728                 ret = rtl2832_sdr_wr_regs(dev, 0x102, "\x40", 1);
 729                 ret = rtl2832_sdr_wr_regs(dev, 0x115, "\x01", 1);
 730                 ret = rtl2832_sdr_wr_regs(dev, 0x103, "\x80", 1);
 731                 ret = rtl2832_sdr_wr_regs(dev, 0x1c7, "\x24", 1);
 732                 ret = rtl2832_sdr_wr_regs(dev, 0x104, "\xcc", 1);
 733                 ret = rtl2832_sdr_wr_regs(dev, 0x105, "\xbe", 1);
 734                 ret = rtl2832_sdr_wr_regs(dev, 0x1c8, "\x14", 1);
 735                 ret = rtl2832_sdr_wr_regs(dev, 0x106, "\x35", 1);
 736                 ret = rtl2832_sdr_wr_regs(dev, 0x1c9, "\x21", 1);
 737                 ret = rtl2832_sdr_wr_regs(dev, 0x1ca, "\x21", 1);
 738                 ret = rtl2832_sdr_wr_regs(dev, 0x1cb, "\x00", 1);
 739                 ret = rtl2832_sdr_wr_regs(dev, 0x107, "\x40", 1);
 740                 ret = rtl2832_sdr_wr_regs(dev, 0x1cd, "\x10", 1);
 741                 ret = rtl2832_sdr_wr_regs(dev, 0x1ce, "\x10", 1);
 742                 ret = rtl2832_sdr_wr_regs(dev, 0x108, "\x80", 1);
 743                 ret = rtl2832_sdr_wr_regs(dev, 0x109, "\x7f", 1);
 744                 ret = rtl2832_sdr_wr_regs(dev, 0x10a, "\x80", 1);
 745                 ret = rtl2832_sdr_wr_regs(dev, 0x10b, "\x7f", 1);
 746                 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
 747                 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
 748                 ret = rtl2832_sdr_wr_regs(dev, 0x011, "\xf4", 1);
 749                 break;
 750         case RTL2832_SDR_TUNER_FC2580:
 751                 ret = rtl2832_sdr_wr_regs(dev, 0x112, "\x39", 1);
 752                 ret = rtl2832_sdr_wr_regs(dev, 0x102, "\x40", 1);
 753                 ret = rtl2832_sdr_wr_regs(dev, 0x103, "\x5a", 1);
 754                 ret = rtl2832_sdr_wr_regs(dev, 0x1c7, "\x2c", 1);
 755                 ret = rtl2832_sdr_wr_regs(dev, 0x104, "\xcc", 1);
 756                 ret = rtl2832_sdr_wr_regs(dev, 0x105, "\xbe", 1);
 757                 ret = rtl2832_sdr_wr_regs(dev, 0x1c8, "\x16", 1);
 758                 ret = rtl2832_sdr_wr_regs(dev, 0x106, "\x35", 1);
 759                 ret = rtl2832_sdr_wr_regs(dev, 0x1c9, "\x21", 1);
 760                 ret = rtl2832_sdr_wr_regs(dev, 0x1ca, "\x21", 1);
 761                 ret = rtl2832_sdr_wr_regs(dev, 0x1cb, "\x00", 1);
 762                 ret = rtl2832_sdr_wr_regs(dev, 0x107, "\x40", 1);
 763                 ret = rtl2832_sdr_wr_regs(dev, 0x1cd, "\x10", 1);
 764                 ret = rtl2832_sdr_wr_regs(dev, 0x1ce, "\x10", 1);
 765                 ret = rtl2832_sdr_wr_regs(dev, 0x108, "\x80", 1);
 766                 ret = rtl2832_sdr_wr_regs(dev, 0x109, "\x7f", 1);
 767                 ret = rtl2832_sdr_wr_regs(dev, 0x10a, "\x9c", 1);
 768                 ret = rtl2832_sdr_wr_regs(dev, 0x10b, "\x7f", 1);
 769                 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
 770                 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
 771                 ret = rtl2832_sdr_wr_regs(dev, 0x011, "\xe9\xf4", 2);
 772                 break;
 773         default:
 774                 dev_notice(&pdev->dev, "Unsupported tuner\n");
 775         }
 776
 777         /* software reset */
 778         ret = rtl2832_sdr_wr_reg_mask(dev, 0x101, 0x04, 0x04);
 779         if (ret)
 780                 goto err;
 781
 782         ret = rtl2832_sdr_wr_reg_mask(dev, 0x101, 0x00, 0x04);
 783         if (ret)
 784                 goto err;
 785 err:
 786         return ret;
 787 };
 788
 789 static void rtl2832_sdr_unset_adc(struct rtl2832_sdr_dev *dev)
 790 {
 791         struct platform_device *pdev = dev->pdev;
 792         int ret;
 793
 794         dev_dbg(&pdev->dev, "\n");
 795
 796         /* PID filter */
 797         ret = rtl2832_sdr_wr_regs(dev, 0x061, "\xe0", 1);
 798         if (ret)
 799                 goto err;
 800
 801         /* mode */
 802         ret = rtl2832_sdr_wr_regs(dev, 0x019, "\x20", 1);
 803         if (ret)
 804                 goto err;
 805
 806         ret = rtl2832_sdr_wr_regs(dev, 0x017, "\x11\x10", 2);
 807         if (ret)
 808                 goto err;
 809
 810         /* FSM */
 811         ret = rtl2832_sdr_wr_regs(dev, 0x192, "\x00\x0f\xff", 3);
 812         if (ret)
 813                 goto err;
 814
 815         ret = rtl2832_sdr_wr_regs(dev, 0x13e, "\x40\x00", 2);
 816         if (ret)
 817                 goto err;
 818
 819         ret = rtl2832_sdr_wr_regs(dev, 0x115, "\x06\x3f\xce\xcc", 4);
 820         if (ret)
 821                 goto err;
 822 err:
 823         return;
 824 };
 825
 826 static int rtl2832_sdr_set_tuner_freq(struct rtl2832_sdr_dev *dev)
 827 {
 828         struct platform_device *pdev = dev->pdev;
 829         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 830         struct dvb_frontend *fe = pdata->dvb_frontend;
 831         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 832         struct v4l2_ctrl *bandwidth_auto;
 833         struct v4l2_ctrl *bandwidth;
 834
 835         /*
 836          * tuner RF (Hz)
 837          */
 838         if (dev->f_tuner == 0)
 839                 return 0;
 840
 841         /*
 842          * bandwidth (Hz)
 843          */
 844         bandwidth_auto = v4l2_ctrl_find(&dev->hdl,
 845                                         V4L2_CID_RF_TUNER_BANDWIDTH_AUTO);
 846         bandwidth = v4l2_ctrl_find(&dev->hdl, V4L2_CID_RF_TUNER_BANDWIDTH);
 847         if (v4l2_ctrl_g_ctrl(bandwidth_auto)) {
 848                 c->bandwidth_hz = dev->f_adc;
 849                 v4l2_ctrl_s_ctrl(bandwidth, dev->f_adc);
 850         } else {
 851                 c->bandwidth_hz = v4l2_ctrl_g_ctrl(bandwidth);
 852         }
 853
 854         c->frequency = dev->f_tuner;
 855         c->delivery_system = SYS_DVBT;
 856
 857         dev_dbg(&pdev->dev, "frequency=%u bandwidth=%d\n",
 858                 c->frequency, c->bandwidth_hz);
 859
 860         if (!test_bit(POWER_ON, &dev->flags))
 861                 return 0;
 862
 863         if (!V4L2_SUBDEV_HAS_OP(dev->v4l2_subdev, tuner, s_frequency)) {
 864                 if (fe->ops.tuner_ops.set_params)
 865                         fe->ops.tuner_ops.set_params(fe);
 866         }
 867
 868         return 0;
 869 };
 870
 871 static int rtl2832_sdr_set_tuner(struct rtl2832_sdr_dev *dev)
 872 {
 873         struct platform_device *pdev = dev->pdev;
 874         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 875         struct dvb_frontend *fe = pdata->dvb_frontend;
 876
 877         dev_dbg(&pdev->dev, "\n");
 878
 879         if (fe->ops.tuner_ops.init)
 880                 fe->ops.tuner_ops.init(fe);
 881
 882         return 0;
 883 };
 884
 885 static void rtl2832_sdr_unset_tuner(struct rtl2832_sdr_dev *dev)
 886 {
 887         struct platform_device *pdev = dev->pdev;
 888         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 889         struct dvb_frontend *fe = pdata->dvb_frontend;
 890
 891         dev_dbg(&pdev->dev, "\n");
 892
 893         if (fe->ops.tuner_ops.sleep)
 894                 fe->ops.tuner_ops.sleep(fe);
 895
 896         return;
 897 };
 898
 899 static int rtl2832_sdr_start_streaming(struct vb2_queue *vq, unsigned int count)
 900 {
 901         struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vq);
 902         struct platform_device *pdev = dev->pdev;
 903         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 904         struct dvb_usb_device *d = pdata->dvb_usb_device;
 905         int ret;
 906
 907         dev_dbg(&pdev->dev, "\n");
 908
 909         if (!dev->udev)
 910                 return -ENODEV;
 911
 912         if (mutex_lock_interruptible(&dev->v4l2_lock))
 913                 return -ERESTARTSYS;
 914
 915         if (d->props->power_ctrl)
 916                 d->props->power_ctrl(d, 1);
 917
 918         /* enable ADC */
 919         if (d->props->frontend_ctrl)
 920                 d->props->frontend_ctrl(pdata->dvb_frontend, 1);
 921
 922         set_bit(POWER_ON, &dev->flags);
 923
 924         /* wake-up tuner */
 925         if (V4L2_SUBDEV_HAS_OP(dev->v4l2_subdev, core, s_power))
 926                 ret = v4l2_subdev_call(dev->v4l2_subdev, core, s_power, 1);
 927         else
 928                 ret = rtl2832_sdr_set_tuner(dev);
 929         if (ret)
 930                 goto err;
 931
 932         ret = rtl2832_sdr_set_tuner_freq(dev);
 933         if (ret)
 934                 goto err;
 935
 936         ret = rtl2832_sdr_set_adc(dev);
 937         if (ret)
 938                 goto err;
 939
 940         ret = rtl2832_sdr_alloc_stream_bufs(dev);
 941         if (ret)
 942                 goto err;
 943
 944         ret = rtl2832_sdr_alloc_urbs(dev);
 945         if (ret)
 946                 goto err;
 947
 948         dev->sequence = 0;
 949
 950         ret = rtl2832_sdr_submit_urbs(dev);
 951         if (ret)
 952                 goto err;
 953
 954 err:
 955         mutex_unlock(&dev->v4l2_lock);
 956
 957         return ret;
 958 }
 959
 960 static void rtl2832_sdr_stop_streaming(struct vb2_queue *vq)
 961 {
 962         struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vq);
 963         struct platform_device *pdev = dev->pdev;
 964         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
 965         struct dvb_usb_device *d = pdata->dvb_usb_device;
 966
 967         dev_dbg(&pdev->dev, "\n");
 968
 969         mutex_lock(&dev->v4l2_lock);
 970
 971         rtl2832_sdr_kill_urbs(dev);
 972         rtl2832_sdr_free_urbs(dev);
 973         rtl2832_sdr_free_stream_bufs(dev);
 974         rtl2832_sdr_cleanup_queued_bufs(dev);
 975         rtl2832_sdr_unset_adc(dev);
 976
 977         /* sleep tuner */
 978         if (V4L2_SUBDEV_HAS_OP(dev->v4l2_subdev, core, s_power))
 979                 v4l2_subdev_call(dev->v4l2_subdev, core, s_power, 0);
 980         else
 981                 rtl2832_sdr_unset_tuner(dev);
 982
 983         clear_bit(POWER_ON, &dev->flags);
 984
 985         /* disable ADC */
 986         if (d->props->frontend_ctrl)
 987                 d->props->frontend_ctrl(pdata->dvb_frontend, 0);
 988
 989         if (d->props->power_ctrl)
 990                 d->props->power_ctrl(d, 0);
 991
 992         mutex_unlock(&dev->v4l2_lock);
 993 }
 994
 995 static struct vb2_ops rtl2832_sdr_vb2_ops = {
 996         .queue_setup            = rtl2832_sdr_queue_setup,
 997         .buf_prepare            = rtl2832_sdr_buf_prepare,
 998         .buf_queue              = rtl2832_sdr_buf_queue,
 999         .start_streaming        = rtl2832_sdr_start_streaming,
1000         .stop_streaming         = rtl2832_sdr_stop_streaming,
1001         .wait_prepare           = vb2_ops_wait_prepare,
1002         .wait_finish            = vb2_ops_wait_finish,
1003 };
1004
1005 static int rtl2832_sdr_g_tuner(struct file *file, void *priv,
1006                 struct v4l2_tuner *v)
1007 {
1008         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1009         struct platform_device *pdev = dev->pdev;
1010         int ret;
1011
1012         dev_dbg(&pdev->dev, "index=%d type=%d\n", v->index, v->type);
1013
1014         if (v->index == 0) {
1015                 strlcpy(v->name, "ADC: Realtek RTL2832", sizeof(v->name));
1016                 v->type = V4L2_TUNER_ADC;
1017                 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1018                 v->rangelow =   300000;
1019                 v->rangehigh = 3200000;
1020                 ret = 0;
1021         } else if (v->index == 1 &&
1022                    V4L2_SUBDEV_HAS_OP(dev->v4l2_subdev, tuner, g_tuner)) {
1023                 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, g_tuner, v);
1024         } else if (v->index == 1) {
1025                 strlcpy(v->name, "RF: <unknown>", sizeof(v->name));
1026                 v->type = V4L2_TUNER_RF;
1027                 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1028                 v->rangelow =    50000000;
1029                 v->rangehigh = 2000000000;
1030                 ret = 0;
1031         } else {
1032                 ret = -EINVAL;
1033         }
1034         return ret;
1035 }
1036
1037 static int rtl2832_sdr_s_tuner(struct file *file, void *priv,
1038                 const struct v4l2_tuner *v)
1039 {
1040         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1041         struct platform_device *pdev = dev->pdev;
1042         int ret;
1043
1044         dev_dbg(&pdev->dev, "\n");
1045
1046         if (v->index == 0) {
1047                 ret = 0;
1048         } else if (v->index == 1 &&
1049                    V4L2_SUBDEV_HAS_OP(dev->v4l2_subdev, tuner, s_tuner)) {
1050                 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, s_tuner, v);
1051         } else if (v->index == 1) {
1052                 ret = 0;
1053         } else {
1054                 ret = -EINVAL;
1055         }
1056         return ret;
1057 }
1058
1059 static int rtl2832_sdr_enum_freq_bands(struct file *file, void *priv,
1060                 struct v4l2_frequency_band *band)
1061 {
1062         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1063         struct platform_device *pdev = dev->pdev;
1064         int ret;
1065
1066         dev_dbg(&pdev->dev, "tuner=%d type=%d index=%d\n",
1067                 band->tuner, band->type, band->index);
1068
1069         if (band->tuner == 0) {
1070                 if (band->index >= ARRAY_SIZE(bands_adc))
1071                         return -EINVAL;
1072
1073                 *band = bands_adc[band->index];
1074                 ret = 0;
1075         } else if (band->tuner == 1 &&
1076                    V4L2_SUBDEV_HAS_OP(dev->v4l2_subdev, tuner, enum_freq_bands)) {
1077                 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, enum_freq_bands, band);
1078         } else if (band->tuner == 1) {
1079                 if (band->index >= ARRAY_SIZE(bands_fm))
1080                         return -EINVAL;
1081
1082                 *band = bands_fm[band->index];
1083                 ret = 0;
1084         } else {
1085                 ret = -EINVAL;
1086         }
1087         return ret;
1088 }
1089
1090 static int rtl2832_sdr_g_frequency(struct file *file, void *priv,
1091                 struct v4l2_frequency *f)
1092 {
1093         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1094         struct platform_device *pdev = dev->pdev;
1095         int ret;
1096
1097         dev_dbg(&pdev->dev, "tuner=%d type=%d\n", f->tuner, f->type);
1098
1099         if (f->tuner == 0) {
1100                 f->frequency = dev->f_adc;
1101                 f->type = V4L2_TUNER_ADC;
1102                 ret = 0;
1103         } else if (f->tuner == 1 &&
1104                    V4L2_SUBDEV_HAS_OP(dev->v4l2_subdev, tuner, g_frequency)) {
1105                 f->type = V4L2_TUNER_RF;
1106                 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, g_frequency, f);
1107         } else if (f->tuner == 1) {
1108                 f->frequency = dev->f_tuner;
1109                 f->type = V4L2_TUNER_RF;
1110                 ret = 0;
1111         } else {
1112                 ret = -EINVAL;
1113         }
1114         return ret;
1115 }
1116
1117 static int rtl2832_sdr_s_frequency(struct file *file, void *priv,
1118                 const struct v4l2_frequency *f)
1119 {
1120         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1121         struct platform_device *pdev = dev->pdev;
1122         int ret, band;
1123
1124         dev_dbg(&pdev->dev, "tuner=%d type=%d frequency=%u\n",
1125                 f->tuner, f->type, f->frequency);
1126
1127         /* ADC band midpoints */
1128         #define BAND_ADC_0 ((bands_adc[0].rangehigh + bands_adc[1].rangelow) / 2)
1129         #define BAND_ADC_1 ((bands_adc[1].rangehigh + bands_adc[2].rangelow) / 2)
1130
1131         if (f->tuner == 0 && f->type == V4L2_TUNER_ADC) {
1132                 if (f->frequency < BAND_ADC_0)
1133                         band = 0;
1134                 else if (f->frequency < BAND_ADC_1)
1135                         band = 1;
1136                 else
1137                         band = 2;
1138
1139                 dev->f_adc = clamp_t(unsigned int, f->frequency,
1140                                      bands_adc[band].rangelow,
1141                                      bands_adc[band].rangehigh);
1142
1143                 dev_dbg(&pdev->dev, "ADC frequency=%u Hz\n", dev->f_adc);
1144                 ret = rtl2832_sdr_set_adc(dev);
1145         } else if (f->tuner == 1 &&
1146                    V4L2_SUBDEV_HAS_OP(dev->v4l2_subdev, tuner, s_frequency)) {
1147                 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, s_frequency, f);
1148         } else if (f->tuner == 1) {
1149                 dev->f_tuner = clamp_t(unsigned int, f->frequency,
1150                                 bands_fm[0].rangelow,
1151                                 bands_fm[0].rangehigh);
1152                 dev_dbg(&pdev->dev, "RF frequency=%u Hz\n", f->frequency);
1153
1154                 ret = rtl2832_sdr_set_tuner_freq(dev);
1155         } else {
1156                 ret = -EINVAL;
1157         }
1158         return ret;
1159 }
1160
1161 static int rtl2832_sdr_enum_fmt_sdr_cap(struct file *file, void *priv,
1162                 struct v4l2_fmtdesc *f)
1163 {
1164         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1165         struct platform_device *pdev = dev->pdev;
1166
1167         dev_dbg(&pdev->dev, "\n");
1168
1169         if (f->index >= dev->num_formats)
1170                 return -EINVAL;
1171
1172         strlcpy(f->description, formats[f->index].name, sizeof(f->description));
1173         f->pixelformat = formats[f->index].pixelformat;
1174
1175         return 0;
1176 }
1177
1178 static int rtl2832_sdr_g_fmt_sdr_cap(struct file *file, void *priv,
1179                 struct v4l2_format *f)
1180 {
1181         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1182         struct platform_device *pdev = dev->pdev;
1183
1184         dev_dbg(&pdev->dev, "\n");
1185
1186         f->fmt.sdr.pixelformat = dev->pixelformat;
1187         f->fmt.sdr.buffersize = dev->buffersize;
1188
1189         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1190
1191         return 0;
1192 }
1193
1194 static int rtl2832_sdr_s_fmt_sdr_cap(struct file *file, void *priv,
1195                 struct v4l2_format *f)
1196 {
1197         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1198         struct platform_device *pdev = dev->pdev;
1199         struct vb2_queue *q = &dev->vb_queue;
1200         int i;
1201
1202         dev_dbg(&pdev->dev, "pixelformat fourcc %4.4s\n",
1203                 (char *)&f->fmt.sdr.pixelformat);
1204
1205         if (vb2_is_busy(q))
1206                 return -EBUSY;
1207
1208         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1209         for (i = 0; i < dev->num_formats; i++) {
1210                 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
1211                         dev->pixelformat = formats[i].pixelformat;
1212                         dev->buffersize = formats[i].buffersize;
1213                         f->fmt.sdr.buffersize = formats[i].buffersize;
1214                         return 0;
1215                 }
1216         }
1217
1218         dev->pixelformat = formats[0].pixelformat;
1219         dev->buffersize = formats[0].buffersize;
1220         f->fmt.sdr.pixelformat = formats[0].pixelformat;
1221         f->fmt.sdr.buffersize = formats[0].buffersize;
1222
1223         return 0;
1224 }
1225
1226 static int rtl2832_sdr_try_fmt_sdr_cap(struct file *file, void *priv,
1227                 struct v4l2_format *f)
1228 {
1229         struct rtl2832_sdr_dev *dev = video_drvdata(file);
1230         struct platform_device *pdev = dev->pdev;
1231         int i;
1232
1233         dev_dbg(&pdev->dev, "pixelformat fourcc %4.4s\n",
1234                 (char *)&f->fmt.sdr.pixelformat);
1235
1236         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1237         for (i = 0; i < dev->num_formats; i++) {
1238                 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
1239                         f->fmt.sdr.buffersize = formats[i].buffersize;
1240                         return 0;
1241                 }
1242         }
1243
1244         f->fmt.sdr.pixelformat = formats[0].pixelformat;
1245         f->fmt.sdr.buffersize = formats[0].buffersize;
1246
1247         return 0;
1248 }
1249
1250 static const struct v4l2_ioctl_ops rtl2832_sdr_ioctl_ops = {
1251         .vidioc_querycap          = rtl2832_sdr_querycap,
1252
1253         .vidioc_enum_fmt_sdr_cap  = rtl2832_sdr_enum_fmt_sdr_cap,
1254         .vidioc_g_fmt_sdr_cap     = rtl2832_sdr_g_fmt_sdr_cap,
1255         .vidioc_s_fmt_sdr_cap     = rtl2832_sdr_s_fmt_sdr_cap,
1256         .vidioc_try_fmt_sdr_cap   = rtl2832_sdr_try_fmt_sdr_cap,
1257
1258         .vidioc_reqbufs           = vb2_ioctl_reqbufs,
1259         .vidioc_create_bufs       = vb2_ioctl_create_bufs,
1260         .vidioc_prepare_buf       = vb2_ioctl_prepare_buf,
1261         .vidioc_querybuf          = vb2_ioctl_querybuf,
1262         .vidioc_qbuf              = vb2_ioctl_qbuf,
1263         .vidioc_dqbuf             = vb2_ioctl_dqbuf,
1264
1265         .vidioc_streamon          = vb2_ioctl_streamon,
1266         .vidioc_streamoff         = vb2_ioctl_streamoff,
1267
1268         .vidioc_g_tuner           = rtl2832_sdr_g_tuner,
1269         .vidioc_s_tuner           = rtl2832_sdr_s_tuner,
1270
1271         .vidioc_enum_freq_bands   = rtl2832_sdr_enum_freq_bands,
1272         .vidioc_g_frequency       = rtl2832_sdr_g_frequency,
1273         .vidioc_s_frequency       = rtl2832_sdr_s_frequency,
1274
1275         .vidioc_subscribe_event   = v4l2_ctrl_subscribe_event,
1276         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1277         .vidioc_log_status        = v4l2_ctrl_log_status,
1278 };
1279
1280 static const struct v4l2_file_operations rtl2832_sdr_fops = {
1281         .owner                    = THIS_MODULE,
1282         .open                     = v4l2_fh_open,
1283         .release                  = vb2_fop_release,
1284         .read                     = vb2_fop_read,
1285         .poll                     = vb2_fop_poll,
1286         .mmap                     = vb2_fop_mmap,
1287         .unlocked_ioctl           = video_ioctl2,
1288 };
1289
1290 static struct video_device rtl2832_sdr_template = {
1291         .name                     = "Realtek RTL2832 SDR",
1292         .release                  = video_device_release_empty,
1293         .fops                     = &rtl2832_sdr_fops,
1294         .ioctl_ops                = &rtl2832_sdr_ioctl_ops,
1295 };
1296
1297 static int rtl2832_sdr_s_ctrl(struct v4l2_ctrl *ctrl)
1298 {
1299         struct rtl2832_sdr_dev *dev =
1300                         container_of(ctrl->handler, struct rtl2832_sdr_dev,
1301                                         hdl);
1302         struct platform_device *pdev = dev->pdev;
1303         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
1304         struct dvb_frontend *fe = pdata->dvb_frontend;
1305         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1306         int ret;
1307
1308         dev_dbg(&pdev->dev, "id=%d name=%s val=%d min=%lld max=%lld step=%lld\n",
1309                 ctrl->id, ctrl->name, ctrl->val, ctrl->minimum, ctrl->maximum,
1310                 ctrl->step);
1311
1312         switch (ctrl->id) {
1313         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1314         case V4L2_CID_RF_TUNER_BANDWIDTH:
1315                 /* TODO: these controls should be moved to tuner drivers */
1316                 if (dev->bandwidth_auto->val) {
1317                         /* Round towards the closest legal value */
1318                         s32 val = dev->f_adc + div_u64(dev->bandwidth->step, 2);
1319                         u32 offset;
1320
1321                         val = clamp_t(s32, val, dev->bandwidth->minimum,
1322                                       dev->bandwidth->maximum);
1323                         offset = val - dev->bandwidth->minimum;
1324                         offset = dev->bandwidth->step *
1325                                 div_u64(offset, dev->bandwidth->step);
1326                         dev->bandwidth->val = dev->bandwidth->minimum + offset;
1327                 }
1328                 c->bandwidth_hz = dev->bandwidth->val;
1329
1330                 if (!test_bit(POWER_ON, &dev->flags))
1331                         return 0;
1332
1333                 if (fe->ops.tuner_ops.set_params)
1334                         ret = fe->ops.tuner_ops.set_params(fe);
1335                 else
1336                         ret = 0;
1337                 break;
1338         default:
1339                 ret = -EINVAL;
1340         }
1341
1342         return ret;
1343 }
1344
1345 static const struct v4l2_ctrl_ops rtl2832_sdr_ctrl_ops = {
1346         .s_ctrl = rtl2832_sdr_s_ctrl,
1347 };
1348
1349 static void rtl2832_sdr_video_release(struct v4l2_device *v)
1350 {
1351         struct rtl2832_sdr_dev *dev =
1352                         container_of(v, struct rtl2832_sdr_dev, v4l2_dev);
1353         struct platform_device *pdev = dev->pdev;
1354
1355         dev_dbg(&pdev->dev, "\n");
1356
1357         v4l2_ctrl_handler_free(&dev->hdl);
1358         v4l2_device_unregister(&dev->v4l2_dev);
1359         kfree(dev);
1360 }
1361
1362 /* Platform driver interface */
1363 static int rtl2832_sdr_probe(struct platform_device *pdev)
1364 {
1365         struct rtl2832_sdr_dev *dev;
1366         struct rtl2832_sdr_platform_data *pdata = pdev->dev.platform_data;
1367         const struct v4l2_ctrl_ops *ops = &rtl2832_sdr_ctrl_ops;
1368         struct v4l2_subdev *subdev;
1369         int ret;
1370
1371         dev_dbg(&pdev->dev, "\n");
1372
1373         if (!pdata) {
1374                 dev_err(&pdev->dev, "Cannot proceed without platform data\n");
1375                 ret = -EINVAL;
1376                 goto err;
1377         }
1378         if (!pdev->dev.parent->driver) {
1379                 dev_dbg(&pdev->dev, "No parent device\n");
1380                 ret = -EINVAL;
1381                 goto err;
1382         }
1383         /* try to refcount host drv since we are the consumer */
1384         if (!try_module_get(pdev->dev.parent->driver->owner)) {
1385                 dev_err(&pdev->dev, "Refcount fail");
1386                 ret = -EINVAL;
1387                 goto err;
1388         }
1389         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1390         if (dev == NULL) {
1391                 ret = -ENOMEM;
1392                 goto err_module_put;
1393         }
1394
1395         /* setup the state */
1396         subdev = pdata->v4l2_subdev;
1397         dev->v4l2_subdev = pdata->v4l2_subdev;
1398         dev->pdev = pdev;
1399         dev->udev = pdata->dvb_usb_device->udev;
1400         dev->f_adc = bands_adc[0].rangelow;
1401         dev->f_tuner = bands_fm[0].rangelow;
1402         dev->pixelformat = formats[0].pixelformat;
1403         dev->buffersize = formats[0].buffersize;
1404         dev->num_formats = NUM_FORMATS;
1405         if (!rtl2832_sdr_emulated_fmt)
1406                 dev->num_formats -= 1;
1407
1408         mutex_init(&dev->v4l2_lock);
1409         mutex_init(&dev->vb_queue_lock);
1410         spin_lock_init(&dev->queued_bufs_lock);
1411         INIT_LIST_HEAD(&dev->queued_bufs);
1412
1413         /* Init videobuf2 queue structure */
1414         dev->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1415         dev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1416         dev->vb_queue.drv_priv = dev;
1417         dev->vb_queue.buf_struct_size = sizeof(struct rtl2832_sdr_frame_buf);
1418         dev->vb_queue.ops = &rtl2832_sdr_vb2_ops;
1419         dev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1420         dev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1421         ret = vb2_queue_init(&dev->vb_queue);
1422         if (ret) {
1423                 dev_err(&pdev->dev, "Could not initialize vb2 queue\n");
1424                 goto err_kfree;
1425         }
1426
1427         /* Register controls */
1428         switch (pdata->tuner) {
1429         case RTL2832_SDR_TUNER_E4000:
1430                 v4l2_ctrl_handler_init(&dev->hdl, 9);
1431                 if (subdev)
1432                         v4l2_ctrl_add_handler(&dev->hdl, subdev->ctrl_handler, NULL);
1433                 break;
1434         case RTL2832_SDR_TUNER_R820T:
1435         case RTL2832_SDR_TUNER_R828D:
1436                 v4l2_ctrl_handler_init(&dev->hdl, 2);
1437                 dev->bandwidth_auto = v4l2_ctrl_new_std(&dev->hdl, ops,
1438                                                         V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1439                                                         0, 1, 1, 1);
1440                 dev->bandwidth = v4l2_ctrl_new_std(&dev->hdl, ops,
1441                                                    V4L2_CID_RF_TUNER_BANDWIDTH,
1442                                                    0, 8000000, 100000, 0);
1443                 v4l2_ctrl_auto_cluster(2, &dev->bandwidth_auto, 0, false);
1444                 break;
1445         case RTL2832_SDR_TUNER_FC0012:
1446         case RTL2832_SDR_TUNER_FC0013:
1447                 v4l2_ctrl_handler_init(&dev->hdl, 2);
1448                 dev->bandwidth_auto = v4l2_ctrl_new_std(&dev->hdl, ops,
1449                                                         V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1450                                                         0, 1, 1, 1);
1451                 dev->bandwidth = v4l2_ctrl_new_std(&dev->hdl, ops,
1452                                                    V4L2_CID_RF_TUNER_BANDWIDTH,
1453                                                    6000000, 8000000, 1000000,
1454                                                    6000000);
1455                 v4l2_ctrl_auto_cluster(2, &dev->bandwidth_auto, 0, false);
1456                 break;
1457         case RTL2832_SDR_TUNER_FC2580:
1458                 v4l2_ctrl_handler_init(&dev->hdl, 2);
1459                 if (subdev)
1460                         v4l2_ctrl_add_handler(&dev->hdl, subdev->ctrl_handler,
1461                                               NULL);
1462                 break;
1463         default:
1464                 v4l2_ctrl_handler_init(&dev->hdl, 0);
1465                 dev_err(&pdev->dev, "Unsupported tuner\n");
1466                 goto err_v4l2_ctrl_handler_free;
1467         }
1468         if (dev->hdl.error) {
1469                 ret = dev->hdl.error;
1470                 dev_err(&pdev->dev, "Could not initialize controls\n");
1471                 goto err_v4l2_ctrl_handler_free;
1472         }
1473
1474         /* Init video_device structure */
1475         dev->vdev = rtl2832_sdr_template;
1476         dev->vdev.queue = &dev->vb_queue;
1477         dev->vdev.queue->lock = &dev->vb_queue_lock;
1478         video_set_drvdata(&dev->vdev, dev);
1479
1480         /* Register the v4l2_device structure */
1481         dev->v4l2_dev.release = rtl2832_sdr_video_release;
1482         ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
1483         if (ret) {
1484                 dev_err(&pdev->dev, "Failed to register v4l2-device %d\n", ret);
1485                 goto err_v4l2_ctrl_handler_free;
1486         }
1487
1488         dev->v4l2_dev.ctrl_handler = &dev->hdl;
1489         dev->vdev.v4l2_dev = &dev->v4l2_dev;
1490         dev->vdev.lock = &dev->v4l2_lock;
1491         dev->vdev.vfl_dir = VFL_DIR_RX;
1492
1493         ret = video_register_device(&dev->vdev, VFL_TYPE_SDR, -1);
1494         if (ret) {
1495                 dev_err(&pdev->dev, "Failed to register as video device %d\n",
1496                         ret);
1497                 goto err_v4l2_device_unregister;
1498         }
1499         dev_info(&pdev->dev, "Registered as %s\n",
1500                  video_device_node_name(&dev->vdev));
1501         dev_info(&pdev->dev, "Realtek RTL2832 SDR attached\n");
1502         dev_notice(&pdev->dev,
1503                    "SDR API is still slightly experimental and functionality changes may follow\n");
1504         platform_set_drvdata(pdev, dev);
1505         return 0;
1506 err_v4l2_device_unregister:
1507         v4l2_device_unregister(&dev->v4l2_dev);
1508 err_v4l2_ctrl_handler_free:
1509         v4l2_ctrl_handler_free(&dev->hdl);
1510 err_kfree:
1511         kfree(dev);
1512 err_module_put:
1513         module_put(pdev->dev.parent->driver->owner);
1514 err:
1515         return ret;
1516 }
1517
1518 static int rtl2832_sdr_remove(struct platform_device *pdev)
1519 {
1520         struct rtl2832_sdr_dev *dev = platform_get_drvdata(pdev);
1521
1522         dev_dbg(&pdev->dev, "\n");
1523
1524         mutex_lock(&dev->vb_queue_lock);
1525         mutex_lock(&dev->v4l2_lock);
1526         /* No need to keep the urbs around after disconnection */
1527         dev->udev = NULL;
1528         v4l2_device_disconnect(&dev->v4l2_dev);
1529         video_unregister_device(&dev->vdev);
1530         mutex_unlock(&dev->v4l2_lock);
1531         mutex_unlock(&dev->vb_queue_lock);
1532         v4l2_device_put(&dev->v4l2_dev);
1533         module_put(pdev->dev.parent->driver->owner);
1534
1535         return 0;
1536 }
1537
1538 static struct platform_driver rtl2832_sdr_driver = {
1539         .driver = {
1540                 .name   = "rtl2832_sdr",
1541         },
1542         .probe          = rtl2832_sdr_probe,
1543         .remove         = rtl2832_sdr_remove,
1544 };
1545 module_platform_driver(rtl2832_sdr_driver);
1546
1547 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1548 MODULE_DESCRIPTION("Realtek RTL2832 SDR driver");
1549 MODULE_LICENSE("GPL");