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-v4l2.h>
25 #include <media/videobuf2-vmalloc.h>
28 * Used Avago MGA-81563 RF amplifier could be destroyed pretty easily with too
29 * strong signal or transmitting to bad antenna.
30 * Set RF gain control to 'grabbed' state by default for sure.
32 static bool hackrf_enable_rf_gain_ctrl
;
33 module_param_named(enable_rf_gain_ctrl
, hackrf_enable_rf_gain_ctrl
, bool, 0644);
34 MODULE_PARM_DESC(enable_rf_gain_ctrl
, "enable RX/TX RF amplifier control (warn: could damage amplifier)");
36 /* HackRF USB API commands (from HackRF Library) */
38 CMD_SET_TRANSCEIVER_MODE
= 0x01,
39 CMD_SAMPLE_RATE_SET
= 0x06,
40 CMD_BASEBAND_FILTER_BANDWIDTH_SET
= 0x07,
41 CMD_BOARD_ID_READ
= 0x0e,
42 CMD_VERSION_STRING_READ
= 0x0f,
44 CMD_AMP_ENABLE
= 0x11,
45 CMD_SET_LNA_GAIN
= 0x13,
46 CMD_SET_VGA_GAIN
= 0x14,
47 CMD_SET_TXVGA_GAIN
= 0x15,
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_adc_dac
[] = {
61 .type
= V4L2_TUNER_SDR
,
63 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
65 .rangehigh
= 24000000,
69 static const struct v4l2_frequency_band bands_rx_tx
[] = {
72 .type
= V4L2_TUNER_RF
,
74 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
76 .rangehigh
= 4294967294LL, /* max u32, hw goes over 7GHz */
81 struct hackrf_format
{
86 /* format descriptions for capture and preview */
87 static struct hackrf_format formats
[] = {
89 .pixelformat
= V4L2_SDR_FMT_CS8
,
90 .buffersize
= BULK_BUFFER_SIZE
,
94 static const unsigned int NUM_FORMATS
= ARRAY_SIZE(formats
);
96 /* intermediate buffers with raw data from the USB device */
97 struct hackrf_buffer
{
98 struct vb2_v4l2_buffer vb
;
99 struct list_head list
;
103 #define USB_STATE_URB_BUF 1 /* XXX: set manually */
106 #define RX_ADC_FREQUENCY 11
107 #define TX_DAC_FREQUENCY 12
108 #define RX_BANDWIDTH 13
109 #define TX_BANDWIDTH 14
110 #define RX_RF_FREQUENCY 15
111 #define TX_RF_FREQUENCY 16
112 #define RX_RF_GAIN 17
113 #define TX_RF_GAIN 18
114 #define RX_IF_GAIN 19
115 #define RX_LNA_GAIN 20
116 #define TX_LNA_GAIN 21
119 struct usb_interface
*intf
;
121 struct usb_device
*udev
;
122 struct video_device rx_vdev
;
123 struct video_device tx_vdev
;
124 struct v4l2_device v4l2_dev
;
126 /* videobuf2 queue and queued buffers list */
127 struct vb2_queue rx_vb2_queue
;
128 struct vb2_queue tx_vb2_queue
;
129 struct list_head rx_buffer_list
;
130 struct list_head tx_buffer_list
;
131 spinlock_t buffer_list_lock
; /* Protects buffer_list */
132 unsigned int sequence
; /* Buffer sequence counter */
133 unsigned int vb_full
; /* vb is full and packets dropped */
134 unsigned int vb_empty
; /* vb is empty and packets dropped */
136 /* Note if taking both locks v4l2_lock must always be locked first! */
137 struct mutex v4l2_lock
; /* Protects everything else */
138 struct mutex vb_queue_lock
; /* Protects vb_queue */
140 struct urb
*urb_list
[MAX_BULK_BUFS
];
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
;
148 /* USB control message buffer */
152 /* Current configuration */
161 struct v4l2_ctrl_handler rx_ctrl_handler
;
162 struct v4l2_ctrl
*rx_bandwidth_auto
;
163 struct v4l2_ctrl
*rx_bandwidth
;
164 struct v4l2_ctrl
*rx_rf_gain
;
165 struct v4l2_ctrl
*rx_lna_gain
;
166 struct v4l2_ctrl
*rx_if_gain
;
167 struct v4l2_ctrl_handler tx_ctrl_handler
;
168 struct v4l2_ctrl
*tx_bandwidth_auto
;
169 struct v4l2_ctrl
*tx_bandwidth
;
170 struct v4l2_ctrl
*tx_rf_gain
;
171 struct v4l2_ctrl
*tx_lna_gain
;
173 /* Sample rate calc */
174 unsigned long jiffies_next
;
176 unsigned int sample_measured
;
179 #define hackrf_dbg_usb_control_msg(_dev, _r, _t, _v, _i, _b, _l) { \
181 if (_t & USB_DIR_IN) \
182 _direction = "<<<"; \
184 _direction = ">>>"; \
185 dev_dbg(_dev, "%02x %02x %02x %02x %02x %02x %02x %02x %s %*ph\n", \
186 _t, _r, _v & 0xff, _v >> 8, _i & 0xff, \
187 _i >> 8, _l & 0xff, _l >> 8, _direction, _l, _b); \
190 /* execute firmware command */
191 static int hackrf_ctrl_msg(struct hackrf_dev
*dev
, u8 request
, u16 value
,
192 u16 index
, u8
*data
, u16 size
)
199 case CMD_SET_TRANSCEIVER_MODE
:
202 case CMD_SAMPLE_RATE_SET
:
203 case CMD_BASEBAND_FILTER_BANDWIDTH_SET
:
204 pipe
= usb_sndctrlpipe(dev
->udev
, 0);
205 requesttype
= (USB_TYPE_VENDOR
| USB_DIR_OUT
);
207 case CMD_BOARD_ID_READ
:
208 case CMD_VERSION_STRING_READ
:
209 case CMD_SET_LNA_GAIN
:
210 case CMD_SET_VGA_GAIN
:
211 case CMD_SET_TXVGA_GAIN
:
212 pipe
= usb_rcvctrlpipe(dev
->udev
, 0);
213 requesttype
= (USB_TYPE_VENDOR
| USB_DIR_IN
);
216 dev_err(dev
->dev
, "Unknown command %02x\n", request
);
222 if (!(requesttype
& USB_DIR_IN
))
223 memcpy(dev
->buf
, data
, size
);
225 ret
= usb_control_msg(dev
->udev
, pipe
, request
, requesttype
, value
,
226 index
, dev
->buf
, size
, 1000);
227 hackrf_dbg_usb_control_msg(dev
->dev
, request
, requesttype
, value
,
228 index
, dev
->buf
, size
);
230 dev_err(dev
->dev
, "usb_control_msg() failed %d request %02x\n",
236 if (requesttype
& USB_DIR_IN
)
237 memcpy(data
, dev
->buf
, size
);
244 static int hackrf_set_params(struct hackrf_dev
*dev
)
246 struct usb_interface
*intf
= dev
->intf
;
249 unsigned int uitmp
, uitmp1
, uitmp2
;
250 const bool rx
= test_bit(RX_ON
, &dev
->flags
);
251 const bool tx
= test_bit(TX_ON
, &dev
->flags
);
252 static const struct {
254 } bandwidth_lut
[] = {
255 { 1750000}, /* 1.75 MHz */
256 { 2500000}, /* 2.5 MHz */
257 { 3500000}, /* 3.5 MHz */
258 { 5000000}, /* 5 MHz */
259 { 5500000}, /* 5.5 MHz */
260 { 6000000}, /* 6 MHz */
261 { 7000000}, /* 7 MHz */
262 { 8000000}, /* 8 MHz */
263 { 9000000}, /* 9 MHz */
264 {10000000}, /* 10 MHz */
265 {12000000}, /* 12 MHz */
266 {14000000}, /* 14 MHz */
267 {15000000}, /* 15 MHz */
268 {20000000}, /* 20 MHz */
269 {24000000}, /* 24 MHz */
270 {28000000}, /* 28 MHz */
274 dev_dbg(&intf
->dev
, "device is sleeping\n");
278 /* ADC / DAC frequency */
279 if (rx
&& test_and_clear_bit(RX_ADC_FREQUENCY
, &dev
->flags
)) {
280 dev_dbg(&intf
->dev
, "RX ADC frequency=%u Hz\n", dev
->f_adc
);
283 set_bit(TX_DAC_FREQUENCY
, &dev
->flags
);
284 } else if (tx
&& test_and_clear_bit(TX_DAC_FREQUENCY
, &dev
->flags
)) {
285 dev_dbg(&intf
->dev
, "TX DAC frequency=%u Hz\n", dev
->f_dac
);
288 set_bit(RX_ADC_FREQUENCY
, &dev
->flags
);
292 if (uitmp1
|| uitmp2
) {
293 buf
[0] = (uitmp1
>> 0) & 0xff;
294 buf
[1] = (uitmp1
>> 8) & 0xff;
295 buf
[2] = (uitmp1
>> 16) & 0xff;
296 buf
[3] = (uitmp1
>> 24) & 0xff;
297 buf
[4] = (uitmp2
>> 0) & 0xff;
298 buf
[5] = (uitmp2
>> 8) & 0xff;
299 buf
[6] = (uitmp2
>> 16) & 0xff;
300 buf
[7] = (uitmp2
>> 24) & 0xff;
301 ret
= hackrf_ctrl_msg(dev
, CMD_SAMPLE_RATE_SET
, 0, 0, buf
, 8);
307 if (rx
&& test_and_clear_bit(RX_BANDWIDTH
, &dev
->flags
)) {
308 if (dev
->rx_bandwidth_auto
->val
== true)
311 uitmp
= dev
->rx_bandwidth
->val
;
313 for (i
= 0; i
< ARRAY_SIZE(bandwidth_lut
); i
++) {
314 if (uitmp
<= bandwidth_lut
[i
].freq
) {
315 uitmp
= bandwidth_lut
[i
].freq
;
319 dev
->rx_bandwidth
->val
= uitmp
;
320 dev
->rx_bandwidth
->cur
.val
= uitmp
;
321 dev_dbg(&intf
->dev
, "RX bandwidth selected=%u\n", uitmp
);
322 set_bit(TX_BANDWIDTH
, &dev
->flags
);
323 } else if (tx
&& test_and_clear_bit(TX_BANDWIDTH
, &dev
->flags
)) {
324 if (dev
->tx_bandwidth_auto
->val
== true)
327 uitmp
= dev
->tx_bandwidth
->val
;
329 for (i
= 0; i
< ARRAY_SIZE(bandwidth_lut
); i
++) {
330 if (uitmp
<= bandwidth_lut
[i
].freq
) {
331 uitmp
= bandwidth_lut
[i
].freq
;
335 dev
->tx_bandwidth
->val
= uitmp
;
336 dev
->tx_bandwidth
->cur
.val
= uitmp
;
337 dev_dbg(&intf
->dev
, "TX bandwidth selected=%u\n", uitmp
);
338 set_bit(RX_BANDWIDTH
, &dev
->flags
);
344 uitmp1
|= ((uitmp
>> 0) & 0xff) << 0;
345 uitmp1
|= ((uitmp
>> 8) & 0xff) << 8;
346 uitmp2
|= ((uitmp
>> 16) & 0xff) << 0;
347 uitmp2
|= ((uitmp
>> 24) & 0xff) << 8;
348 ret
= hackrf_ctrl_msg(dev
, CMD_BASEBAND_FILTER_BANDWIDTH_SET
,
349 uitmp1
, uitmp2
, NULL
, 0);
354 /* RX / TX RF frequency */
355 if (rx
&& test_and_clear_bit(RX_RF_FREQUENCY
, &dev
->flags
)) {
356 dev_dbg(&intf
->dev
, "RX RF frequency=%u Hz\n", dev
->f_rx
);
357 uitmp1
= dev
->f_rx
/ 1000000;
358 uitmp2
= dev
->f_rx
% 1000000;
359 set_bit(TX_RF_FREQUENCY
, &dev
->flags
);
360 } else if (tx
&& test_and_clear_bit(TX_RF_FREQUENCY
, &dev
->flags
)) {
361 dev_dbg(&intf
->dev
, "TX RF frequency=%u Hz\n", dev
->f_tx
);
362 uitmp1
= dev
->f_tx
/ 1000000;
363 uitmp2
= dev
->f_tx
% 1000000;
364 set_bit(RX_RF_FREQUENCY
, &dev
->flags
);
368 if (uitmp1
|| uitmp2
) {
369 buf
[0] = (uitmp1
>> 0) & 0xff;
370 buf
[1] = (uitmp1
>> 8) & 0xff;
371 buf
[2] = (uitmp1
>> 16) & 0xff;
372 buf
[3] = (uitmp1
>> 24) & 0xff;
373 buf
[4] = (uitmp2
>> 0) & 0xff;
374 buf
[5] = (uitmp2
>> 8) & 0xff;
375 buf
[6] = (uitmp2
>> 16) & 0xff;
376 buf
[7] = (uitmp2
>> 24) & 0xff;
377 ret
= hackrf_ctrl_msg(dev
, CMD_SET_FREQ
, 0, 0, buf
, 8);
383 if (rx
&& test_and_clear_bit(RX_RF_GAIN
, &dev
->flags
)) {
384 dev_dbg(&intf
->dev
, "RX RF gain val=%d->%d\n",
385 dev
->rx_rf_gain
->cur
.val
, dev
->rx_rf_gain
->val
);
387 u8tmp
= (dev
->rx_rf_gain
->val
) ? 1 : 0;
388 ret
= hackrf_ctrl_msg(dev
, CMD_AMP_ENABLE
, u8tmp
, 0, NULL
, 0);
391 set_bit(TX_RF_GAIN
, &dev
->flags
);
395 if (tx
&& test_and_clear_bit(TX_RF_GAIN
, &dev
->flags
)) {
396 dev_dbg(&intf
->dev
, "TX RF gain val=%d->%d\n",
397 dev
->tx_rf_gain
->cur
.val
, dev
->tx_rf_gain
->val
);
399 u8tmp
= (dev
->tx_rf_gain
->val
) ? 1 : 0;
400 ret
= hackrf_ctrl_msg(dev
, CMD_AMP_ENABLE
, u8tmp
, 0, NULL
, 0);
403 set_bit(RX_RF_GAIN
, &dev
->flags
);
407 if (rx
&& test_and_clear_bit(RX_LNA_GAIN
, &dev
->flags
)) {
408 dev_dbg(dev
->dev
, "RX LNA gain val=%d->%d\n",
409 dev
->rx_lna_gain
->cur
.val
, dev
->rx_lna_gain
->val
);
411 ret
= hackrf_ctrl_msg(dev
, CMD_SET_LNA_GAIN
, 0,
412 dev
->rx_lna_gain
->val
, &u8tmp
, 1);
418 if (rx
&& test_and_clear_bit(RX_IF_GAIN
, &dev
->flags
)) {
419 dev_dbg(&intf
->dev
, "IF gain val=%d->%d\n",
420 dev
->rx_if_gain
->cur
.val
, dev
->rx_if_gain
->val
);
422 ret
= hackrf_ctrl_msg(dev
, CMD_SET_VGA_GAIN
, 0,
423 dev
->rx_if_gain
->val
, &u8tmp
, 1);
429 if (tx
&& test_and_clear_bit(TX_LNA_GAIN
, &dev
->flags
)) {
430 dev_dbg(&intf
->dev
, "TX LNA gain val=%d->%d\n",
431 dev
->tx_lna_gain
->cur
.val
, dev
->tx_lna_gain
->val
);
433 ret
= hackrf_ctrl_msg(dev
, CMD_SET_TXVGA_GAIN
, 0,
434 dev
->tx_lna_gain
->val
, &u8tmp
, 1);
441 dev_dbg(&intf
->dev
, "failed=%d\n", ret
);
445 /* Private functions */
446 static struct hackrf_buffer
*hackrf_get_next_buffer(struct hackrf_dev
*dev
,
447 struct list_head
*buffer_list
)
450 struct hackrf_buffer
*buffer
= NULL
;
452 spin_lock_irqsave(&dev
->buffer_list_lock
, flags
);
453 if (list_empty(buffer_list
))
456 buffer
= list_entry(buffer_list
->next
, struct hackrf_buffer
, list
);
457 list_del(&buffer
->list
);
459 spin_unlock_irqrestore(&dev
->buffer_list_lock
, flags
);
463 static void hackrf_copy_stream(struct hackrf_dev
*dev
, void *dst
, void *src
,
464 unsigned int src_len
)
466 memcpy(dst
, src
, src_len
);
468 /* calculate sample rate and output it in 10 seconds intervals */
469 if (unlikely(time_is_before_jiffies(dev
->jiffies_next
))) {
470 #define MSECS 10000UL
471 unsigned int msecs
= jiffies_to_msecs(jiffies
-
472 dev
->jiffies_next
+ msecs_to_jiffies(MSECS
));
473 unsigned int samples
= dev
->sample
- dev
->sample_measured
;
475 dev
->jiffies_next
= jiffies
+ msecs_to_jiffies(MSECS
);
476 dev
->sample_measured
= dev
->sample
;
477 dev_dbg(dev
->dev
, "slen=%u samples=%u msecs=%u sample rate=%lu\n",
478 src_len
, samples
, msecs
,
479 samples
* 1000UL / msecs
);
482 /* total number of samples */
483 dev
->sample
+= src_len
/ 2;
487 * This gets called for the bulk stream pipe. This is done in interrupt
488 * time, so it has to be fast, not crash, and not stall. Neat.
490 static void hackrf_urb_complete_in(struct urb
*urb
)
492 struct hackrf_dev
*dev
= urb
->context
;
493 struct usb_interface
*intf
= dev
->intf
;
494 struct hackrf_buffer
*buffer
;
497 dev_dbg_ratelimited(&intf
->dev
, "status=%d length=%u/%u\n", urb
->status
,
498 urb
->actual_length
, urb
->transfer_buffer_length
);
500 switch (urb
->status
) {
501 case 0: /* success */
502 case -ETIMEDOUT
: /* NAK */
504 case -ECONNRESET
: /* kill */
509 dev_err_ratelimited(&intf
->dev
, "URB failed %d\n", urb
->status
);
510 goto exit_usb_submit_urb
;
513 /* get buffer to write */
514 buffer
= hackrf_get_next_buffer(dev
, &dev
->rx_buffer_list
);
515 if (unlikely(buffer
== NULL
)) {
517 dev_notice_ratelimited(&intf
->dev
,
518 "buffer is full - %u packets dropped\n",
520 goto exit_usb_submit_urb
;
523 len
= min_t(unsigned long, vb2_plane_size(&buffer
->vb
.vb2_buf
, 0),
525 hackrf_copy_stream(dev
, vb2_plane_vaddr(&buffer
->vb
.vb2_buf
, 0),
526 urb
->transfer_buffer
, len
);
527 vb2_set_plane_payload(&buffer
->vb
.vb2_buf
, 0, len
);
528 buffer
->vb
.sequence
= dev
->sequence
++;
529 buffer
->vb
.vb2_buf
.timestamp
= ktime_get_ns();
530 vb2_buffer_done(&buffer
->vb
.vb2_buf
, VB2_BUF_STATE_DONE
);
532 usb_submit_urb(urb
, GFP_ATOMIC
);
535 static void hackrf_urb_complete_out(struct urb
*urb
)
537 struct hackrf_dev
*dev
= urb
->context
;
538 struct usb_interface
*intf
= dev
->intf
;
539 struct hackrf_buffer
*buffer
;
542 dev_dbg_ratelimited(&intf
->dev
, "status=%d length=%u/%u\n", urb
->status
,
543 urb
->actual_length
, urb
->transfer_buffer_length
);
545 switch (urb
->status
) {
546 case 0: /* success */
547 case -ETIMEDOUT
: /* NAK */
549 case -ECONNRESET
: /* kill */
554 dev_err_ratelimited(&intf
->dev
, "URB failed %d\n", urb
->status
);
557 /* get buffer to read */
558 buffer
= hackrf_get_next_buffer(dev
, &dev
->tx_buffer_list
);
559 if (unlikely(buffer
== NULL
)) {
561 dev_notice_ratelimited(&intf
->dev
,
562 "buffer is empty - %u packets dropped\n",
564 urb
->actual_length
= 0;
565 goto exit_usb_submit_urb
;
568 len
= min_t(unsigned long, urb
->transfer_buffer_length
,
569 vb2_get_plane_payload(&buffer
->vb
.vb2_buf
, 0));
570 hackrf_copy_stream(dev
, urb
->transfer_buffer
,
571 vb2_plane_vaddr(&buffer
->vb
.vb2_buf
, 0), len
);
572 urb
->actual_length
= len
;
573 buffer
->vb
.sequence
= dev
->sequence
++;
574 buffer
->vb
.vb2_buf
.timestamp
= ktime_get_ns();
575 vb2_buffer_done(&buffer
->vb
.vb2_buf
, VB2_BUF_STATE_DONE
);
577 usb_submit_urb(urb
, GFP_ATOMIC
);
580 static int hackrf_kill_urbs(struct hackrf_dev
*dev
)
584 for (i
= dev
->urbs_submitted
- 1; i
>= 0; i
--) {
585 dev_dbg(dev
->dev
, "kill urb=%d\n", i
);
587 usb_kill_urb(dev
->urb_list
[i
]);
589 dev
->urbs_submitted
= 0;
594 static int hackrf_submit_urbs(struct hackrf_dev
*dev
)
598 for (i
= 0; i
< dev
->urbs_initialized
; i
++) {
599 dev_dbg(dev
->dev
, "submit urb=%d\n", i
);
600 ret
= usb_submit_urb(dev
->urb_list
[i
], GFP_ATOMIC
);
602 dev_err(dev
->dev
, "Could not submit URB no. %d - get them all back\n",
604 hackrf_kill_urbs(dev
);
607 dev
->urbs_submitted
++;
613 static int hackrf_free_stream_bufs(struct hackrf_dev
*dev
)
615 if (dev
->flags
& USB_STATE_URB_BUF
) {
616 while (dev
->buf_num
) {
618 dev_dbg(dev
->dev
, "free buf=%d\n", dev
->buf_num
);
619 usb_free_coherent(dev
->udev
, dev
->buf_size
,
620 dev
->buf_list
[dev
->buf_num
],
621 dev
->dma_addr
[dev
->buf_num
]);
624 dev
->flags
&= ~USB_STATE_URB_BUF
;
629 static int hackrf_alloc_stream_bufs(struct hackrf_dev
*dev
)
632 dev
->buf_size
= BULK_BUFFER_SIZE
;
634 dev_dbg(dev
->dev
, "all in all I will use %u bytes for streaming\n",
635 MAX_BULK_BUFS
* BULK_BUFFER_SIZE
);
637 for (dev
->buf_num
= 0; dev
->buf_num
< MAX_BULK_BUFS
; dev
->buf_num
++) {
638 dev
->buf_list
[dev
->buf_num
] = usb_alloc_coherent(dev
->udev
,
639 BULK_BUFFER_SIZE
, GFP_ATOMIC
,
640 &dev
->dma_addr
[dev
->buf_num
]);
641 if (!dev
->buf_list
[dev
->buf_num
]) {
642 dev_dbg(dev
->dev
, "alloc buf=%d failed\n",
644 hackrf_free_stream_bufs(dev
);
648 dev_dbg(dev
->dev
, "alloc buf=%d %p (dma %llu)\n", dev
->buf_num
,
649 dev
->buf_list
[dev
->buf_num
],
650 (long long)dev
->dma_addr
[dev
->buf_num
]);
651 dev
->flags
|= USB_STATE_URB_BUF
;
657 static int hackrf_free_urbs(struct hackrf_dev
*dev
)
661 hackrf_kill_urbs(dev
);
663 for (i
= dev
->urbs_initialized
- 1; i
>= 0; i
--) {
664 if (dev
->urb_list
[i
]) {
665 dev_dbg(dev
->dev
, "free urb=%d\n", i
);
667 usb_free_urb(dev
->urb_list
[i
]);
670 dev
->urbs_initialized
= 0;
675 static int hackrf_alloc_urbs(struct hackrf_dev
*dev
, bool rcv
)
679 usb_complete_t complete
;
682 pipe
= usb_rcvbulkpipe(dev
->udev
, 0x81);
683 complete
= &hackrf_urb_complete_in
;
685 pipe
= usb_sndbulkpipe(dev
->udev
, 0x02);
686 complete
= &hackrf_urb_complete_out
;
689 /* allocate the URBs */
690 for (i
= 0; i
< MAX_BULK_BUFS
; i
++) {
691 dev_dbg(dev
->dev
, "alloc urb=%d\n", i
);
692 dev
->urb_list
[i
] = usb_alloc_urb(0, GFP_ATOMIC
);
693 if (!dev
->urb_list
[i
]) {
694 for (j
= 0; j
< i
; j
++)
695 usb_free_urb(dev
->urb_list
[j
]);
698 usb_fill_bulk_urb(dev
->urb_list
[i
],
705 dev
->urb_list
[i
]->transfer_flags
= URB_NO_TRANSFER_DMA_MAP
;
706 dev
->urb_list
[i
]->transfer_dma
= dev
->dma_addr
[i
];
707 dev
->urbs_initialized
++;
713 /* The user yanked out the cable... */
714 static void hackrf_disconnect(struct usb_interface
*intf
)
716 struct v4l2_device
*v
= usb_get_intfdata(intf
);
717 struct hackrf_dev
*dev
= container_of(v
, struct hackrf_dev
, v4l2_dev
);
719 dev_dbg(dev
->dev
, "\n");
721 mutex_lock(&dev
->vb_queue_lock
);
722 mutex_lock(&dev
->v4l2_lock
);
723 /* No need to keep the urbs around after disconnection */
725 v4l2_device_disconnect(&dev
->v4l2_dev
);
726 video_unregister_device(&dev
->tx_vdev
);
727 video_unregister_device(&dev
->rx_vdev
);
728 mutex_unlock(&dev
->v4l2_lock
);
729 mutex_unlock(&dev
->vb_queue_lock
);
731 v4l2_device_put(&dev
->v4l2_dev
);
734 /* Videobuf2 operations */
735 static void hackrf_return_all_buffers(struct vb2_queue
*vq
,
736 enum vb2_buffer_state state
)
738 struct hackrf_dev
*dev
= vb2_get_drv_priv(vq
);
739 struct usb_interface
*intf
= dev
->intf
;
740 struct hackrf_buffer
*buffer
, *node
;
741 struct list_head
*buffer_list
;
744 dev_dbg(&intf
->dev
, "\n");
746 if (vq
->type
== V4L2_BUF_TYPE_SDR_CAPTURE
)
747 buffer_list
= &dev
->rx_buffer_list
;
749 buffer_list
= &dev
->tx_buffer_list
;
751 spin_lock_irqsave(&dev
->buffer_list_lock
, flags
);
752 list_for_each_entry_safe(buffer
, node
, buffer_list
, list
) {
753 dev_dbg(&intf
->dev
, "list_for_each_entry_safe\n");
754 vb2_buffer_done(&buffer
->vb
.vb2_buf
, state
);
755 list_del(&buffer
->list
);
757 spin_unlock_irqrestore(&dev
->buffer_list_lock
, flags
);
760 static int hackrf_queue_setup(struct vb2_queue
*vq
,
761 unsigned int *nbuffers
,
762 unsigned int *nplanes
, unsigned int sizes
[], struct device
*alloc_devs
[])
764 struct hackrf_dev
*dev
= vb2_get_drv_priv(vq
);
766 dev_dbg(dev
->dev
, "nbuffers=%d\n", *nbuffers
);
768 /* Need at least 8 buffers */
769 if (vq
->num_buffers
+ *nbuffers
< 8)
770 *nbuffers
= 8 - vq
->num_buffers
;
772 sizes
[0] = PAGE_ALIGN(dev
->buffersize
);
774 dev_dbg(dev
->dev
, "nbuffers=%d sizes[0]=%d\n", *nbuffers
, sizes
[0]);
778 static void hackrf_buf_queue(struct vb2_buffer
*vb
)
780 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
781 struct vb2_queue
*vq
= vb
->vb2_queue
;
782 struct hackrf_dev
*dev
= vb2_get_drv_priv(vq
);
783 struct hackrf_buffer
*buffer
= container_of(vbuf
, struct hackrf_buffer
, vb
);
784 struct list_head
*buffer_list
;
787 dev_dbg_ratelimited(&dev
->intf
->dev
, "\n");
789 if (vq
->type
== V4L2_BUF_TYPE_SDR_CAPTURE
)
790 buffer_list
= &dev
->rx_buffer_list
;
792 buffer_list
= &dev
->tx_buffer_list
;
794 spin_lock_irqsave(&dev
->buffer_list_lock
, flags
);
795 list_add_tail(&buffer
->list
, buffer_list
);
796 spin_unlock_irqrestore(&dev
->buffer_list_lock
, flags
);
799 static int hackrf_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
801 struct hackrf_dev
*dev
= vb2_get_drv_priv(vq
);
802 struct usb_interface
*intf
= dev
->intf
;
806 dev_dbg(&intf
->dev
, "count=%i\n", count
);
808 mutex_lock(&dev
->v4l2_lock
);
810 /* Allow only RX or TX, not both same time */
811 if (vq
->type
== V4L2_BUF_TYPE_SDR_CAPTURE
) {
812 if (test_bit(TX_ON
, &dev
->flags
)) {
814 goto err_hackrf_return_all_buffers
;
818 set_bit(RX_ON
, &dev
->flags
);
820 if (test_bit(RX_ON
, &dev
->flags
)) {
822 goto err_hackrf_return_all_buffers
;
826 set_bit(TX_ON
, &dev
->flags
);
831 ret
= hackrf_alloc_stream_bufs(dev
);
835 ret
= hackrf_alloc_urbs(dev
, (mode
== 1));
839 ret
= hackrf_submit_urbs(dev
);
843 ret
= hackrf_set_params(dev
);
847 /* start hardware streaming */
848 ret
= hackrf_ctrl_msg(dev
, CMD_SET_TRANSCEIVER_MODE
, mode
, 0, NULL
, 0);
852 mutex_unlock(&dev
->v4l2_lock
);
856 hackrf_kill_urbs(dev
);
857 hackrf_free_urbs(dev
);
858 hackrf_free_stream_bufs(dev
);
859 clear_bit(RX_ON
, &dev
->flags
);
860 clear_bit(TX_ON
, &dev
->flags
);
861 err_hackrf_return_all_buffers
:
862 hackrf_return_all_buffers(vq
, VB2_BUF_STATE_QUEUED
);
863 mutex_unlock(&dev
->v4l2_lock
);
864 dev_dbg(&intf
->dev
, "failed=%d\n", ret
);
868 static void hackrf_stop_streaming(struct vb2_queue
*vq
)
870 struct hackrf_dev
*dev
= vb2_get_drv_priv(vq
);
871 struct usb_interface
*intf
= dev
->intf
;
873 dev_dbg(&intf
->dev
, "\n");
875 mutex_lock(&dev
->v4l2_lock
);
877 /* stop hardware streaming */
878 hackrf_ctrl_msg(dev
, CMD_SET_TRANSCEIVER_MODE
, 0, 0, NULL
, 0);
880 hackrf_kill_urbs(dev
);
881 hackrf_free_urbs(dev
);
882 hackrf_free_stream_bufs(dev
);
884 hackrf_return_all_buffers(vq
, VB2_BUF_STATE_ERROR
);
886 if (vq
->type
== V4L2_BUF_TYPE_SDR_CAPTURE
)
887 clear_bit(RX_ON
, &dev
->flags
);
889 clear_bit(TX_ON
, &dev
->flags
);
891 mutex_unlock(&dev
->v4l2_lock
);
894 static const struct vb2_ops hackrf_vb2_ops
= {
895 .queue_setup
= hackrf_queue_setup
,
896 .buf_queue
= hackrf_buf_queue
,
897 .start_streaming
= hackrf_start_streaming
,
898 .stop_streaming
= hackrf_stop_streaming
,
899 .wait_prepare
= vb2_ops_wait_prepare
,
900 .wait_finish
= vb2_ops_wait_finish
,
903 static int hackrf_querycap(struct file
*file
, void *fh
,
904 struct v4l2_capability
*cap
)
906 struct hackrf_dev
*dev
= video_drvdata(file
);
907 struct usb_interface
*intf
= dev
->intf
;
908 struct video_device
*vdev
= video_devdata(file
);
910 dev_dbg(&intf
->dev
, "\n");
912 if (vdev
->vfl_dir
== VFL_DIR_RX
)
913 cap
->device_caps
= V4L2_CAP_SDR_CAPTURE
| V4L2_CAP_TUNER
|
914 V4L2_CAP_STREAMING
| V4L2_CAP_READWRITE
;
917 cap
->device_caps
= V4L2_CAP_SDR_OUTPUT
| V4L2_CAP_MODULATOR
|
918 V4L2_CAP_STREAMING
| V4L2_CAP_READWRITE
;
920 cap
->capabilities
= V4L2_CAP_SDR_CAPTURE
| V4L2_CAP_TUNER
|
921 V4L2_CAP_SDR_OUTPUT
| V4L2_CAP_MODULATOR
|
922 V4L2_CAP_STREAMING
| V4L2_CAP_READWRITE
|
923 V4L2_CAP_DEVICE_CAPS
;
924 strlcpy(cap
->driver
, KBUILD_MODNAME
, sizeof(cap
->driver
));
925 strlcpy(cap
->card
, dev
->rx_vdev
.name
, sizeof(cap
->card
));
926 usb_make_path(dev
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
931 static int hackrf_s_fmt_sdr(struct file
*file
, void *priv
,
932 struct v4l2_format
*f
)
934 struct hackrf_dev
*dev
= video_drvdata(file
);
935 struct video_device
*vdev
= video_devdata(file
);
939 dev_dbg(dev
->dev
, "pixelformat fourcc %4.4s\n",
940 (char *)&f
->fmt
.sdr
.pixelformat
);
942 if (vdev
->vfl_dir
== VFL_DIR_RX
)
943 q
= &dev
->rx_vb2_queue
;
945 q
= &dev
->tx_vb2_queue
;
950 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
951 for (i
= 0; i
< NUM_FORMATS
; i
++) {
952 if (f
->fmt
.sdr
.pixelformat
== formats
[i
].pixelformat
) {
953 dev
->pixelformat
= formats
[i
].pixelformat
;
954 dev
->buffersize
= formats
[i
].buffersize
;
955 f
->fmt
.sdr
.buffersize
= formats
[i
].buffersize
;
960 dev
->pixelformat
= formats
[0].pixelformat
;
961 dev
->buffersize
= formats
[0].buffersize
;
962 f
->fmt
.sdr
.pixelformat
= formats
[0].pixelformat
;
963 f
->fmt
.sdr
.buffersize
= formats
[0].buffersize
;
968 static int hackrf_g_fmt_sdr(struct file
*file
, void *priv
,
969 struct v4l2_format
*f
)
971 struct hackrf_dev
*dev
= video_drvdata(file
);
973 dev_dbg(dev
->dev
, "pixelformat fourcc %4.4s\n",
974 (char *)&dev
->pixelformat
);
976 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
977 f
->fmt
.sdr
.pixelformat
= dev
->pixelformat
;
978 f
->fmt
.sdr
.buffersize
= dev
->buffersize
;
983 static int hackrf_try_fmt_sdr(struct file
*file
, void *priv
,
984 struct v4l2_format
*f
)
986 struct hackrf_dev
*dev
= video_drvdata(file
);
989 dev_dbg(dev
->dev
, "pixelformat fourcc %4.4s\n",
990 (char *)&f
->fmt
.sdr
.pixelformat
);
992 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
993 for (i
= 0; i
< NUM_FORMATS
; i
++) {
994 if (formats
[i
].pixelformat
== f
->fmt
.sdr
.pixelformat
) {
995 f
->fmt
.sdr
.buffersize
= formats
[i
].buffersize
;
1000 f
->fmt
.sdr
.pixelformat
= formats
[0].pixelformat
;
1001 f
->fmt
.sdr
.buffersize
= formats
[0].buffersize
;
1006 static int hackrf_enum_fmt_sdr(struct file
*file
, void *priv
,
1007 struct v4l2_fmtdesc
*f
)
1009 struct hackrf_dev
*dev
= video_drvdata(file
);
1011 dev_dbg(dev
->dev
, "index=%d\n", f
->index
);
1013 if (f
->index
>= NUM_FORMATS
)
1016 f
->pixelformat
= formats
[f
->index
].pixelformat
;
1021 static int hackrf_s_tuner(struct file
*file
, void *priv
,
1022 const struct v4l2_tuner
*v
)
1024 struct hackrf_dev
*dev
= video_drvdata(file
);
1027 dev_dbg(dev
->dev
, "index=%d\n", v
->index
);
1031 else if (v
->index
== 1)
1039 static int hackrf_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*v
)
1041 struct hackrf_dev
*dev
= video_drvdata(file
);
1044 dev_dbg(dev
->dev
, "index=%d\n", v
->index
);
1046 if (v
->index
== 0) {
1047 strlcpy(v
->name
, "HackRF ADC", sizeof(v
->name
));
1048 v
->type
= V4L2_TUNER_SDR
;
1049 v
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
1050 v
->rangelow
= bands_adc_dac
[0].rangelow
;
1051 v
->rangehigh
= bands_adc_dac
[0].rangehigh
;
1053 } else if (v
->index
== 1) {
1054 strlcpy(v
->name
, "HackRF RF", sizeof(v
->name
));
1055 v
->type
= V4L2_TUNER_RF
;
1056 v
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
1057 v
->rangelow
= bands_rx_tx
[0].rangelow
;
1058 v
->rangehigh
= bands_rx_tx
[0].rangehigh
;
1067 static int hackrf_s_modulator(struct file
*file
, void *fh
,
1068 const struct v4l2_modulator
*a
)
1070 struct hackrf_dev
*dev
= video_drvdata(file
);
1072 dev_dbg(dev
->dev
, "index=%d\n", a
->index
);
1074 return a
->index
> 1 ? -EINVAL
: 0;
1077 static int hackrf_g_modulator(struct file
*file
, void *fh
,
1078 struct v4l2_modulator
*a
)
1080 struct hackrf_dev
*dev
= video_drvdata(file
);
1083 dev_dbg(dev
->dev
, "index=%d\n", a
->index
);
1085 if (a
->index
== 0) {
1086 strlcpy(a
->name
, "HackRF DAC", sizeof(a
->name
));
1087 a
->type
= V4L2_TUNER_SDR
;
1088 a
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
1089 a
->rangelow
= bands_adc_dac
[0].rangelow
;
1090 a
->rangehigh
= bands_adc_dac
[0].rangehigh
;
1092 } else if (a
->index
== 1) {
1093 strlcpy(a
->name
, "HackRF RF", sizeof(a
->name
));
1094 a
->type
= V4L2_TUNER_RF
;
1095 a
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
1096 a
->rangelow
= bands_rx_tx
[0].rangelow
;
1097 a
->rangehigh
= bands_rx_tx
[0].rangehigh
;
1106 static int hackrf_s_frequency(struct file
*file
, void *priv
,
1107 const struct v4l2_frequency
*f
)
1109 struct hackrf_dev
*dev
= video_drvdata(file
);
1110 struct usb_interface
*intf
= dev
->intf
;
1111 struct video_device
*vdev
= video_devdata(file
);
1115 dev_dbg(&intf
->dev
, "tuner=%d type=%d frequency=%u\n",
1116 f
->tuner
, f
->type
, f
->frequency
);
1118 if (f
->tuner
== 0) {
1119 uitmp
= clamp(f
->frequency
, bands_adc_dac
[0].rangelow
,
1120 bands_adc_dac
[0].rangehigh
);
1121 if (vdev
->vfl_dir
== VFL_DIR_RX
) {
1123 set_bit(RX_ADC_FREQUENCY
, &dev
->flags
);
1126 set_bit(TX_DAC_FREQUENCY
, &dev
->flags
);
1128 } else if (f
->tuner
== 1) {
1129 uitmp
= clamp(f
->frequency
, bands_rx_tx
[0].rangelow
,
1130 bands_rx_tx
[0].rangehigh
);
1131 if (vdev
->vfl_dir
== VFL_DIR_RX
) {
1133 set_bit(RX_RF_FREQUENCY
, &dev
->flags
);
1136 set_bit(TX_RF_FREQUENCY
, &dev
->flags
);
1143 ret
= hackrf_set_params(dev
);
1149 dev_dbg(&intf
->dev
, "failed=%d\n", ret
);
1153 static int hackrf_g_frequency(struct file
*file
, void *priv
,
1154 struct v4l2_frequency
*f
)
1156 struct hackrf_dev
*dev
= video_drvdata(file
);
1157 struct usb_interface
*intf
= dev
->intf
;
1158 struct video_device
*vdev
= video_devdata(file
);
1161 dev_dbg(dev
->dev
, "tuner=%d type=%d\n", f
->tuner
, f
->type
);
1163 if (f
->tuner
== 0) {
1164 f
->type
= V4L2_TUNER_SDR
;
1165 if (vdev
->vfl_dir
== VFL_DIR_RX
)
1166 f
->frequency
= dev
->f_adc
;
1168 f
->frequency
= dev
->f_dac
;
1169 } else if (f
->tuner
== 1) {
1170 f
->type
= V4L2_TUNER_RF
;
1171 if (vdev
->vfl_dir
== VFL_DIR_RX
)
1172 f
->frequency
= dev
->f_rx
;
1174 f
->frequency
= dev
->f_tx
;
1182 dev_dbg(&intf
->dev
, "failed=%d\n", ret
);
1186 static int hackrf_enum_freq_bands(struct file
*file
, void *priv
,
1187 struct v4l2_frequency_band
*band
)
1189 struct hackrf_dev
*dev
= video_drvdata(file
);
1192 dev_dbg(dev
->dev
, "tuner=%d type=%d index=%d\n",
1193 band
->tuner
, band
->type
, band
->index
);
1195 if (band
->tuner
== 0) {
1196 if (band
->index
>= ARRAY_SIZE(bands_adc_dac
)) {
1199 *band
= bands_adc_dac
[band
->index
];
1202 } else if (band
->tuner
== 1) {
1203 if (band
->index
>= ARRAY_SIZE(bands_rx_tx
)) {
1206 *band
= bands_rx_tx
[band
->index
];
1216 static const struct v4l2_ioctl_ops hackrf_ioctl_ops
= {
1217 .vidioc_querycap
= hackrf_querycap
,
1219 .vidioc_s_fmt_sdr_cap
= hackrf_s_fmt_sdr
,
1220 .vidioc_g_fmt_sdr_cap
= hackrf_g_fmt_sdr
,
1221 .vidioc_enum_fmt_sdr_cap
= hackrf_enum_fmt_sdr
,
1222 .vidioc_try_fmt_sdr_cap
= hackrf_try_fmt_sdr
,
1224 .vidioc_s_fmt_sdr_out
= hackrf_s_fmt_sdr
,
1225 .vidioc_g_fmt_sdr_out
= hackrf_g_fmt_sdr
,
1226 .vidioc_enum_fmt_sdr_out
= hackrf_enum_fmt_sdr
,
1227 .vidioc_try_fmt_sdr_out
= hackrf_try_fmt_sdr
,
1229 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1230 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
1231 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
1232 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1233 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1234 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1235 .vidioc_expbuf
= vb2_ioctl_expbuf
,
1237 .vidioc_streamon
= vb2_ioctl_streamon
,
1238 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1240 .vidioc_s_tuner
= hackrf_s_tuner
,
1241 .vidioc_g_tuner
= hackrf_g_tuner
,
1243 .vidioc_s_modulator
= hackrf_s_modulator
,
1244 .vidioc_g_modulator
= hackrf_g_modulator
,
1246 .vidioc_s_frequency
= hackrf_s_frequency
,
1247 .vidioc_g_frequency
= hackrf_g_frequency
,
1248 .vidioc_enum_freq_bands
= hackrf_enum_freq_bands
,
1250 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1251 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1252 .vidioc_log_status
= v4l2_ctrl_log_status
,
1255 static const struct v4l2_file_operations hackrf_fops
= {
1256 .owner
= THIS_MODULE
,
1257 .open
= v4l2_fh_open
,
1258 .release
= vb2_fop_release
,
1259 .read
= vb2_fop_read
,
1260 .write
= vb2_fop_write
,
1261 .poll
= vb2_fop_poll
,
1262 .mmap
= vb2_fop_mmap
,
1263 .unlocked_ioctl
= video_ioctl2
,
1266 static const struct video_device hackrf_template
= {
1267 .name
= "HackRF One",
1268 .release
= video_device_release_empty
,
1269 .fops
= &hackrf_fops
,
1270 .ioctl_ops
= &hackrf_ioctl_ops
,
1273 static void hackrf_video_release(struct v4l2_device
*v
)
1275 struct hackrf_dev
*dev
= container_of(v
, struct hackrf_dev
, v4l2_dev
);
1277 dev_dbg(dev
->dev
, "\n");
1279 v4l2_ctrl_handler_free(&dev
->rx_ctrl_handler
);
1280 v4l2_ctrl_handler_free(&dev
->tx_ctrl_handler
);
1281 v4l2_device_unregister(&dev
->v4l2_dev
);
1285 static int hackrf_s_ctrl_rx(struct v4l2_ctrl
*ctrl
)
1287 struct hackrf_dev
*dev
= container_of(ctrl
->handler
,
1288 struct hackrf_dev
, rx_ctrl_handler
);
1289 struct usb_interface
*intf
= dev
->intf
;
1293 case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
:
1294 case V4L2_CID_RF_TUNER_BANDWIDTH
:
1295 set_bit(RX_BANDWIDTH
, &dev
->flags
);
1297 case V4L2_CID_RF_TUNER_RF_GAIN
:
1298 set_bit(RX_RF_GAIN
, &dev
->flags
);
1300 case V4L2_CID_RF_TUNER_LNA_GAIN
:
1301 set_bit(RX_LNA_GAIN
, &dev
->flags
);
1303 case V4L2_CID_RF_TUNER_IF_GAIN
:
1304 set_bit(RX_IF_GAIN
, &dev
->flags
);
1307 dev_dbg(&intf
->dev
, "unknown ctrl: id=%d name=%s\n",
1308 ctrl
->id
, ctrl
->name
);
1313 ret
= hackrf_set_params(dev
);
1319 dev_dbg(&intf
->dev
, "failed=%d\n", ret
);
1323 static int hackrf_s_ctrl_tx(struct v4l2_ctrl
*ctrl
)
1325 struct hackrf_dev
*dev
= container_of(ctrl
->handler
,
1326 struct hackrf_dev
, tx_ctrl_handler
);
1327 struct usb_interface
*intf
= dev
->intf
;
1331 case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
:
1332 case V4L2_CID_RF_TUNER_BANDWIDTH
:
1333 set_bit(TX_BANDWIDTH
, &dev
->flags
);
1335 case V4L2_CID_RF_TUNER_LNA_GAIN
:
1336 set_bit(TX_LNA_GAIN
, &dev
->flags
);
1338 case V4L2_CID_RF_TUNER_RF_GAIN
:
1339 set_bit(TX_RF_GAIN
, &dev
->flags
);
1342 dev_dbg(&intf
->dev
, "unknown ctrl: id=%d name=%s\n",
1343 ctrl
->id
, ctrl
->name
);
1348 ret
= hackrf_set_params(dev
);
1354 dev_dbg(&intf
->dev
, "failed=%d\n", ret
);
1358 static const struct v4l2_ctrl_ops hackrf_ctrl_ops_rx
= {
1359 .s_ctrl
= hackrf_s_ctrl_rx
,
1362 static const struct v4l2_ctrl_ops hackrf_ctrl_ops_tx
= {
1363 .s_ctrl
= hackrf_s_ctrl_tx
,
1366 static int hackrf_probe(struct usb_interface
*intf
,
1367 const struct usb_device_id
*id
)
1369 struct hackrf_dev
*dev
;
1371 u8 u8tmp
, buf
[BUF_SIZE
];
1373 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1379 mutex_init(&dev
->v4l2_lock
);
1380 mutex_init(&dev
->vb_queue_lock
);
1381 spin_lock_init(&dev
->buffer_list_lock
);
1382 INIT_LIST_HEAD(&dev
->rx_buffer_list
);
1383 INIT_LIST_HEAD(&dev
->tx_buffer_list
);
1385 dev
->dev
= &intf
->dev
;
1386 dev
->udev
= interface_to_usbdev(intf
);
1387 dev
->pixelformat
= formats
[0].pixelformat
;
1388 dev
->buffersize
= formats
[0].buffersize
;
1389 dev
->f_adc
= bands_adc_dac
[0].rangelow
;
1390 dev
->f_dac
= bands_adc_dac
[0].rangelow
;
1391 dev
->f_rx
= bands_rx_tx
[0].rangelow
;
1392 dev
->f_tx
= bands_rx_tx
[0].rangelow
;
1393 set_bit(RX_ADC_FREQUENCY
, &dev
->flags
);
1394 set_bit(TX_DAC_FREQUENCY
, &dev
->flags
);
1395 set_bit(RX_RF_FREQUENCY
, &dev
->flags
);
1396 set_bit(TX_RF_FREQUENCY
, &dev
->flags
);
1399 ret
= hackrf_ctrl_msg(dev
, CMD_BOARD_ID_READ
, 0, 0, &u8tmp
, 1);
1401 ret
= hackrf_ctrl_msg(dev
, CMD_VERSION_STRING_READ
, 0, 0,
1404 dev_err(dev
->dev
, "Could not detect board\n");
1408 buf
[BUF_SIZE
- 1] = '\0';
1409 dev_info(dev
->dev
, "Board ID: %02x\n", u8tmp
);
1410 dev_info(dev
->dev
, "Firmware version: %s\n", buf
);
1412 /* Init vb2 queue structure for receiver */
1413 dev
->rx_vb2_queue
.type
= V4L2_BUF_TYPE_SDR_CAPTURE
;
1414 dev
->rx_vb2_queue
.io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
|
1416 dev
->rx_vb2_queue
.ops
= &hackrf_vb2_ops
;
1417 dev
->rx_vb2_queue
.mem_ops
= &vb2_vmalloc_memops
;
1418 dev
->rx_vb2_queue
.drv_priv
= dev
;
1419 dev
->rx_vb2_queue
.buf_struct_size
= sizeof(struct hackrf_buffer
);
1420 dev
->rx_vb2_queue
.timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1421 ret
= vb2_queue_init(&dev
->rx_vb2_queue
);
1423 dev_err(dev
->dev
, "Could not initialize rx vb2 queue\n");
1427 /* Init vb2 queue structure for transmitter */
1428 dev
->tx_vb2_queue
.type
= V4L2_BUF_TYPE_SDR_OUTPUT
;
1429 dev
->tx_vb2_queue
.io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
|
1431 dev
->tx_vb2_queue
.ops
= &hackrf_vb2_ops
;
1432 dev
->tx_vb2_queue
.mem_ops
= &vb2_vmalloc_memops
;
1433 dev
->tx_vb2_queue
.drv_priv
= dev
;
1434 dev
->tx_vb2_queue
.buf_struct_size
= sizeof(struct hackrf_buffer
);
1435 dev
->tx_vb2_queue
.timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1436 ret
= vb2_queue_init(&dev
->tx_vb2_queue
);
1438 dev_err(dev
->dev
, "Could not initialize tx vb2 queue\n");
1442 /* Register controls for receiver */
1443 v4l2_ctrl_handler_init(&dev
->rx_ctrl_handler
, 5);
1444 dev
->rx_bandwidth_auto
= v4l2_ctrl_new_std(&dev
->rx_ctrl_handler
,
1445 &hackrf_ctrl_ops_rx
, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
,
1447 dev
->rx_bandwidth
= v4l2_ctrl_new_std(&dev
->rx_ctrl_handler
,
1448 &hackrf_ctrl_ops_rx
, V4L2_CID_RF_TUNER_BANDWIDTH
,
1449 1750000, 28000000, 50000, 1750000);
1450 v4l2_ctrl_auto_cluster(2, &dev
->rx_bandwidth_auto
, 0, false);
1451 dev
->rx_rf_gain
= v4l2_ctrl_new_std(&dev
->rx_ctrl_handler
,
1452 &hackrf_ctrl_ops_rx
, V4L2_CID_RF_TUNER_RF_GAIN
, 0, 12, 12, 0);
1453 dev
->rx_lna_gain
= v4l2_ctrl_new_std(&dev
->rx_ctrl_handler
,
1454 &hackrf_ctrl_ops_rx
, V4L2_CID_RF_TUNER_LNA_GAIN
, 0, 40, 8, 0);
1455 dev
->rx_if_gain
= v4l2_ctrl_new_std(&dev
->rx_ctrl_handler
,
1456 &hackrf_ctrl_ops_rx
, V4L2_CID_RF_TUNER_IF_GAIN
, 0, 62, 2, 0);
1457 if (dev
->rx_ctrl_handler
.error
) {
1458 ret
= dev
->rx_ctrl_handler
.error
;
1459 dev_err(dev
->dev
, "Could not initialize controls\n");
1460 goto err_v4l2_ctrl_handler_free_rx
;
1462 v4l2_ctrl_grab(dev
->rx_rf_gain
, !hackrf_enable_rf_gain_ctrl
);
1463 v4l2_ctrl_handler_setup(&dev
->rx_ctrl_handler
);
1465 /* Register controls for transmitter */
1466 v4l2_ctrl_handler_init(&dev
->tx_ctrl_handler
, 4);
1467 dev
->tx_bandwidth_auto
= v4l2_ctrl_new_std(&dev
->tx_ctrl_handler
,
1468 &hackrf_ctrl_ops_tx
, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
,
1470 dev
->tx_bandwidth
= v4l2_ctrl_new_std(&dev
->tx_ctrl_handler
,
1471 &hackrf_ctrl_ops_tx
, V4L2_CID_RF_TUNER_BANDWIDTH
,
1472 1750000, 28000000, 50000, 1750000);
1473 v4l2_ctrl_auto_cluster(2, &dev
->tx_bandwidth_auto
, 0, false);
1474 dev
->tx_lna_gain
= v4l2_ctrl_new_std(&dev
->tx_ctrl_handler
,
1475 &hackrf_ctrl_ops_tx
, V4L2_CID_RF_TUNER_LNA_GAIN
, 0, 47, 1, 0);
1476 dev
->tx_rf_gain
= v4l2_ctrl_new_std(&dev
->tx_ctrl_handler
,
1477 &hackrf_ctrl_ops_tx
, V4L2_CID_RF_TUNER_RF_GAIN
, 0, 15, 15, 0);
1478 if (dev
->tx_ctrl_handler
.error
) {
1479 ret
= dev
->tx_ctrl_handler
.error
;
1480 dev_err(dev
->dev
, "Could not initialize controls\n");
1481 goto err_v4l2_ctrl_handler_free_tx
;
1483 v4l2_ctrl_grab(dev
->tx_rf_gain
, !hackrf_enable_rf_gain_ctrl
);
1484 v4l2_ctrl_handler_setup(&dev
->tx_ctrl_handler
);
1486 /* Register the v4l2_device structure */
1487 dev
->v4l2_dev
.release
= hackrf_video_release
;
1488 ret
= v4l2_device_register(&intf
->dev
, &dev
->v4l2_dev
);
1490 dev_err(dev
->dev
, "Failed to register v4l2-device (%d)\n", ret
);
1491 goto err_v4l2_ctrl_handler_free_tx
;
1494 /* Init video_device structure for receiver */
1495 dev
->rx_vdev
= hackrf_template
;
1496 dev
->rx_vdev
.queue
= &dev
->rx_vb2_queue
;
1497 dev
->rx_vdev
.queue
->lock
= &dev
->vb_queue_lock
;
1498 dev
->rx_vdev
.v4l2_dev
= &dev
->v4l2_dev
;
1499 dev
->rx_vdev
.ctrl_handler
= &dev
->rx_ctrl_handler
;
1500 dev
->rx_vdev
.lock
= &dev
->v4l2_lock
;
1501 dev
->rx_vdev
.vfl_dir
= VFL_DIR_RX
;
1502 video_set_drvdata(&dev
->rx_vdev
, dev
);
1503 ret
= video_register_device(&dev
->rx_vdev
, VFL_TYPE_SDR
, -1);
1506 "Failed to register as video device (%d)\n", ret
);
1507 goto err_v4l2_device_unregister
;
1509 dev_info(dev
->dev
, "Registered as %s\n",
1510 video_device_node_name(&dev
->rx_vdev
));
1512 /* Init video_device structure for transmitter */
1513 dev
->tx_vdev
= hackrf_template
;
1514 dev
->tx_vdev
.queue
= &dev
->tx_vb2_queue
;
1515 dev
->tx_vdev
.queue
->lock
= &dev
->vb_queue_lock
;
1516 dev
->tx_vdev
.v4l2_dev
= &dev
->v4l2_dev
;
1517 dev
->tx_vdev
.ctrl_handler
= &dev
->tx_ctrl_handler
;
1518 dev
->tx_vdev
.lock
= &dev
->v4l2_lock
;
1519 dev
->tx_vdev
.vfl_dir
= VFL_DIR_TX
;
1520 video_set_drvdata(&dev
->tx_vdev
, dev
);
1521 ret
= video_register_device(&dev
->tx_vdev
, VFL_TYPE_SDR
, -1);
1524 "Failed to register as video device (%d)\n", ret
);
1525 goto err_video_unregister_device_rx
;
1527 dev_info(dev
->dev
, "Registered as %s\n",
1528 video_device_node_name(&dev
->tx_vdev
));
1530 dev_notice(dev
->dev
, "SDR API is still slightly experimental and functionality changes may follow\n");
1532 err_video_unregister_device_rx
:
1533 video_unregister_device(&dev
->rx_vdev
);
1534 err_v4l2_device_unregister
:
1535 v4l2_device_unregister(&dev
->v4l2_dev
);
1536 err_v4l2_ctrl_handler_free_tx
:
1537 v4l2_ctrl_handler_free(&dev
->tx_ctrl_handler
);
1538 err_v4l2_ctrl_handler_free_rx
:
1539 v4l2_ctrl_handler_free(&dev
->rx_ctrl_handler
);
1543 dev_dbg(&intf
->dev
, "failed=%d\n", ret
);
1547 /* USB device ID list */
1548 static const struct usb_device_id hackrf_id_table
[] = {
1549 { USB_DEVICE(0x1d50, 0x6089) }, /* HackRF One */
1552 MODULE_DEVICE_TABLE(usb
, hackrf_id_table
);
1554 /* USB subsystem interface */
1555 static struct usb_driver hackrf_driver
= {
1556 .name
= KBUILD_MODNAME
,
1557 .probe
= hackrf_probe
,
1558 .disconnect
= hackrf_disconnect
,
1559 .id_table
= hackrf_id_table
,
1562 module_usb_driver(hackrf_driver
);
1564 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1565 MODULE_DESCRIPTION("HackRF");
1566 MODULE_LICENSE("GPL");