2 * Realtek RTL2832U SDR driver
4 * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
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.
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.
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.
20 * GNU Radio plugin "gr-kernel" for device usage will be on:
21 * http://git.linuxtv.org/anttip/gr-kernel.git
25 #include "dvb_frontend.h"
26 #include "rtl2832_sdr.h"
29 #include <media/v4l2-device.h>
30 #include <media/v4l2-ioctl.h>
31 #include <media/v4l2-ctrls.h>
32 #include <media/v4l2-event.h>
33 #include <media/videobuf2-vmalloc.h>
35 #include <linux/jiffies.h>
36 #include <linux/math64.h>
38 #define MAX_BULK_BUFS (10)
39 #define BULK_BUFFER_SIZE (128 * 512)
41 static const struct v4l2_frequency_band bands_adc
[] = {
44 .type
= V4L2_TUNER_ADC
,
46 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
52 .type
= V4L2_TUNER_ADC
,
54 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
60 .type
= V4L2_TUNER_ADC
,
62 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
68 static const struct v4l2_frequency_band bands_fm
[] = {
71 .type
= V4L2_TUNER_RF
,
73 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
75 .rangehigh
= 2000000000,
80 struct rtl2832_sdr_format
{
85 static struct rtl2832_sdr_format formats
[] = {
88 .pixelformat
= V4L2_SDR_FMT_CU8
,
90 .name
= "IQ U16LE (emulated)",
91 .pixelformat
= V4L2_SDR_FMT_CU16LE
,
95 static const unsigned int NUM_FORMATS
= ARRAY_SIZE(formats
);
97 /* intermediate buffers with raw data from the USB device */
98 struct rtl2832_sdr_frame_buf
{
99 struct vb2_buffer vb
; /* common v4l buffer stuff -- must be first */
100 struct list_head list
;
103 struct rtl2832_sdr_state
{
104 #define POWER_ON (1 << 1)
105 #define URB_BUF (1 << 2)
108 const struct rtl2832_config
*cfg
;
109 struct dvb_frontend
*fe
;
110 struct dvb_usb_device
*d
;
111 struct i2c_adapter
*i2c
;
114 struct video_device vdev
;
115 struct v4l2_device v4l2_dev
;
117 /* videobuf2 queue and queued buffers list */
118 struct vb2_queue vb_queue
;
119 struct list_head queued_bufs
;
120 spinlock_t queued_bufs_lock
; /* Protects queued_bufs */
121 unsigned sequence
; /* buffer sequence counter */
123 /* Note if taking both locks v4l2_lock must always be locked first! */
124 struct mutex v4l2_lock
; /* Protects everything else */
125 struct mutex vb_queue_lock
; /* Protects vb_queue and capt_file */
127 /* Pointer to our usb_device, will be NULL after unplug */
128 struct usb_device
*udev
; /* Both mutexes most be hold when setting! */
130 unsigned int vb_full
; /* vb is full and packets dropped */
132 struct urb
*urb_list
[MAX_BULK_BUFS
];
134 unsigned long buf_size
;
135 u8
*buf_list
[MAX_BULK_BUFS
];
136 dma_addr_t dma_addr
[MAX_BULK_BUFS
];
137 int urbs_initialized
;
140 unsigned int f_adc
, f_tuner
;
144 struct v4l2_ctrl_handler hdl
;
145 struct v4l2_ctrl
*bandwidth_auto
;
146 struct v4l2_ctrl
*bandwidth
;
148 /* for sample rate calc */
150 unsigned int sample_measured
;
151 unsigned long jiffies_next
;
154 /* write multiple hardware registers */
155 static int rtl2832_sdr_wr(struct rtl2832_sdr_state
*s
, u8 reg
, const u8
*val
,
159 #define MAX_WR_LEN 24
160 #define MAX_WR_XFER_LEN (MAX_WR_LEN + 1)
161 u8 buf
[MAX_WR_XFER_LEN
];
162 struct i2c_msg msg
[1] = {
164 .addr
= s
->cfg
->i2c_addr
,
171 if (WARN_ON(len
> MAX_WR_LEN
))
175 memcpy(&buf
[1], val
, len
);
177 ret
= i2c_transfer(s
->i2c
, msg
, 1);
181 dev_err(&s
->i2c
->dev
,
182 "%s: I2C wr failed=%d reg=%02x len=%d\n",
183 KBUILD_MODNAME
, ret
, reg
, len
);
189 /* read multiple hardware registers */
190 static int rtl2832_sdr_rd(struct rtl2832_sdr_state
*s
, u8 reg
, u8
*val
, int len
)
193 struct i2c_msg msg
[2] = {
195 .addr
= s
->cfg
->i2c_addr
,
200 .addr
= s
->cfg
->i2c_addr
,
207 ret
= i2c_transfer(s
->i2c
, msg
, 2);
211 dev_err(&s
->i2c
->dev
,
212 "%s: I2C rd failed=%d reg=%02x len=%d\n",
213 KBUILD_MODNAME
, ret
, reg
, len
);
219 /* write multiple registers */
220 static int rtl2832_sdr_wr_regs(struct rtl2832_sdr_state
*s
, u16 reg
,
221 const u8
*val
, int len
)
224 u8 reg2
= (reg
>> 0) & 0xff;
225 u8 bank
= (reg
>> 8) & 0xff;
227 /* switch bank if needed */
228 if (bank
!= s
->bank
) {
229 ret
= rtl2832_sdr_wr(s
, 0x00, &bank
, 1);
236 return rtl2832_sdr_wr(s
, reg2
, val
, len
);
239 /* read multiple registers */
240 static int rtl2832_sdr_rd_regs(struct rtl2832_sdr_state
*s
, u16 reg
, u8
*val
,
244 u8 reg2
= (reg
>> 0) & 0xff;
245 u8 bank
= (reg
>> 8) & 0xff;
247 /* switch bank if needed */
248 if (bank
!= s
->bank
) {
249 ret
= rtl2832_sdr_wr(s
, 0x00, &bank
, 1);
256 return rtl2832_sdr_rd(s
, reg2
, val
, len
);
259 /* write single register */
260 static int rtl2832_sdr_wr_reg(struct rtl2832_sdr_state
*s
, u16 reg
, u8 val
)
262 return rtl2832_sdr_wr_regs(s
, reg
, &val
, 1);
266 /* read single register */
267 static int rtl2832_sdr_rd_reg(struct rtl2832_sdr_state
*s
, u16 reg
, u8
*val
)
269 return rtl2832_sdr_rd_regs(s
, reg
, val
, 1);
273 /* write single register with mask */
274 static int rtl2832_sdr_wr_reg_mask(struct rtl2832_sdr_state
*s
, u16 reg
,
280 /* no need for read if whole reg is written */
282 ret
= rtl2832_sdr_rd_regs(s
, reg
, &tmp
, 1);
291 return rtl2832_sdr_wr_regs(s
, reg
, &val
, 1);
295 /* read single register with mask */
296 static int rtl2832_sdr_rd_reg_mask(struct rtl2832_sdr_state
*s
, u16 reg
,
302 ret
= rtl2832_sdr_rd_regs(s
, reg
, &tmp
, 1);
308 /* find position of the first bit */
309 for (i
= 0; i
< 8; i
++) {
310 if ((mask
>> i
) & 0x01)
319 /* Private functions */
320 static struct rtl2832_sdr_frame_buf
*rtl2832_sdr_get_next_fill_buf(
321 struct rtl2832_sdr_state
*s
)
323 unsigned long flags
= 0;
324 struct rtl2832_sdr_frame_buf
*buf
= NULL
;
326 spin_lock_irqsave(&s
->queued_bufs_lock
, flags
);
327 if (list_empty(&s
->queued_bufs
))
330 buf
= list_entry(s
->queued_bufs
.next
,
331 struct rtl2832_sdr_frame_buf
, list
);
332 list_del(&buf
->list
);
334 spin_unlock_irqrestore(&s
->queued_bufs_lock
, flags
);
338 static unsigned int rtl2832_sdr_convert_stream(struct rtl2832_sdr_state
*s
,
339 void *dst
, const u8
*src
, unsigned int src_len
)
341 unsigned int dst_len
;
343 if (s
->pixelformat
== V4L2_SDR_FMT_CU8
) {
344 /* native stream, no need to convert */
345 memcpy(dst
, src
, src_len
);
347 } else if (s
->pixelformat
== V4L2_SDR_FMT_CU16LE
) {
348 /* convert u8 to u16 */
351 for (i
= 0; i
< src_len
; i
++)
352 *u16dst
++ = (src
[i
] << 8) | (src
[i
] >> 0);
353 dst_len
= 2 * src_len
;
358 /* calculate samping rate and output it in 10 seconds intervals */
359 if (unlikely(time_is_before_jiffies(s
->jiffies_next
))) {
360 #define MSECS 10000UL
361 unsigned int samples
= s
->sample
- s
->sample_measured
;
362 s
->jiffies_next
= jiffies
+ msecs_to_jiffies(MSECS
);
363 s
->sample_measured
= s
->sample
;
364 dev_dbg(&s
->udev
->dev
,
365 "slen=%d samples=%u msecs=%lu sampling rate=%lu\n",
366 src_len
, samples
, MSECS
,
367 samples
* 1000UL / MSECS
);
370 /* total number of I+Q pairs */
371 s
->sample
+= src_len
/ 2;
377 * This gets called for the bulk stream pipe. This is done in interrupt
378 * time, so it has to be fast, not crash, and not stall. Neat.
380 static void rtl2832_sdr_urb_complete(struct urb
*urb
)
382 struct rtl2832_sdr_state
*s
= urb
->context
;
383 struct rtl2832_sdr_frame_buf
*fbuf
;
385 dev_dbg_ratelimited(&s
->udev
->dev
,
386 "%s: status=%d length=%d/%d errors=%d\n",
387 __func__
, urb
->status
, urb
->actual_length
,
388 urb
->transfer_buffer_length
, urb
->error_count
);
390 switch (urb
->status
) {
391 case 0: /* success */
392 case -ETIMEDOUT
: /* NAK */
394 case -ECONNRESET
: /* kill */
399 dev_err_ratelimited(&s
->udev
->dev
, "urb failed=%d\n",
404 if (likely(urb
->actual_length
> 0)) {
407 /* get free framebuffer */
408 fbuf
= rtl2832_sdr_get_next_fill_buf(s
);
409 if (unlikely(fbuf
== NULL
)) {
411 dev_notice_ratelimited(&s
->udev
->dev
,
412 "videobuf is full, %d packets dropped\n",
417 /* fill framebuffer */
418 ptr
= vb2_plane_vaddr(&fbuf
->vb
, 0);
419 len
= rtl2832_sdr_convert_stream(s
, ptr
, urb
->transfer_buffer
,
421 vb2_set_plane_payload(&fbuf
->vb
, 0, len
);
422 v4l2_get_timestamp(&fbuf
->vb
.v4l2_buf
.timestamp
);
423 fbuf
->vb
.v4l2_buf
.sequence
= s
->sequence
++;
424 vb2_buffer_done(&fbuf
->vb
, VB2_BUF_STATE_DONE
);
427 usb_submit_urb(urb
, GFP_ATOMIC
);
430 static int rtl2832_sdr_kill_urbs(struct rtl2832_sdr_state
*s
)
434 for (i
= s
->urbs_submitted
- 1; i
>= 0; i
--) {
435 dev_dbg(&s
->udev
->dev
, "%s: kill urb=%d\n", __func__
, i
);
437 usb_kill_urb(s
->urb_list
[i
]);
439 s
->urbs_submitted
= 0;
444 static int rtl2832_sdr_submit_urbs(struct rtl2832_sdr_state
*s
)
448 for (i
= 0; i
< s
->urbs_initialized
; i
++) {
449 dev_dbg(&s
->udev
->dev
, "%s: submit urb=%d\n", __func__
, i
);
450 ret
= usb_submit_urb(s
->urb_list
[i
], GFP_ATOMIC
);
452 dev_err(&s
->udev
->dev
,
453 "Could not submit urb no. %d - get them all back\n",
455 rtl2832_sdr_kill_urbs(s
);
464 static int rtl2832_sdr_free_stream_bufs(struct rtl2832_sdr_state
*s
)
466 if (s
->flags
& USB_STATE_URB_BUF
) {
469 dev_dbg(&s
->udev
->dev
, "%s: free buf=%d\n",
470 __func__
, s
->buf_num
);
471 usb_free_coherent(s
->udev
, s
->buf_size
,
472 s
->buf_list
[s
->buf_num
],
473 s
->dma_addr
[s
->buf_num
]);
476 s
->flags
&= ~USB_STATE_URB_BUF
;
481 static int rtl2832_sdr_alloc_stream_bufs(struct rtl2832_sdr_state
*s
)
484 s
->buf_size
= BULK_BUFFER_SIZE
;
486 dev_dbg(&s
->udev
->dev
,
487 "%s: all in all I will use %u bytes for streaming\n",
488 __func__
, MAX_BULK_BUFS
* BULK_BUFFER_SIZE
);
490 for (s
->buf_num
= 0; s
->buf_num
< MAX_BULK_BUFS
; s
->buf_num
++) {
491 s
->buf_list
[s
->buf_num
] = usb_alloc_coherent(s
->udev
,
492 BULK_BUFFER_SIZE
, GFP_ATOMIC
,
493 &s
->dma_addr
[s
->buf_num
]);
494 if (!s
->buf_list
[s
->buf_num
]) {
495 dev_dbg(&s
->udev
->dev
, "%s: alloc buf=%d failed\n",
496 __func__
, s
->buf_num
);
497 rtl2832_sdr_free_stream_bufs(s
);
501 dev_dbg(&s
->udev
->dev
, "%s: alloc buf=%d %p (dma %llu)\n",
502 __func__
, s
->buf_num
,
503 s
->buf_list
[s
->buf_num
],
504 (long long)s
->dma_addr
[s
->buf_num
]);
505 s
->flags
|= USB_STATE_URB_BUF
;
511 static int rtl2832_sdr_free_urbs(struct rtl2832_sdr_state
*s
)
515 rtl2832_sdr_kill_urbs(s
);
517 for (i
= s
->urbs_initialized
- 1; i
>= 0; i
--) {
518 if (s
->urb_list
[i
]) {
519 dev_dbg(&s
->udev
->dev
, "%s: free urb=%d\n",
522 usb_free_urb(s
->urb_list
[i
]);
525 s
->urbs_initialized
= 0;
530 static int rtl2832_sdr_alloc_urbs(struct rtl2832_sdr_state
*s
)
534 /* allocate the URBs */
535 for (i
= 0; i
< MAX_BULK_BUFS
; i
++) {
536 dev_dbg(&s
->udev
->dev
, "%s: alloc urb=%d\n", __func__
, i
);
537 s
->urb_list
[i
] = usb_alloc_urb(0, GFP_ATOMIC
);
538 if (!s
->urb_list
[i
]) {
539 dev_dbg(&s
->udev
->dev
, "%s: failed\n", __func__
);
540 for (j
= 0; j
< i
; j
++)
541 usb_free_urb(s
->urb_list
[j
]);
544 usb_fill_bulk_urb(s
->urb_list
[i
],
546 usb_rcvbulkpipe(s
->udev
, 0x81),
549 rtl2832_sdr_urb_complete
, s
);
551 s
->urb_list
[i
]->transfer_flags
= URB_NO_TRANSFER_DMA_MAP
;
552 s
->urb_list
[i
]->transfer_dma
= s
->dma_addr
[i
];
553 s
->urbs_initialized
++;
559 /* Must be called with vb_queue_lock hold */
560 static void rtl2832_sdr_cleanup_queued_bufs(struct rtl2832_sdr_state
*s
)
562 unsigned long flags
= 0;
563 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
565 spin_lock_irqsave(&s
->queued_bufs_lock
, flags
);
566 while (!list_empty(&s
->queued_bufs
)) {
567 struct rtl2832_sdr_frame_buf
*buf
;
568 buf
= list_entry(s
->queued_bufs
.next
,
569 struct rtl2832_sdr_frame_buf
, list
);
570 list_del(&buf
->list
);
571 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
573 spin_unlock_irqrestore(&s
->queued_bufs_lock
, flags
);
576 /* The user yanked out the cable... */
577 static void rtl2832_sdr_release_sec(struct dvb_frontend
*fe
)
579 struct rtl2832_sdr_state
*s
= fe
->sec_priv
;
580 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
582 mutex_lock(&s
->vb_queue_lock
);
583 mutex_lock(&s
->v4l2_lock
);
584 /* No need to keep the urbs around after disconnection */
587 v4l2_device_disconnect(&s
->v4l2_dev
);
588 video_unregister_device(&s
->vdev
);
589 mutex_unlock(&s
->v4l2_lock
);
590 mutex_unlock(&s
->vb_queue_lock
);
592 v4l2_device_put(&s
->v4l2_dev
);
597 static int rtl2832_sdr_querycap(struct file
*file
, void *fh
,
598 struct v4l2_capability
*cap
)
600 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
601 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
603 strlcpy(cap
->driver
, KBUILD_MODNAME
, sizeof(cap
->driver
));
604 strlcpy(cap
->card
, s
->vdev
.name
, sizeof(cap
->card
));
605 usb_make_path(s
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
606 cap
->device_caps
= V4L2_CAP_SDR_CAPTURE
| V4L2_CAP_STREAMING
|
607 V4L2_CAP_READWRITE
| V4L2_CAP_TUNER
;
608 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
612 /* Videobuf2 operations */
613 static int rtl2832_sdr_queue_setup(struct vb2_queue
*vq
,
614 const struct v4l2_format
*fmt
, unsigned int *nbuffers
,
615 unsigned int *nplanes
, unsigned int sizes
[], void *alloc_ctxs
[])
617 struct rtl2832_sdr_state
*s
= vb2_get_drv_priv(vq
);
618 dev_dbg(&s
->udev
->dev
, "%s: *nbuffers=%d\n", __func__
, *nbuffers
);
620 /* Need at least 8 buffers */
621 if (vq
->num_buffers
+ *nbuffers
< 8)
622 *nbuffers
= 8 - vq
->num_buffers
;
624 /* 2 = max 16-bit sample returned */
625 sizes
[0] = PAGE_ALIGN(BULK_BUFFER_SIZE
* 2);
626 dev_dbg(&s
->udev
->dev
, "%s: nbuffers=%d sizes[0]=%d\n",
627 __func__
, *nbuffers
, sizes
[0]);
631 static int rtl2832_sdr_buf_prepare(struct vb2_buffer
*vb
)
633 struct rtl2832_sdr_state
*s
= vb2_get_drv_priv(vb
->vb2_queue
);
635 /* Don't allow queing new buffers after device disconnection */
642 static void rtl2832_sdr_buf_queue(struct vb2_buffer
*vb
)
644 struct rtl2832_sdr_state
*s
= vb2_get_drv_priv(vb
->vb2_queue
);
645 struct rtl2832_sdr_frame_buf
*buf
=
646 container_of(vb
, struct rtl2832_sdr_frame_buf
, vb
);
647 unsigned long flags
= 0;
649 /* Check the device has not disconnected between prep and queuing */
651 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
655 spin_lock_irqsave(&s
->queued_bufs_lock
, flags
);
656 list_add_tail(&buf
->list
, &s
->queued_bufs
);
657 spin_unlock_irqrestore(&s
->queued_bufs_lock
, flags
);
660 static int rtl2832_sdr_set_adc(struct rtl2832_sdr_state
*s
)
662 struct dvb_frontend
*fe
= s
->fe
;
664 unsigned int f_sr
, f_if
;
665 u8 buf
[4], u8tmp1
, u8tmp2
;
668 dev_dbg(&s
->udev
->dev
, "%s: f_adc=%u\n", __func__
, s
->f_adc
);
670 if (!test_bit(POWER_ON
, &s
->flags
))
678 ret
= rtl2832_sdr_wr_regs(s
, 0x13e, "\x00\x00", 2);
682 ret
= rtl2832_sdr_wr_regs(s
, 0x115, "\x00\x00\x00\x00", 4);
686 /* get IF from tuner */
687 if (fe
->ops
.tuner_ops
.get_if_frequency
)
688 ret
= fe
->ops
.tuner_ops
.get_if_frequency(fe
, &f_if
);
696 u64tmp
= f_if
% s
->cfg
->xtal
;
698 u64tmp
= div_u64(u64tmp
, s
->cfg
->xtal
);
700 u32tmp
= u64tmp
& 0x3fffff;
702 dev_dbg(&s
->udev
->dev
, "%s: f_if=%u if_ctl=%08x\n",
703 __func__
, f_if
, u32tmp
);
705 buf
[0] = (u32tmp
>> 16) & 0xff;
706 buf
[1] = (u32tmp
>> 8) & 0xff;
707 buf
[2] = (u32tmp
>> 0) & 0xff;
709 ret
= rtl2832_sdr_wr_regs(s
, 0x119, buf
, 3);
714 /* POR: 0x1b1=0x1f, 0x008=0x0d, 0x006=0x80 */
716 u8tmp1
= 0x1a; /* disable Zero-IF */
717 u8tmp2
= 0x8d; /* enable ADC I */
719 u8tmp1
= 0x1b; /* enable Zero-IF, DC, IQ */
720 u8tmp2
= 0xcd; /* enable ADC I, ADC Q */
723 ret
= rtl2832_sdr_wr_reg(s
, 0x1b1, u8tmp1
);
727 ret
= rtl2832_sdr_wr_reg(s
, 0x008, u8tmp2
);
731 ret
= rtl2832_sdr_wr_reg(s
, 0x006, 0x80);
735 /* program sampling rate (resampling down) */
736 u32tmp
= div_u64(s
->cfg
->xtal
* 0x400000ULL
, f_sr
* 4U);
738 buf
[0] = (u32tmp
>> 24) & 0xff;
739 buf
[1] = (u32tmp
>> 16) & 0xff;
740 buf
[2] = (u32tmp
>> 8) & 0xff;
741 buf
[3] = (u32tmp
>> 0) & 0xff;
742 ret
= rtl2832_sdr_wr_regs(s
, 0x19f, buf
, 4);
746 /* low-pass filter */
747 ret
= rtl2832_sdr_wr_regs(s
, 0x11c,
748 "\xca\xdc\xd7\xd8\xe0\xf2\x0e\x35\x06\x50\x9c\x0d\x71\x11\x14\x71\x74\x19\x41\xa5",
753 ret
= rtl2832_sdr_wr_regs(s
, 0x017, "\x11\x10", 2);
758 ret
= rtl2832_sdr_wr_regs(s
, 0x019, "\x05", 1);
762 ret
= rtl2832_sdr_wr_regs(s
, 0x01a, "\x1b\x16\x0d\x06\x01\xff", 6);
767 ret
= rtl2832_sdr_wr_regs(s
, 0x192, "\x00\xf0\x0f", 3);
772 ret
= rtl2832_sdr_wr_regs(s
, 0x061, "\x60", 1);
776 /* used RF tuner based settings */
777 switch (s
->cfg
->tuner
) {
778 case RTL2832_TUNER_E4000
:
779 ret
= rtl2832_sdr_wr_regs(s
, 0x112, "\x5a", 1);
780 ret
= rtl2832_sdr_wr_regs(s
, 0x102, "\x40", 1);
781 ret
= rtl2832_sdr_wr_regs(s
, 0x103, "\x5a", 1);
782 ret
= rtl2832_sdr_wr_regs(s
, 0x1c7, "\x30", 1);
783 ret
= rtl2832_sdr_wr_regs(s
, 0x104, "\xd0", 1);
784 ret
= rtl2832_sdr_wr_regs(s
, 0x105, "\xbe", 1);
785 ret
= rtl2832_sdr_wr_regs(s
, 0x1c8, "\x18", 1);
786 ret
= rtl2832_sdr_wr_regs(s
, 0x106, "\x35", 1);
787 ret
= rtl2832_sdr_wr_regs(s
, 0x1c9, "\x21", 1);
788 ret
= rtl2832_sdr_wr_regs(s
, 0x1ca, "\x21", 1);
789 ret
= rtl2832_sdr_wr_regs(s
, 0x1cb, "\x00", 1);
790 ret
= rtl2832_sdr_wr_regs(s
, 0x107, "\x40", 1);
791 ret
= rtl2832_sdr_wr_regs(s
, 0x1cd, "\x10", 1);
792 ret
= rtl2832_sdr_wr_regs(s
, 0x1ce, "\x10", 1);
793 ret
= rtl2832_sdr_wr_regs(s
, 0x108, "\x80", 1);
794 ret
= rtl2832_sdr_wr_regs(s
, 0x109, "\x7f", 1);
795 ret
= rtl2832_sdr_wr_regs(s
, 0x10a, "\x80", 1);
796 ret
= rtl2832_sdr_wr_regs(s
, 0x10b, "\x7f", 1);
797 ret
= rtl2832_sdr_wr_regs(s
, 0x00e, "\xfc", 1);
798 ret
= rtl2832_sdr_wr_regs(s
, 0x00e, "\xfc", 1);
799 ret
= rtl2832_sdr_wr_regs(s
, 0x011, "\xd4", 1);
800 ret
= rtl2832_sdr_wr_regs(s
, 0x1e5, "\xf0", 1);
801 ret
= rtl2832_sdr_wr_regs(s
, 0x1d9, "\x00", 1);
802 ret
= rtl2832_sdr_wr_regs(s
, 0x1db, "\x00", 1);
803 ret
= rtl2832_sdr_wr_regs(s
, 0x1dd, "\x14", 1);
804 ret
= rtl2832_sdr_wr_regs(s
, 0x1de, "\xec", 1);
805 ret
= rtl2832_sdr_wr_regs(s
, 0x1d8, "\x0c", 1);
806 ret
= rtl2832_sdr_wr_regs(s
, 0x1e6, "\x02", 1);
807 ret
= rtl2832_sdr_wr_regs(s
, 0x1d7, "\x09", 1);
808 ret
= rtl2832_sdr_wr_regs(s
, 0x00d, "\x83", 1);
809 ret
= rtl2832_sdr_wr_regs(s
, 0x010, "\x49", 1);
810 ret
= rtl2832_sdr_wr_regs(s
, 0x00d, "\x87", 1);
811 ret
= rtl2832_sdr_wr_regs(s
, 0x00d, "\x85", 1);
812 ret
= rtl2832_sdr_wr_regs(s
, 0x013, "\x02", 1);
814 case RTL2832_TUNER_FC0012
:
815 case RTL2832_TUNER_FC0013
:
816 ret
= rtl2832_sdr_wr_regs(s
, 0x112, "\x5a", 1);
817 ret
= rtl2832_sdr_wr_regs(s
, 0x102, "\x40", 1);
818 ret
= rtl2832_sdr_wr_regs(s
, 0x103, "\x5a", 1);
819 ret
= rtl2832_sdr_wr_regs(s
, 0x1c7, "\x2c", 1);
820 ret
= rtl2832_sdr_wr_regs(s
, 0x104, "\xcc", 1);
821 ret
= rtl2832_sdr_wr_regs(s
, 0x105, "\xbe", 1);
822 ret
= rtl2832_sdr_wr_regs(s
, 0x1c8, "\x16", 1);
823 ret
= rtl2832_sdr_wr_regs(s
, 0x106, "\x35", 1);
824 ret
= rtl2832_sdr_wr_regs(s
, 0x1c9, "\x21", 1);
825 ret
= rtl2832_sdr_wr_regs(s
, 0x1ca, "\x21", 1);
826 ret
= rtl2832_sdr_wr_regs(s
, 0x1cb, "\x00", 1);
827 ret
= rtl2832_sdr_wr_regs(s
, 0x107, "\x40", 1);
828 ret
= rtl2832_sdr_wr_regs(s
, 0x1cd, "\x10", 1);
829 ret
= rtl2832_sdr_wr_regs(s
, 0x1ce, "\x10", 1);
830 ret
= rtl2832_sdr_wr_regs(s
, 0x108, "\x80", 1);
831 ret
= rtl2832_sdr_wr_regs(s
, 0x109, "\x7f", 1);
832 ret
= rtl2832_sdr_wr_regs(s
, 0x10a, "\x80", 1);
833 ret
= rtl2832_sdr_wr_regs(s
, 0x10b, "\x7f", 1);
834 ret
= rtl2832_sdr_wr_regs(s
, 0x00e, "\xfc", 1);
835 ret
= rtl2832_sdr_wr_regs(s
, 0x00e, "\xfc", 1);
836 ret
= rtl2832_sdr_wr_regs(s
, 0x011, "\xe9\xbf", 2);
837 ret
= rtl2832_sdr_wr_regs(s
, 0x1e5, "\xf0", 1);
838 ret
= rtl2832_sdr_wr_regs(s
, 0x1d9, "\x00", 1);
839 ret
= rtl2832_sdr_wr_regs(s
, 0x1db, "\x00", 1);
840 ret
= rtl2832_sdr_wr_regs(s
, 0x1dd, "\x11", 1);
841 ret
= rtl2832_sdr_wr_regs(s
, 0x1de, "\xef", 1);
842 ret
= rtl2832_sdr_wr_regs(s
, 0x1d8, "\x0c", 1);
843 ret
= rtl2832_sdr_wr_regs(s
, 0x1e6, "\x02", 1);
844 ret
= rtl2832_sdr_wr_regs(s
, 0x1d7, "\x09", 1);
846 case RTL2832_TUNER_R820T
:
847 ret
= rtl2832_sdr_wr_regs(s
, 0x112, "\x5a", 1);
848 ret
= rtl2832_sdr_wr_regs(s
, 0x102, "\x40", 1);
849 ret
= rtl2832_sdr_wr_regs(s
, 0x115, "\x01", 1);
850 ret
= rtl2832_sdr_wr_regs(s
, 0x103, "\x80", 1);
851 ret
= rtl2832_sdr_wr_regs(s
, 0x1c7, "\x24", 1);
852 ret
= rtl2832_sdr_wr_regs(s
, 0x104, "\xcc", 1);
853 ret
= rtl2832_sdr_wr_regs(s
, 0x105, "\xbe", 1);
854 ret
= rtl2832_sdr_wr_regs(s
, 0x1c8, "\x14", 1);
855 ret
= rtl2832_sdr_wr_regs(s
, 0x106, "\x35", 1);
856 ret
= rtl2832_sdr_wr_regs(s
, 0x1c9, "\x21", 1);
857 ret
= rtl2832_sdr_wr_regs(s
, 0x1ca, "\x21", 1);
858 ret
= rtl2832_sdr_wr_regs(s
, 0x1cb, "\x00", 1);
859 ret
= rtl2832_sdr_wr_regs(s
, 0x107, "\x40", 1);
860 ret
= rtl2832_sdr_wr_regs(s
, 0x1cd, "\x10", 1);
861 ret
= rtl2832_sdr_wr_regs(s
, 0x1ce, "\x10", 1);
862 ret
= rtl2832_sdr_wr_regs(s
, 0x108, "\x80", 1);
863 ret
= rtl2832_sdr_wr_regs(s
, 0x109, "\x7f", 1);
864 ret
= rtl2832_sdr_wr_regs(s
, 0x10a, "\x80", 1);
865 ret
= rtl2832_sdr_wr_regs(s
, 0x10b, "\x7f", 1);
866 ret
= rtl2832_sdr_wr_regs(s
, 0x00e, "\xfc", 1);
867 ret
= rtl2832_sdr_wr_regs(s
, 0x00e, "\xfc", 1);
868 ret
= rtl2832_sdr_wr_regs(s
, 0x011, "\xf4", 1);
871 dev_notice(&s
->udev
->dev
, "Unsupported tuner\n");
875 ret
= rtl2832_sdr_wr_reg_mask(s
, 0x101, 0x04, 0x04);
879 ret
= rtl2832_sdr_wr_reg_mask(s
, 0x101, 0x00, 0x04);
886 static void rtl2832_sdr_unset_adc(struct rtl2832_sdr_state
*s
)
890 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
893 ret
= rtl2832_sdr_wr_regs(s
, 0x061, "\xe0", 1);
898 ret
= rtl2832_sdr_wr_regs(s
, 0x019, "\x20", 1);
902 ret
= rtl2832_sdr_wr_regs(s
, 0x017, "\x11\x10", 2);
907 ret
= rtl2832_sdr_wr_regs(s
, 0x192, "\x00\x0f\xff", 3);
911 ret
= rtl2832_sdr_wr_regs(s
, 0x13e, "\x40\x00", 2);
915 ret
= rtl2832_sdr_wr_regs(s
, 0x115, "\x06\x3f\xce\xcc", 4);
922 static int rtl2832_sdr_set_tuner_freq(struct rtl2832_sdr_state
*s
)
924 struct dvb_frontend
*fe
= s
->fe
;
925 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
926 struct v4l2_ctrl
*bandwidth_auto
;
927 struct v4l2_ctrl
*bandwidth
;
938 bandwidth_auto
= v4l2_ctrl_find(&s
->hdl
, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
);
939 bandwidth
= v4l2_ctrl_find(&s
->hdl
, V4L2_CID_RF_TUNER_BANDWIDTH
);
940 if (v4l2_ctrl_g_ctrl(bandwidth_auto
)) {
941 c
->bandwidth_hz
= s
->f_adc
;
942 v4l2_ctrl_s_ctrl(bandwidth
, s
->f_adc
);
944 c
->bandwidth_hz
= v4l2_ctrl_g_ctrl(bandwidth
);
947 c
->frequency
= s
->f_tuner
;
948 c
->delivery_system
= SYS_DVBT
;
950 dev_dbg(&s
->udev
->dev
, "%s: frequency=%u bandwidth=%d\n",
951 __func__
, c
->frequency
, c
->bandwidth_hz
);
953 if (!test_bit(POWER_ON
, &s
->flags
))
956 if (fe
->ops
.tuner_ops
.set_params
)
957 fe
->ops
.tuner_ops
.set_params(fe
);
962 static int rtl2832_sdr_set_tuner(struct rtl2832_sdr_state
*s
)
964 struct dvb_frontend
*fe
= s
->fe
;
966 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
968 if (fe
->ops
.tuner_ops
.init
)
969 fe
->ops
.tuner_ops
.init(fe
);
974 static void rtl2832_sdr_unset_tuner(struct rtl2832_sdr_state
*s
)
976 struct dvb_frontend
*fe
= s
->fe
;
978 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
980 if (fe
->ops
.tuner_ops
.sleep
)
981 fe
->ops
.tuner_ops
.sleep(fe
);
986 static int rtl2832_sdr_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
988 struct rtl2832_sdr_state
*s
= vb2_get_drv_priv(vq
);
990 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
995 if (mutex_lock_interruptible(&s
->v4l2_lock
))
998 if (s
->d
->props
->power_ctrl
)
999 s
->d
->props
->power_ctrl(s
->d
, 1);
1001 set_bit(POWER_ON
, &s
->flags
);
1003 ret
= rtl2832_sdr_set_tuner(s
);
1007 ret
= rtl2832_sdr_set_tuner_freq(s
);
1011 ret
= rtl2832_sdr_set_adc(s
);
1015 ret
= rtl2832_sdr_alloc_stream_bufs(s
);
1019 ret
= rtl2832_sdr_alloc_urbs(s
);
1025 ret
= rtl2832_sdr_submit_urbs(s
);
1030 mutex_unlock(&s
->v4l2_lock
);
1035 static int rtl2832_sdr_stop_streaming(struct vb2_queue
*vq
)
1037 struct rtl2832_sdr_state
*s
= vb2_get_drv_priv(vq
);
1038 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
1040 if (mutex_lock_interruptible(&s
->v4l2_lock
))
1041 return -ERESTARTSYS
;
1043 rtl2832_sdr_kill_urbs(s
);
1044 rtl2832_sdr_free_urbs(s
);
1045 rtl2832_sdr_free_stream_bufs(s
);
1046 rtl2832_sdr_cleanup_queued_bufs(s
);
1047 rtl2832_sdr_unset_adc(s
);
1048 rtl2832_sdr_unset_tuner(s
);
1050 clear_bit(POWER_ON
, &s
->flags
);
1052 if (s
->d
->props
->power_ctrl
)
1053 s
->d
->props
->power_ctrl(s
->d
, 0);
1055 mutex_unlock(&s
->v4l2_lock
);
1060 static struct vb2_ops rtl2832_sdr_vb2_ops
= {
1061 .queue_setup
= rtl2832_sdr_queue_setup
,
1062 .buf_prepare
= rtl2832_sdr_buf_prepare
,
1063 .buf_queue
= rtl2832_sdr_buf_queue
,
1064 .start_streaming
= rtl2832_sdr_start_streaming
,
1065 .stop_streaming
= rtl2832_sdr_stop_streaming
,
1066 .wait_prepare
= vb2_ops_wait_prepare
,
1067 .wait_finish
= vb2_ops_wait_finish
,
1070 static int rtl2832_sdr_g_tuner(struct file
*file
, void *priv
,
1071 struct v4l2_tuner
*v
)
1073 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1074 dev_dbg(&s
->udev
->dev
, "%s: index=%d type=%d\n",
1075 __func__
, v
->index
, v
->type
);
1077 if (v
->index
== 0) {
1078 strlcpy(v
->name
, "ADC: Realtek RTL2832", sizeof(v
->name
));
1079 v
->type
= V4L2_TUNER_ADC
;
1080 v
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
1081 v
->rangelow
= 300000;
1082 v
->rangehigh
= 3200000;
1083 } else if (v
->index
== 1) {
1084 strlcpy(v
->name
, "RF: <unknown>", sizeof(v
->name
));
1085 v
->type
= V4L2_TUNER_RF
;
1086 v
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
1087 v
->rangelow
= 50000000;
1088 v
->rangehigh
= 2000000000;
1096 static int rtl2832_sdr_s_tuner(struct file
*file
, void *priv
,
1097 const struct v4l2_tuner
*v
)
1099 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1100 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
1107 static int rtl2832_sdr_enum_freq_bands(struct file
*file
, void *priv
,
1108 struct v4l2_frequency_band
*band
)
1110 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1111 dev_dbg(&s
->udev
->dev
, "%s: tuner=%d type=%d index=%d\n",
1112 __func__
, band
->tuner
, band
->type
, band
->index
);
1114 if (band
->tuner
== 0) {
1115 if (band
->index
>= ARRAY_SIZE(bands_adc
))
1118 *band
= bands_adc
[band
->index
];
1119 } else if (band
->tuner
== 1) {
1120 if (band
->index
>= ARRAY_SIZE(bands_fm
))
1123 *band
= bands_fm
[band
->index
];
1131 static int rtl2832_sdr_g_frequency(struct file
*file
, void *priv
,
1132 struct v4l2_frequency
*f
)
1134 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1136 dev_dbg(&s
->udev
->dev
, "%s: tuner=%d type=%d\n",
1137 __func__
, f
->tuner
, f
->type
);
1139 if (f
->tuner
== 0) {
1140 f
->frequency
= s
->f_adc
;
1141 f
->type
= V4L2_TUNER_ADC
;
1142 } else if (f
->tuner
== 1) {
1143 f
->frequency
= s
->f_tuner
;
1144 f
->type
= V4L2_TUNER_RF
;
1152 static int rtl2832_sdr_s_frequency(struct file
*file
, void *priv
,
1153 const struct v4l2_frequency
*f
)
1155 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1158 dev_dbg(&s
->udev
->dev
, "%s: tuner=%d type=%d frequency=%u\n",
1159 __func__
, f
->tuner
, f
->type
, f
->frequency
);
1161 /* ADC band midpoints */
1162 #define BAND_ADC_0 ((bands_adc[0].rangehigh + bands_adc[1].rangelow) / 2)
1163 #define BAND_ADC_1 ((bands_adc[1].rangehigh + bands_adc[2].rangelow) / 2)
1165 if (f
->tuner
== 0 && f
->type
== V4L2_TUNER_ADC
) {
1166 if (f
->frequency
< BAND_ADC_0
)
1168 else if (f
->frequency
< BAND_ADC_1
)
1173 s
->f_adc
= clamp_t(unsigned int, f
->frequency
,
1174 bands_adc
[band
].rangelow
,
1175 bands_adc
[band
].rangehigh
);
1177 dev_dbg(&s
->udev
->dev
, "%s: ADC frequency=%u Hz\n",
1178 __func__
, s
->f_adc
);
1179 ret
= rtl2832_sdr_set_adc(s
);
1180 } else if (f
->tuner
== 1) {
1181 s
->f_tuner
= clamp_t(unsigned int, f
->frequency
,
1182 bands_fm
[0].rangelow
,
1183 bands_fm
[0].rangehigh
);
1184 dev_dbg(&s
->udev
->dev
, "%s: RF frequency=%u Hz\n",
1185 __func__
, f
->frequency
);
1187 ret
= rtl2832_sdr_set_tuner_freq(s
);
1195 static int rtl2832_sdr_enum_fmt_sdr_cap(struct file
*file
, void *priv
,
1196 struct v4l2_fmtdesc
*f
)
1198 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1199 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
1201 if (f
->index
>= NUM_FORMATS
)
1204 strlcpy(f
->description
, formats
[f
->index
].name
, sizeof(f
->description
));
1205 f
->pixelformat
= formats
[f
->index
].pixelformat
;
1210 static int rtl2832_sdr_g_fmt_sdr_cap(struct file
*file
, void *priv
,
1211 struct v4l2_format
*f
)
1213 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1214 dev_dbg(&s
->udev
->dev
, "%s:\n", __func__
);
1216 f
->fmt
.sdr
.pixelformat
= s
->pixelformat
;
1217 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
1222 static int rtl2832_sdr_s_fmt_sdr_cap(struct file
*file
, void *priv
,
1223 struct v4l2_format
*f
)
1225 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1226 struct vb2_queue
*q
= &s
->vb_queue
;
1228 dev_dbg(&s
->udev
->dev
, "%s: pixelformat fourcc %4.4s\n", __func__
,
1229 (char *)&f
->fmt
.sdr
.pixelformat
);
1234 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
1235 for (i
= 0; i
< NUM_FORMATS
; i
++) {
1236 if (formats
[i
].pixelformat
== f
->fmt
.sdr
.pixelformat
) {
1237 s
->pixelformat
= f
->fmt
.sdr
.pixelformat
;
1242 f
->fmt
.sdr
.pixelformat
= formats
[0].pixelformat
;
1243 s
->pixelformat
= formats
[0].pixelformat
;
1248 static int rtl2832_sdr_try_fmt_sdr_cap(struct file
*file
, void *priv
,
1249 struct v4l2_format
*f
)
1251 struct rtl2832_sdr_state
*s
= video_drvdata(file
);
1253 dev_dbg(&s
->udev
->dev
, "%s: pixelformat fourcc %4.4s\n", __func__
,
1254 (char *)&f
->fmt
.sdr
.pixelformat
);
1256 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
1257 for (i
= 0; i
< NUM_FORMATS
; i
++) {
1258 if (formats
[i
].pixelformat
== f
->fmt
.sdr
.pixelformat
)
1262 f
->fmt
.sdr
.pixelformat
= formats
[0].pixelformat
;
1267 static const struct v4l2_ioctl_ops rtl2832_sdr_ioctl_ops
= {
1268 .vidioc_querycap
= rtl2832_sdr_querycap
,
1270 .vidioc_enum_fmt_sdr_cap
= rtl2832_sdr_enum_fmt_sdr_cap
,
1271 .vidioc_g_fmt_sdr_cap
= rtl2832_sdr_g_fmt_sdr_cap
,
1272 .vidioc_s_fmt_sdr_cap
= rtl2832_sdr_s_fmt_sdr_cap
,
1273 .vidioc_try_fmt_sdr_cap
= rtl2832_sdr_try_fmt_sdr_cap
,
1275 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1276 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
1277 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
1278 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1279 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1280 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1282 .vidioc_streamon
= vb2_ioctl_streamon
,
1283 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1285 .vidioc_g_tuner
= rtl2832_sdr_g_tuner
,
1286 .vidioc_s_tuner
= rtl2832_sdr_s_tuner
,
1288 .vidioc_enum_freq_bands
= rtl2832_sdr_enum_freq_bands
,
1289 .vidioc_g_frequency
= rtl2832_sdr_g_frequency
,
1290 .vidioc_s_frequency
= rtl2832_sdr_s_frequency
,
1292 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1293 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1294 .vidioc_log_status
= v4l2_ctrl_log_status
,
1297 static const struct v4l2_file_operations rtl2832_sdr_fops
= {
1298 .owner
= THIS_MODULE
,
1299 .open
= v4l2_fh_open
,
1300 .release
= vb2_fop_release
,
1301 .read
= vb2_fop_read
,
1302 .poll
= vb2_fop_poll
,
1303 .mmap
= vb2_fop_mmap
,
1304 .unlocked_ioctl
= video_ioctl2
,
1307 static struct video_device rtl2832_sdr_template
= {
1308 .name
= "Realtek RTL2832 SDR",
1309 .release
= video_device_release_empty
,
1310 .fops
= &rtl2832_sdr_fops
,
1311 .ioctl_ops
= &rtl2832_sdr_ioctl_ops
,
1314 static int rtl2832_sdr_s_ctrl(struct v4l2_ctrl
*ctrl
)
1316 struct rtl2832_sdr_state
*s
=
1317 container_of(ctrl
->handler
, struct rtl2832_sdr_state
,
1319 struct dvb_frontend
*fe
= s
->fe
;
1320 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
1322 dev_dbg(&s
->udev
->dev
,
1323 "%s: id=%d name=%s val=%d min=%d max=%d step=%d\n",
1324 __func__
, ctrl
->id
, ctrl
->name
, ctrl
->val
,
1325 ctrl
->minimum
, ctrl
->maximum
, ctrl
->step
);
1328 case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
:
1329 case V4L2_CID_RF_TUNER_BANDWIDTH
:
1330 /* TODO: these controls should be moved to tuner drivers */
1331 if (s
->bandwidth_auto
->val
) {
1332 /* Round towards the closest legal value */
1333 s32 val
= s
->f_adc
+ s
->bandwidth
->step
/ 2;
1335 val
= clamp(val
, s
->bandwidth
->minimum
, s
->bandwidth
->maximum
);
1336 offset
= val
- s
->bandwidth
->minimum
;
1337 offset
= s
->bandwidth
->step
* (offset
/ s
->bandwidth
->step
);
1338 s
->bandwidth
->val
= s
->bandwidth
->minimum
+ offset
;
1341 c
->bandwidth_hz
= s
->bandwidth
->val
;
1343 if (!test_bit(POWER_ON
, &s
->flags
))
1346 if (fe
->ops
.tuner_ops
.set_params
)
1347 ret
= fe
->ops
.tuner_ops
.set_params(fe
);
1358 static const struct v4l2_ctrl_ops rtl2832_sdr_ctrl_ops
= {
1359 .s_ctrl
= rtl2832_sdr_s_ctrl
,
1362 static void rtl2832_sdr_video_release(struct v4l2_device
*v
)
1364 struct rtl2832_sdr_state
*s
=
1365 container_of(v
, struct rtl2832_sdr_state
, v4l2_dev
);
1367 v4l2_ctrl_handler_free(&s
->hdl
);
1368 v4l2_device_unregister(&s
->v4l2_dev
);
1372 struct dvb_frontend
*rtl2832_sdr_attach(struct dvb_frontend
*fe
,
1373 struct i2c_adapter
*i2c
, const struct rtl2832_config
*cfg
,
1374 struct v4l2_subdev
*sd
)
1377 struct rtl2832_sdr_state
*s
;
1378 const struct v4l2_ctrl_ops
*ops
= &rtl2832_sdr_ctrl_ops
;
1379 struct dvb_usb_device
*d
= i2c_get_adapdata(i2c
);
1381 s
= kzalloc(sizeof(struct rtl2832_sdr_state
), GFP_KERNEL
);
1383 dev_err(&d
->udev
->dev
,
1384 "Could not allocate memory for rtl2832_sdr_state\n");
1388 /* setup the state */
1394 s
->f_adc
= bands_adc
[0].rangelow
;
1395 s
->f_tuner
= bands_fm
[0].rangelow
;
1396 s
->pixelformat
= V4L2_SDR_FMT_CU8
;
1398 mutex_init(&s
->v4l2_lock
);
1399 mutex_init(&s
->vb_queue_lock
);
1400 spin_lock_init(&s
->queued_bufs_lock
);
1401 INIT_LIST_HEAD(&s
->queued_bufs
);
1403 /* Init videobuf2 queue structure */
1404 s
->vb_queue
.type
= V4L2_BUF_TYPE_SDR_CAPTURE
;
1405 s
->vb_queue
.io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_READ
;
1406 s
->vb_queue
.drv_priv
= s
;
1407 s
->vb_queue
.buf_struct_size
= sizeof(struct rtl2832_sdr_frame_buf
);
1408 s
->vb_queue
.ops
= &rtl2832_sdr_vb2_ops
;
1409 s
->vb_queue
.mem_ops
= &vb2_vmalloc_memops
;
1410 s
->vb_queue
.timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1411 ret
= vb2_queue_init(&s
->vb_queue
);
1413 dev_err(&s
->udev
->dev
, "Could not initialize vb2 queue\n");
1417 /* Register controls */
1418 switch (s
->cfg
->tuner
) {
1419 case RTL2832_TUNER_E4000
:
1420 v4l2_ctrl_handler_init(&s
->hdl
, 9);
1422 v4l2_ctrl_add_handler(&s
->hdl
, sd
->ctrl_handler
, NULL
);
1424 case RTL2832_TUNER_R820T
:
1425 v4l2_ctrl_handler_init(&s
->hdl
, 2);
1426 s
->bandwidth_auto
= v4l2_ctrl_new_std(&s
->hdl
, ops
, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
, 0, 1, 1, 1);
1427 s
->bandwidth
= v4l2_ctrl_new_std(&s
->hdl
, ops
, V4L2_CID_RF_TUNER_BANDWIDTH
, 0, 8000000, 100000, 0);
1428 v4l2_ctrl_auto_cluster(2, &s
->bandwidth_auto
, 0, false);
1430 case RTL2832_TUNER_FC0012
:
1431 case RTL2832_TUNER_FC0013
:
1432 v4l2_ctrl_handler_init(&s
->hdl
, 2);
1433 s
->bandwidth_auto
= v4l2_ctrl_new_std(&s
->hdl
, ops
, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
, 0, 1, 1, 1);
1434 s
->bandwidth
= v4l2_ctrl_new_std(&s
->hdl
, ops
, V4L2_CID_RF_TUNER_BANDWIDTH
, 6000000, 8000000, 1000000, 6000000);
1435 v4l2_ctrl_auto_cluster(2, &s
->bandwidth_auto
, 0, false);
1438 v4l2_ctrl_handler_init(&s
->hdl
, 0);
1439 dev_notice(&s
->udev
->dev
, "%s: Unsupported tuner\n",
1441 goto err_free_controls
;
1446 dev_err(&s
->udev
->dev
, "Could not initialize controls\n");
1447 goto err_free_controls
;
1450 /* Init video_device structure */
1451 s
->vdev
= rtl2832_sdr_template
;
1452 s
->vdev
.queue
= &s
->vb_queue
;
1453 s
->vdev
.queue
->lock
= &s
->vb_queue_lock
;
1454 set_bit(V4L2_FL_USE_FH_PRIO
, &s
->vdev
.flags
);
1455 video_set_drvdata(&s
->vdev
, s
);
1457 /* Register the v4l2_device structure */
1458 s
->v4l2_dev
.release
= rtl2832_sdr_video_release
;
1459 ret
= v4l2_device_register(&s
->udev
->dev
, &s
->v4l2_dev
);
1461 dev_err(&s
->udev
->dev
,
1462 "Failed to register v4l2-device (%d)\n", ret
);
1463 goto err_free_controls
;
1466 s
->v4l2_dev
.ctrl_handler
= &s
->hdl
;
1467 s
->vdev
.v4l2_dev
= &s
->v4l2_dev
;
1468 s
->vdev
.lock
= &s
->v4l2_lock
;
1469 s
->vdev
.vfl_dir
= VFL_DIR_RX
;
1471 ret
= video_register_device(&s
->vdev
, VFL_TYPE_SDR
, -1);
1473 dev_err(&s
->udev
->dev
,
1474 "Failed to register as video device (%d)\n",
1476 goto err_unregister_v4l2_dev
;
1478 dev_info(&s
->udev
->dev
, "Registered as %s\n",
1479 video_device_node_name(&s
->vdev
));
1482 fe
->ops
.release_sec
= rtl2832_sdr_release_sec
;
1484 dev_info(&s
->i2c
->dev
, "%s: Realtek RTL2832 SDR attached\n",
1488 err_unregister_v4l2_dev
:
1489 v4l2_device_unregister(&s
->v4l2_dev
);
1491 v4l2_ctrl_handler_free(&s
->hdl
);
1496 EXPORT_SYMBOL(rtl2832_sdr_attach
);
1498 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1499 MODULE_DESCRIPTION("Realtek RTL2832 SDR driver");
1500 MODULE_LICENSE("GPL");