4 * Copyright (C) 2014 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.
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/usb.h>
20 #include <media/v4l2-device.h>
21 #include <media/v4l2-ioctl.h>
22 #include <media/v4l2-ctrls.h>
23 #include <media/v4l2-event.h>
24 #include <media/videobuf2-vmalloc.h>
26 /* AirSpy USB API commands (from AirSpy Library) */
29 CMD_RECEIVER_MODE
= 0x01,
30 CMD_SI5351C_WRITE
= 0x02,
31 CMD_SI5351C_READ
= 0x03,
32 CMD_R820T_WRITE
= 0x04,
33 CMD_R820T_READ
= 0x05,
34 CMD_SPIFLASH_ERASE
= 0x06,
35 CMD_SPIFLASH_WRITE
= 0x07,
36 CMD_SPIFLASH_READ
= 0x08,
37 CMD_BOARD_ID_READ
= 0x09,
38 CMD_VERSION_STRING_READ
= 0x0a,
39 CMD_BOARD_PARTID_SERIALNO_READ
= 0x0b,
40 CMD_SET_SAMPLE_RATE
= 0x0c,
42 CMD_SET_LNA_GAIN
= 0x0e,
43 CMD_SET_MIXER_GAIN
= 0x0f,
44 CMD_SET_VGA_GAIN
= 0x10,
45 CMD_SET_LNA_AGC
= 0x11,
46 CMD_SET_MIXER_AGC
= 0x12,
47 CMD_SET_PACKING
= 0x13,
51 * bEndpointAddress 0x81 EP 1 IN
53 * wMaxPacketSize 0x0200 1x 512 bytes
55 #define MAX_BULK_BUFS (6)
56 #define BULK_BUFFER_SIZE (128 * 512)
58 static const struct v4l2_frequency_band bands
[] = {
61 .type
= V4L2_TUNER_ADC
,
63 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
65 .rangehigh
= 20000000,
69 static const struct v4l2_frequency_band bands_rf
[] = {
72 .type
= V4L2_TUNER_RF
,
74 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
76 .rangehigh
= 1750000000,
81 struct airspy_format
{
87 /* format descriptions for capture and preview */
88 static struct airspy_format formats
[] = {
91 .pixelformat
= V4L2_SDR_FMT_RU12LE
,
92 .buffersize
= BULK_BUFFER_SIZE
,
96 static const unsigned int NUM_FORMATS
= ARRAY_SIZE(formats
);
98 /* intermediate buffers with raw data from the USB device */
99 struct airspy_frame_buf
{
100 struct vb2_buffer vb
; /* common v4l buffer stuff -- must be first */
101 struct list_head list
;
105 #define POWER_ON (1 << 1)
106 #define URB_BUF (1 << 2)
107 #define USB_STATE_URB_BUF (1 << 3)
111 struct usb_device
*udev
;
112 struct video_device vdev
;
113 struct v4l2_device v4l2_dev
;
115 /* videobuf2 queue and queued buffers list */
116 struct vb2_queue vb_queue
;
117 struct list_head queued_bufs
;
118 spinlock_t queued_bufs_lock
; /* Protects queued_bufs */
119 unsigned sequence
; /* Buffer sequence counter */
120 unsigned int vb_full
; /* vb is full and packets dropped */
122 /* Note if taking both locks v4l2_lock must always be locked first! */
123 struct mutex v4l2_lock
; /* Protects everything else */
124 struct mutex vb_queue_lock
; /* Protects vb_queue and capt_file */
126 struct urb
*urb_list
[MAX_BULK_BUFS
];
128 unsigned long buf_size
;
129 u8
*buf_list
[MAX_BULK_BUFS
];
130 dma_addr_t dma_addr
[MAX_BULK_BUFS
];
131 int urbs_initialized
;
134 /* USB control message buffer */
138 /* Current configuration */
145 struct v4l2_ctrl_handler hdl
;
146 struct v4l2_ctrl
*lna_gain_auto
;
147 struct v4l2_ctrl
*lna_gain
;
148 struct v4l2_ctrl
*mixer_gain_auto
;
149 struct v4l2_ctrl
*mixer_gain
;
150 struct v4l2_ctrl
*if_gain
;
152 /* Sample rate calc */
153 unsigned long jiffies_next
;
155 unsigned int sample_measured
;
158 #define airspy_dbg_usb_control_msg(_dev, _r, _t, _v, _i, _b, _l) { \
160 if (_t & USB_DIR_IN) \
161 _direction = "<<<"; \
163 _direction = ">>>"; \
164 dev_dbg(_dev, "%02x %02x %02x %02x %02x %02x %02x %02x %s %*ph\n", \
165 _t, _r, _v & 0xff, _v >> 8, _i & 0xff, _i >> 8, \
166 _l & 0xff, _l >> 8, _direction, _l, _b); \
169 /* execute firmware command */
170 static int airspy_ctrl_msg(struct airspy
*s
, u8 request
, u16 value
, u16 index
,
178 case CMD_RECEIVER_MODE
:
180 pipe
= usb_sndctrlpipe(s
->udev
, 0);
181 requesttype
= (USB_TYPE_VENDOR
| USB_DIR_OUT
);
183 case CMD_BOARD_ID_READ
:
184 case CMD_VERSION_STRING_READ
:
185 case CMD_BOARD_PARTID_SERIALNO_READ
:
186 case CMD_SET_LNA_GAIN
:
187 case CMD_SET_MIXER_GAIN
:
188 case CMD_SET_VGA_GAIN
:
189 case CMD_SET_LNA_AGC
:
190 case CMD_SET_MIXER_AGC
:
191 pipe
= usb_rcvctrlpipe(s
->udev
, 0);
192 requesttype
= (USB_TYPE_VENDOR
| USB_DIR_IN
);
195 dev_err(s
->dev
, "Unknown command %02x\n", request
);
201 if (!(requesttype
& USB_DIR_IN
))
202 memcpy(s
->buf
, data
, size
);
204 ret
= usb_control_msg(s
->udev
, pipe
, request
, requesttype
, value
,
205 index
, s
->buf
, size
, 1000);
206 airspy_dbg_usb_control_msg(s
->dev
, request
, requesttype
, value
,
207 index
, s
->buf
, size
);
209 dev_err(s
->dev
, "usb_control_msg() failed %d request %02x\n",
215 if (requesttype
& USB_DIR_IN
)
216 memcpy(data
, s
->buf
, size
);
223 /* Private functions */
224 static struct airspy_frame_buf
*airspy_get_next_fill_buf(struct airspy
*s
)
227 struct airspy_frame_buf
*buf
= NULL
;
229 spin_lock_irqsave(&s
->queued_bufs_lock
, flags
);
230 if (list_empty(&s
->queued_bufs
))
233 buf
= list_entry(s
->queued_bufs
.next
,
234 struct airspy_frame_buf
, list
);
235 list_del(&buf
->list
);
237 spin_unlock_irqrestore(&s
->queued_bufs_lock
, flags
);
241 static unsigned int airspy_convert_stream(struct airspy
*s
,
242 void *dst
, void *src
, unsigned int src_len
)
244 unsigned int dst_len
;
246 if (s
->pixelformat
== V4L2_SDR_FMT_RU12LE
) {
247 memcpy(dst
, src
, src_len
);
253 /* calculate samping rate and output it in 10 seconds intervals */
254 if (unlikely(time_is_before_jiffies(s
->jiffies_next
))) {
255 #define MSECS 10000UL
256 unsigned int samples
= s
->sample
- s
->sample_measured
;
258 s
->jiffies_next
= jiffies
+ msecs_to_jiffies(MSECS
);
259 s
->sample_measured
= s
->sample
;
260 dev_dbg(s
->dev
, "slen=%d samples=%u msecs=%lu sample rate=%lu\n",
261 src_len
, samples
, MSECS
,
262 samples
* 1000UL / MSECS
);
265 /* total number of samples */
266 s
->sample
+= src_len
/ 2;
272 * This gets called for the bulk stream pipe. This is done in interrupt
273 * time, so it has to be fast, not crash, and not stall. Neat.
275 static void airspy_urb_complete(struct urb
*urb
)
277 struct airspy
*s
= urb
->context
;
278 struct airspy_frame_buf
*fbuf
;
280 dev_dbg_ratelimited(s
->dev
, "status=%d length=%d/%d errors=%d\n",
281 urb
->status
, urb
->actual_length
,
282 urb
->transfer_buffer_length
, urb
->error_count
);
284 switch (urb
->status
) {
285 case 0: /* success */
286 case -ETIMEDOUT
: /* NAK */
288 case -ECONNRESET
: /* kill */
293 dev_err_ratelimited(s
->dev
, "URB failed %d\n", urb
->status
);
297 if (likely(urb
->actual_length
> 0)) {
300 /* get free framebuffer */
301 fbuf
= airspy_get_next_fill_buf(s
);
302 if (unlikely(fbuf
== NULL
)) {
304 dev_notice_ratelimited(s
->dev
,
305 "videobuf is full, %d packets dropped\n",
310 /* fill framebuffer */
311 ptr
= vb2_plane_vaddr(&fbuf
->vb
, 0);
312 len
= airspy_convert_stream(s
, ptr
, urb
->transfer_buffer
,
314 vb2_set_plane_payload(&fbuf
->vb
, 0, len
);
315 v4l2_get_timestamp(&fbuf
->vb
.v4l2_buf
.timestamp
);
316 fbuf
->vb
.v4l2_buf
.sequence
= s
->sequence
++;
317 vb2_buffer_done(&fbuf
->vb
, VB2_BUF_STATE_DONE
);
320 usb_submit_urb(urb
, GFP_ATOMIC
);
323 static int airspy_kill_urbs(struct airspy
*s
)
327 for (i
= s
->urbs_submitted
- 1; i
>= 0; i
--) {
328 dev_dbg(s
->dev
, "kill urb=%d\n", i
);
330 usb_kill_urb(s
->urb_list
[i
]);
332 s
->urbs_submitted
= 0;
337 static int airspy_submit_urbs(struct airspy
*s
)
341 for (i
= 0; i
< s
->urbs_initialized
; i
++) {
342 dev_dbg(s
->dev
, "submit urb=%d\n", i
);
343 ret
= usb_submit_urb(s
->urb_list
[i
], GFP_ATOMIC
);
345 dev_err(s
->dev
, "Could not submit URB no. %d - get them all back\n",
356 static int airspy_free_stream_bufs(struct airspy
*s
)
358 if (s
->flags
& USB_STATE_URB_BUF
) {
361 dev_dbg(s
->dev
, "free buf=%d\n", s
->buf_num
);
362 usb_free_coherent(s
->udev
, s
->buf_size
,
363 s
->buf_list
[s
->buf_num
],
364 s
->dma_addr
[s
->buf_num
]);
367 s
->flags
&= ~USB_STATE_URB_BUF
;
372 static int airspy_alloc_stream_bufs(struct airspy
*s
)
375 s
->buf_size
= BULK_BUFFER_SIZE
;
377 dev_dbg(s
->dev
, "all in all I will use %u bytes for streaming\n",
378 MAX_BULK_BUFS
* BULK_BUFFER_SIZE
);
380 for (s
->buf_num
= 0; s
->buf_num
< MAX_BULK_BUFS
; s
->buf_num
++) {
381 s
->buf_list
[s
->buf_num
] = usb_alloc_coherent(s
->udev
,
382 BULK_BUFFER_SIZE
, GFP_ATOMIC
,
383 &s
->dma_addr
[s
->buf_num
]);
384 if (!s
->buf_list
[s
->buf_num
]) {
385 dev_dbg(s
->dev
, "alloc buf=%d failed\n", s
->buf_num
);
386 airspy_free_stream_bufs(s
);
390 dev_dbg(s
->dev
, "alloc buf=%d %p (dma %llu)\n", s
->buf_num
,
391 s
->buf_list
[s
->buf_num
],
392 (long long)s
->dma_addr
[s
->buf_num
]);
393 s
->flags
|= USB_STATE_URB_BUF
;
399 static int airspy_free_urbs(struct airspy
*s
)
405 for (i
= s
->urbs_initialized
- 1; i
>= 0; i
--) {
406 if (s
->urb_list
[i
]) {
407 dev_dbg(s
->dev
, "free urb=%d\n", i
);
409 usb_free_urb(s
->urb_list
[i
]);
412 s
->urbs_initialized
= 0;
417 static int airspy_alloc_urbs(struct airspy
*s
)
421 /* allocate the URBs */
422 for (i
= 0; i
< MAX_BULK_BUFS
; i
++) {
423 dev_dbg(s
->dev
, "alloc urb=%d\n", i
);
424 s
->urb_list
[i
] = usb_alloc_urb(0, GFP_ATOMIC
);
425 if (!s
->urb_list
[i
]) {
426 dev_dbg(s
->dev
, "failed\n");
427 for (j
= 0; j
< i
; j
++)
428 usb_free_urb(s
->urb_list
[j
]);
431 usb_fill_bulk_urb(s
->urb_list
[i
],
433 usb_rcvbulkpipe(s
->udev
, 0x81),
436 airspy_urb_complete
, s
);
438 s
->urb_list
[i
]->transfer_flags
= URB_NO_TRANSFER_DMA_MAP
;
439 s
->urb_list
[i
]->transfer_dma
= s
->dma_addr
[i
];
440 s
->urbs_initialized
++;
446 /* Must be called with vb_queue_lock hold */
447 static void airspy_cleanup_queued_bufs(struct airspy
*s
)
451 dev_dbg(s
->dev
, "\n");
453 spin_lock_irqsave(&s
->queued_bufs_lock
, flags
);
454 while (!list_empty(&s
->queued_bufs
)) {
455 struct airspy_frame_buf
*buf
;
457 buf
= list_entry(s
->queued_bufs
.next
,
458 struct airspy_frame_buf
, list
);
459 list_del(&buf
->list
);
460 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
462 spin_unlock_irqrestore(&s
->queued_bufs_lock
, flags
);
465 /* The user yanked out the cable... */
466 static void airspy_disconnect(struct usb_interface
*intf
)
468 struct v4l2_device
*v
= usb_get_intfdata(intf
);
469 struct airspy
*s
= container_of(v
, struct airspy
, v4l2_dev
);
471 dev_dbg(s
->dev
, "\n");
473 mutex_lock(&s
->vb_queue_lock
);
474 mutex_lock(&s
->v4l2_lock
);
475 /* No need to keep the urbs around after disconnection */
477 v4l2_device_disconnect(&s
->v4l2_dev
);
478 video_unregister_device(&s
->vdev
);
479 mutex_unlock(&s
->v4l2_lock
);
480 mutex_unlock(&s
->vb_queue_lock
);
482 v4l2_device_put(&s
->v4l2_dev
);
485 /* Videobuf2 operations */
486 static int airspy_queue_setup(struct vb2_queue
*vq
,
487 const struct v4l2_format
*fmt
, unsigned int *nbuffers
,
488 unsigned int *nplanes
, unsigned int sizes
[], void *alloc_ctxs
[])
490 struct airspy
*s
= vb2_get_drv_priv(vq
);
492 dev_dbg(s
->dev
, "nbuffers=%d\n", *nbuffers
);
494 /* Need at least 8 buffers */
495 if (vq
->num_buffers
+ *nbuffers
< 8)
496 *nbuffers
= 8 - vq
->num_buffers
;
498 sizes
[0] = PAGE_ALIGN(s
->buffersize
);
500 dev_dbg(s
->dev
, "nbuffers=%d sizes[0]=%d\n", *nbuffers
, sizes
[0]);
504 static void airspy_buf_queue(struct vb2_buffer
*vb
)
506 struct airspy
*s
= vb2_get_drv_priv(vb
->vb2_queue
);
507 struct airspy_frame_buf
*buf
=
508 container_of(vb
, struct airspy_frame_buf
, vb
);
511 /* Check the device has not disconnected between prep and queuing */
512 if (unlikely(!s
->udev
)) {
513 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
517 spin_lock_irqsave(&s
->queued_bufs_lock
, flags
);
518 list_add_tail(&buf
->list
, &s
->queued_bufs
);
519 spin_unlock_irqrestore(&s
->queued_bufs_lock
, flags
);
522 static int airspy_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
524 struct airspy
*s
= vb2_get_drv_priv(vq
);
527 dev_dbg(s
->dev
, "\n");
532 mutex_lock(&s
->v4l2_lock
);
536 set_bit(POWER_ON
, &s
->flags
);
538 ret
= airspy_alloc_stream_bufs(s
);
542 ret
= airspy_alloc_urbs(s
);
544 goto err_free_stream_bufs
;
546 ret
= airspy_submit_urbs(s
);
550 /* start hardware streaming */
551 ret
= airspy_ctrl_msg(s
, CMD_RECEIVER_MODE
, 1, 0, NULL
, 0);
555 goto exit_mutex_unlock
;
561 err_free_stream_bufs
:
562 airspy_free_stream_bufs(s
);
564 clear_bit(POWER_ON
, &s
->flags
);
566 /* return all queued buffers to vb2 */
568 struct airspy_frame_buf
*buf
, *tmp
;
570 list_for_each_entry_safe(buf
, tmp
, &s
->queued_bufs
, list
) {
571 list_del(&buf
->list
);
572 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_QUEUED
);
577 mutex_unlock(&s
->v4l2_lock
);
582 static void airspy_stop_streaming(struct vb2_queue
*vq
)
584 struct airspy
*s
= vb2_get_drv_priv(vq
);
586 dev_dbg(s
->dev
, "\n");
588 mutex_lock(&s
->v4l2_lock
);
590 /* stop hardware streaming */
591 airspy_ctrl_msg(s
, CMD_RECEIVER_MODE
, 0, 0, NULL
, 0);
595 airspy_free_stream_bufs(s
);
597 airspy_cleanup_queued_bufs(s
);
599 clear_bit(POWER_ON
, &s
->flags
);
601 mutex_unlock(&s
->v4l2_lock
);
604 static struct vb2_ops airspy_vb2_ops
= {
605 .queue_setup
= airspy_queue_setup
,
606 .buf_queue
= airspy_buf_queue
,
607 .start_streaming
= airspy_start_streaming
,
608 .stop_streaming
= airspy_stop_streaming
,
609 .wait_prepare
= vb2_ops_wait_prepare
,
610 .wait_finish
= vb2_ops_wait_finish
,
613 static int airspy_querycap(struct file
*file
, void *fh
,
614 struct v4l2_capability
*cap
)
616 struct airspy
*s
= video_drvdata(file
);
618 strlcpy(cap
->driver
, KBUILD_MODNAME
, sizeof(cap
->driver
));
619 strlcpy(cap
->card
, s
->vdev
.name
, sizeof(cap
->card
));
620 usb_make_path(s
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
621 cap
->device_caps
= V4L2_CAP_SDR_CAPTURE
| V4L2_CAP_STREAMING
|
622 V4L2_CAP_READWRITE
| V4L2_CAP_TUNER
;
623 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
628 static int airspy_enum_fmt_sdr_cap(struct file
*file
, void *priv
,
629 struct v4l2_fmtdesc
*f
)
631 if (f
->index
>= NUM_FORMATS
)
634 strlcpy(f
->description
, formats
[f
->index
].name
, sizeof(f
->description
));
635 f
->pixelformat
= formats
[f
->index
].pixelformat
;
640 static int airspy_g_fmt_sdr_cap(struct file
*file
, void *priv
,
641 struct v4l2_format
*f
)
643 struct airspy
*s
= video_drvdata(file
);
645 f
->fmt
.sdr
.pixelformat
= s
->pixelformat
;
646 f
->fmt
.sdr
.buffersize
= s
->buffersize
;
647 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
652 static int airspy_s_fmt_sdr_cap(struct file
*file
, void *priv
,
653 struct v4l2_format
*f
)
655 struct airspy
*s
= video_drvdata(file
);
656 struct vb2_queue
*q
= &s
->vb_queue
;
662 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
663 for (i
= 0; i
< NUM_FORMATS
; i
++) {
664 if (formats
[i
].pixelformat
== f
->fmt
.sdr
.pixelformat
) {
665 s
->pixelformat
= formats
[i
].pixelformat
;
666 s
->buffersize
= formats
[i
].buffersize
;
667 f
->fmt
.sdr
.buffersize
= formats
[i
].buffersize
;
672 s
->pixelformat
= formats
[0].pixelformat
;
673 s
->buffersize
= formats
[0].buffersize
;
674 f
->fmt
.sdr
.pixelformat
= formats
[0].pixelformat
;
675 f
->fmt
.sdr
.buffersize
= formats
[0].buffersize
;
680 static int airspy_try_fmt_sdr_cap(struct file
*file
, void *priv
,
681 struct v4l2_format
*f
)
685 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
686 for (i
= 0; i
< NUM_FORMATS
; i
++) {
687 if (formats
[i
].pixelformat
== f
->fmt
.sdr
.pixelformat
) {
688 f
->fmt
.sdr
.buffersize
= formats
[i
].buffersize
;
693 f
->fmt
.sdr
.pixelformat
= formats
[0].pixelformat
;
694 f
->fmt
.sdr
.buffersize
= formats
[0].buffersize
;
699 static int airspy_s_tuner(struct file
*file
, void *priv
,
700 const struct v4l2_tuner
*v
)
706 else if (v
->index
== 1)
714 static int airspy_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*v
)
719 strlcpy(v
->name
, "AirSpy ADC", sizeof(v
->name
));
720 v
->type
= V4L2_TUNER_ADC
;
721 v
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
722 v
->rangelow
= bands
[0].rangelow
;
723 v
->rangehigh
= bands
[0].rangehigh
;
725 } else if (v
->index
== 1) {
726 strlcpy(v
->name
, "AirSpy RF", sizeof(v
->name
));
727 v
->type
= V4L2_TUNER_RF
;
728 v
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
729 v
->rangelow
= bands_rf
[0].rangelow
;
730 v
->rangehigh
= bands_rf
[0].rangehigh
;
739 static int airspy_g_frequency(struct file
*file
, void *priv
,
740 struct v4l2_frequency
*f
)
742 struct airspy
*s
= video_drvdata(file
);
746 f
->type
= V4L2_TUNER_ADC
;
747 f
->frequency
= s
->f_adc
;
748 dev_dbg(s
->dev
, "ADC frequency=%u Hz\n", s
->f_adc
);
750 } else if (f
->tuner
== 1) {
751 f
->type
= V4L2_TUNER_RF
;
752 f
->frequency
= s
->f_rf
;
753 dev_dbg(s
->dev
, "RF frequency=%u Hz\n", s
->f_rf
);
762 static int airspy_s_frequency(struct file
*file
, void *priv
,
763 const struct v4l2_frequency
*f
)
765 struct airspy
*s
= video_drvdata(file
);
770 s
->f_adc
= clamp_t(unsigned int, f
->frequency
,
773 dev_dbg(s
->dev
, "ADC frequency=%u Hz\n", s
->f_adc
);
775 } else if (f
->tuner
== 1) {
776 s
->f_rf
= clamp_t(unsigned int, f
->frequency
,
777 bands_rf
[0].rangelow
,
778 bands_rf
[0].rangehigh
);
779 dev_dbg(s
->dev
, "RF frequency=%u Hz\n", s
->f_rf
);
780 buf
[0] = (s
->f_rf
>> 0) & 0xff;
781 buf
[1] = (s
->f_rf
>> 8) & 0xff;
782 buf
[2] = (s
->f_rf
>> 16) & 0xff;
783 buf
[3] = (s
->f_rf
>> 24) & 0xff;
784 ret
= airspy_ctrl_msg(s
, CMD_SET_FREQ
, 0, 0, buf
, 4);
792 static int airspy_enum_freq_bands(struct file
*file
, void *priv
,
793 struct v4l2_frequency_band
*band
)
797 if (band
->tuner
== 0) {
798 if (band
->index
>= ARRAY_SIZE(bands
)) {
801 *band
= bands
[band
->index
];
804 } else if (band
->tuner
== 1) {
805 if (band
->index
>= ARRAY_SIZE(bands_rf
)) {
808 *band
= bands_rf
[band
->index
];
818 static const struct v4l2_ioctl_ops airspy_ioctl_ops
= {
819 .vidioc_querycap
= airspy_querycap
,
821 .vidioc_enum_fmt_sdr_cap
= airspy_enum_fmt_sdr_cap
,
822 .vidioc_g_fmt_sdr_cap
= airspy_g_fmt_sdr_cap
,
823 .vidioc_s_fmt_sdr_cap
= airspy_s_fmt_sdr_cap
,
824 .vidioc_try_fmt_sdr_cap
= airspy_try_fmt_sdr_cap
,
826 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
827 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
828 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
829 .vidioc_querybuf
= vb2_ioctl_querybuf
,
830 .vidioc_qbuf
= vb2_ioctl_qbuf
,
831 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
833 .vidioc_streamon
= vb2_ioctl_streamon
,
834 .vidioc_streamoff
= vb2_ioctl_streamoff
,
836 .vidioc_g_tuner
= airspy_g_tuner
,
837 .vidioc_s_tuner
= airspy_s_tuner
,
839 .vidioc_g_frequency
= airspy_g_frequency
,
840 .vidioc_s_frequency
= airspy_s_frequency
,
841 .vidioc_enum_freq_bands
= airspy_enum_freq_bands
,
843 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
844 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
845 .vidioc_log_status
= v4l2_ctrl_log_status
,
848 static const struct v4l2_file_operations airspy_fops
= {
849 .owner
= THIS_MODULE
,
850 .open
= v4l2_fh_open
,
851 .release
= vb2_fop_release
,
852 .read
= vb2_fop_read
,
853 .poll
= vb2_fop_poll
,
854 .mmap
= vb2_fop_mmap
,
855 .unlocked_ioctl
= video_ioctl2
,
858 static struct video_device airspy_template
= {
859 .name
= "AirSpy SDR",
860 .release
= video_device_release_empty
,
861 .fops
= &airspy_fops
,
862 .ioctl_ops
= &airspy_ioctl_ops
,
865 static void airspy_video_release(struct v4l2_device
*v
)
867 struct airspy
*s
= container_of(v
, struct airspy
, v4l2_dev
);
869 v4l2_ctrl_handler_free(&s
->hdl
);
870 v4l2_device_unregister(&s
->v4l2_dev
);
874 static int airspy_set_lna_gain(struct airspy
*s
)
879 dev_dbg(s
->dev
, "lna auto=%d->%d val=%d->%d\n",
880 s
->lna_gain_auto
->cur
.val
, s
->lna_gain_auto
->val
,
881 s
->lna_gain
->cur
.val
, s
->lna_gain
->val
);
883 ret
= airspy_ctrl_msg(s
, CMD_SET_LNA_AGC
, 0, s
->lna_gain_auto
->val
,
888 if (s
->lna_gain_auto
->val
== false) {
889 ret
= airspy_ctrl_msg(s
, CMD_SET_LNA_GAIN
, 0, s
->lna_gain
->val
,
896 dev_dbg(s
->dev
, "failed=%d\n", ret
);
901 static int airspy_set_mixer_gain(struct airspy
*s
)
906 dev_dbg(s
->dev
, "mixer auto=%d->%d val=%d->%d\n",
907 s
->mixer_gain_auto
->cur
.val
, s
->mixer_gain_auto
->val
,
908 s
->mixer_gain
->cur
.val
, s
->mixer_gain
->val
);
910 ret
= airspy_ctrl_msg(s
, CMD_SET_MIXER_AGC
, 0, s
->mixer_gain_auto
->val
,
915 if (s
->mixer_gain_auto
->val
== false) {
916 ret
= airspy_ctrl_msg(s
, CMD_SET_MIXER_GAIN
, 0,
917 s
->mixer_gain
->val
, &u8tmp
, 1);
923 dev_dbg(s
->dev
, "failed=%d\n", ret
);
928 static int airspy_set_if_gain(struct airspy
*s
)
933 dev_dbg(s
->dev
, "val=%d->%d\n", s
->if_gain
->cur
.val
, s
->if_gain
->val
);
935 ret
= airspy_ctrl_msg(s
, CMD_SET_VGA_GAIN
, 0, s
->if_gain
->val
,
941 dev_dbg(s
->dev
, "failed=%d\n", ret
);
946 static int airspy_s_ctrl(struct v4l2_ctrl
*ctrl
)
948 struct airspy
*s
= container_of(ctrl
->handler
, struct airspy
, hdl
);
952 case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO
:
953 case V4L2_CID_RF_TUNER_LNA_GAIN
:
954 ret
= airspy_set_lna_gain(s
);
956 case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO
:
957 case V4L2_CID_RF_TUNER_MIXER_GAIN
:
958 ret
= airspy_set_mixer_gain(s
);
960 case V4L2_CID_RF_TUNER_IF_GAIN
:
961 ret
= airspy_set_if_gain(s
);
964 dev_dbg(s
->dev
, "unknown ctrl: id=%d name=%s\n",
965 ctrl
->id
, ctrl
->name
);
972 static const struct v4l2_ctrl_ops airspy_ctrl_ops
= {
973 .s_ctrl
= airspy_s_ctrl
,
976 static int airspy_probe(struct usb_interface
*intf
,
977 const struct usb_device_id
*id
)
981 u8 u8tmp
, buf
[BUF_SIZE
];
983 s
= kzalloc(sizeof(struct airspy
), GFP_KERNEL
);
985 dev_err(&intf
->dev
, "Could not allocate memory for state\n");
989 mutex_init(&s
->v4l2_lock
);
990 mutex_init(&s
->vb_queue_lock
);
991 spin_lock_init(&s
->queued_bufs_lock
);
992 INIT_LIST_HEAD(&s
->queued_bufs
);
994 s
->udev
= interface_to_usbdev(intf
);
995 s
->f_adc
= bands
[0].rangelow
;
996 s
->f_rf
= bands_rf
[0].rangelow
;
997 s
->pixelformat
= formats
[0].pixelformat
;
998 s
->buffersize
= formats
[0].buffersize
;
1001 ret
= airspy_ctrl_msg(s
, CMD_BOARD_ID_READ
, 0, 0, &u8tmp
, 1);
1003 ret
= airspy_ctrl_msg(s
, CMD_VERSION_STRING_READ
, 0, 0,
1006 dev_err(s
->dev
, "Could not detect board\n");
1010 buf
[BUF_SIZE
- 1] = '\0';
1012 dev_info(s
->dev
, "Board ID: %02x\n", u8tmp
);
1013 dev_info(s
->dev
, "Firmware version: %s\n", buf
);
1015 /* Init videobuf2 queue structure */
1016 s
->vb_queue
.type
= V4L2_BUF_TYPE_SDR_CAPTURE
;
1017 s
->vb_queue
.io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_READ
;
1018 s
->vb_queue
.drv_priv
= s
;
1019 s
->vb_queue
.buf_struct_size
= sizeof(struct airspy_frame_buf
);
1020 s
->vb_queue
.ops
= &airspy_vb2_ops
;
1021 s
->vb_queue
.mem_ops
= &vb2_vmalloc_memops
;
1022 s
->vb_queue
.timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1023 ret
= vb2_queue_init(&s
->vb_queue
);
1025 dev_err(s
->dev
, "Could not initialize vb2 queue\n");
1029 /* Init video_device structure */
1030 s
->vdev
= airspy_template
;
1031 s
->vdev
.queue
= &s
->vb_queue
;
1032 s
->vdev
.queue
->lock
= &s
->vb_queue_lock
;
1033 video_set_drvdata(&s
->vdev
, s
);
1035 /* Register the v4l2_device structure */
1036 s
->v4l2_dev
.release
= airspy_video_release
;
1037 ret
= v4l2_device_register(&intf
->dev
, &s
->v4l2_dev
);
1039 dev_err(s
->dev
, "Failed to register v4l2-device (%d)\n", ret
);
1043 /* Register controls */
1044 v4l2_ctrl_handler_init(&s
->hdl
, 5);
1045 s
->lna_gain_auto
= v4l2_ctrl_new_std(&s
->hdl
, &airspy_ctrl_ops
,
1046 V4L2_CID_RF_TUNER_LNA_GAIN_AUTO
, 0, 1, 1, 0);
1047 s
->lna_gain
= v4l2_ctrl_new_std(&s
->hdl
, &airspy_ctrl_ops
,
1048 V4L2_CID_RF_TUNER_LNA_GAIN
, 0, 14, 1, 8);
1049 v4l2_ctrl_auto_cluster(2, &s
->lna_gain_auto
, 0, false);
1050 s
->mixer_gain_auto
= v4l2_ctrl_new_std(&s
->hdl
, &airspy_ctrl_ops
,
1051 V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO
, 0, 1, 1, 0);
1052 s
->mixer_gain
= v4l2_ctrl_new_std(&s
->hdl
, &airspy_ctrl_ops
,
1053 V4L2_CID_RF_TUNER_MIXER_GAIN
, 0, 15, 1, 8);
1054 v4l2_ctrl_auto_cluster(2, &s
->mixer_gain_auto
, 0, false);
1055 s
->if_gain
= v4l2_ctrl_new_std(&s
->hdl
, &airspy_ctrl_ops
,
1056 V4L2_CID_RF_TUNER_IF_GAIN
, 0, 15, 1, 0);
1059 dev_err(s
->dev
, "Could not initialize controls\n");
1060 goto err_free_controls
;
1063 v4l2_ctrl_handler_setup(&s
->hdl
);
1065 s
->v4l2_dev
.ctrl_handler
= &s
->hdl
;
1066 s
->vdev
.v4l2_dev
= &s
->v4l2_dev
;
1067 s
->vdev
.lock
= &s
->v4l2_lock
;
1069 ret
= video_register_device(&s
->vdev
, VFL_TYPE_SDR
, -1);
1071 dev_err(s
->dev
, "Failed to register as video device (%d)\n",
1073 goto err_unregister_v4l2_dev
;
1075 dev_info(s
->dev
, "Registered as %s\n",
1076 video_device_node_name(&s
->vdev
));
1077 dev_notice(s
->dev
, "SDR API is still slightly experimental and functionality changes may follow\n");
1081 v4l2_ctrl_handler_free(&s
->hdl
);
1082 err_unregister_v4l2_dev
:
1083 v4l2_device_unregister(&s
->v4l2_dev
);
1089 /* USB device ID list */
1090 static struct usb_device_id airspy_id_table
[] = {
1091 { USB_DEVICE(0x1d50, 0x60a1) }, /* AirSpy */
1094 MODULE_DEVICE_TABLE(usb
, airspy_id_table
);
1096 /* USB subsystem interface */
1097 static struct usb_driver airspy_driver
= {
1098 .name
= KBUILD_MODNAME
,
1099 .probe
= airspy_probe
,
1100 .disconnect
= airspy_disconnect
,
1101 .id_table
= airspy_id_table
,
1104 module_usb_driver(airspy_driver
);
1106 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1107 MODULE_DESCRIPTION("AirSpy SDR");
1108 MODULE_LICENSE("GPL");