Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * HackRF driver
0004  *
0005  * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
0006  */
0007 
0008 #include <linux/module.h>
0009 #include <linux/slab.h>
0010 #include <linux/usb.h>
0011 #include <media/v4l2-device.h>
0012 #include <media/v4l2-ioctl.h>
0013 #include <media/v4l2-ctrls.h>
0014 #include <media/v4l2-event.h>
0015 #include <media/videobuf2-v4l2.h>
0016 #include <media/videobuf2-vmalloc.h>
0017 
0018 /*
0019  * Used Avago MGA-81563 RF amplifier could be destroyed pretty easily with too
0020  * strong signal or transmitting to bad antenna.
0021  * Set RF gain control to 'grabbed' state by default for sure.
0022  */
0023 static bool hackrf_enable_rf_gain_ctrl;
0024 module_param_named(enable_rf_gain_ctrl, hackrf_enable_rf_gain_ctrl, bool, 0644);
0025 MODULE_PARM_DESC(enable_rf_gain_ctrl, "enable RX/TX RF amplifier control (warn: could damage amplifier)");
0026 
0027 /* HackRF USB API commands (from HackRF Library) */
0028 enum {
0029     CMD_SET_TRANSCEIVER_MODE           = 0x01,
0030     CMD_SAMPLE_RATE_SET                = 0x06,
0031     CMD_BASEBAND_FILTER_BANDWIDTH_SET  = 0x07,
0032     CMD_BOARD_ID_READ                  = 0x0e,
0033     CMD_VERSION_STRING_READ            = 0x0f,
0034     CMD_SET_FREQ                       = 0x10,
0035     CMD_AMP_ENABLE                     = 0x11,
0036     CMD_SET_LNA_GAIN                   = 0x13,
0037     CMD_SET_VGA_GAIN                   = 0x14,
0038     CMD_SET_TXVGA_GAIN                 = 0x15,
0039 };
0040 
0041 /*
0042  *       bEndpointAddress     0x81  EP 1 IN
0043  *         Transfer Type            Bulk
0044  *       wMaxPacketSize     0x0200  1x 512 bytes
0045  */
0046 #define MAX_BULK_BUFS            (6)
0047 #define BULK_BUFFER_SIZE         (128 * 512)
0048 
0049 static const struct v4l2_frequency_band bands_adc_dac[] = {
0050     {
0051         .tuner = 0,
0052         .type = V4L2_TUNER_SDR,
0053         .index = 0,
0054         .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
0055         .rangelow   =   200000,
0056         .rangehigh  = 24000000,
0057     },
0058 };
0059 
0060 static const struct v4l2_frequency_band bands_rx_tx[] = {
0061     {
0062         .tuner = 1,
0063         .type = V4L2_TUNER_RF,
0064         .index = 0,
0065         .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
0066         .rangelow   =          1,
0067         .rangehigh  = 4294967294LL, /* max u32, hw goes over 7GHz */
0068     },
0069 };
0070 
0071 /* stream formats */
0072 struct hackrf_format {
0073     u32 pixelformat;
0074     u32 buffersize;
0075 };
0076 
0077 /* format descriptions for capture and preview */
0078 static struct hackrf_format formats[] = {
0079     {
0080         .pixelformat    = V4L2_SDR_FMT_CS8,
0081         .buffersize = BULK_BUFFER_SIZE,
0082     },
0083 };
0084 
0085 static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats);
0086 
0087 /* intermediate buffers with raw data from the USB device */
0088 struct hackrf_buffer {
0089     struct vb2_v4l2_buffer vb;
0090     struct list_head list;
0091 };
0092 
0093 struct hackrf_dev {
0094 #define USB_STATE_URB_BUF                1 /* XXX: set manually */
0095 #define RX_ON                            4
0096 #define TX_ON                            5
0097 #define RX_ADC_FREQUENCY                11
0098 #define TX_DAC_FREQUENCY                12
0099 #define RX_BANDWIDTH                    13
0100 #define TX_BANDWIDTH                    14
0101 #define RX_RF_FREQUENCY                 15
0102 #define TX_RF_FREQUENCY                 16
0103 #define RX_RF_GAIN                      17
0104 #define TX_RF_GAIN                      18
0105 #define RX_IF_GAIN                      19
0106 #define RX_LNA_GAIN                     20
0107 #define TX_LNA_GAIN                     21
0108     unsigned long flags;
0109 
0110     struct usb_interface *intf;
0111     struct device *dev;
0112     struct usb_device *udev;
0113     struct video_device rx_vdev;
0114     struct video_device tx_vdev;
0115     struct v4l2_device v4l2_dev;
0116 
0117     /* videobuf2 queue and queued buffers list */
0118     struct vb2_queue rx_vb2_queue;
0119     struct vb2_queue tx_vb2_queue;
0120     struct list_head rx_buffer_list;
0121     struct list_head tx_buffer_list;
0122     spinlock_t buffer_list_lock; /* Protects buffer_list */
0123     unsigned int sequence;       /* Buffer sequence counter */
0124     unsigned int vb_full;        /* vb is full and packets dropped */
0125     unsigned int vb_empty;       /* vb is empty and packets dropped */
0126 
0127     /* Note if taking both locks v4l2_lock must always be locked first! */
0128     struct mutex v4l2_lock;      /* Protects everything else */
0129     struct mutex vb_queue_lock;  /* Protects vb_queue */
0130 
0131     struct urb     *urb_list[MAX_BULK_BUFS];
0132     int            buf_num;
0133     unsigned long  buf_size;
0134     u8             *buf_list[MAX_BULK_BUFS];
0135     dma_addr_t     dma_addr[MAX_BULK_BUFS];
0136     int            urbs_initialized;
0137     int            urbs_submitted;
0138 
0139     /* USB control message buffer */
0140     #define BUF_SIZE 24
0141     u8 buf[BUF_SIZE];
0142 
0143     /* Current configuration */
0144     unsigned int f_adc;
0145     unsigned int f_dac;
0146     unsigned int f_rx;
0147     unsigned int f_tx;
0148     u32 pixelformat;
0149     u32 buffersize;
0150 
0151     /* Controls */
0152     struct v4l2_ctrl_handler rx_ctrl_handler;
0153     struct v4l2_ctrl *rx_bandwidth_auto;
0154     struct v4l2_ctrl *rx_bandwidth;
0155     struct v4l2_ctrl *rx_rf_gain;
0156     struct v4l2_ctrl *rx_lna_gain;
0157     struct v4l2_ctrl *rx_if_gain;
0158     struct v4l2_ctrl_handler tx_ctrl_handler;
0159     struct v4l2_ctrl *tx_bandwidth_auto;
0160     struct v4l2_ctrl *tx_bandwidth;
0161     struct v4l2_ctrl *tx_rf_gain;
0162     struct v4l2_ctrl *tx_lna_gain;
0163 
0164     /* Sample rate calc */
0165     unsigned long jiffies_next;
0166     unsigned int sample;
0167     unsigned int sample_measured;
0168 };
0169 
0170 #define hackrf_dbg_usb_control_msg(_dev, _r, _t, _v, _i, _b, _l) { \
0171     char *_direction; \
0172     if (_t & USB_DIR_IN) \
0173         _direction = "<<<"; \
0174     else \
0175         _direction = ">>>"; \
0176     dev_dbg(_dev, "%02x %02x %02x %02x %02x %02x %02x %02x %s %*ph\n", \
0177             _t, _r, _v & 0xff, _v >> 8, _i & 0xff, \
0178             _i >> 8, _l & 0xff, _l >> 8, _direction, _l, _b); \
0179 }
0180 
0181 /* execute firmware command */
0182 static int hackrf_ctrl_msg(struct hackrf_dev *dev, u8 request, u16 value,
0183         u16 index, u8 *data, u16 size)
0184 {
0185     int ret;
0186     unsigned int pipe;
0187     u8 requesttype;
0188 
0189     switch (request) {
0190     case CMD_SET_TRANSCEIVER_MODE:
0191     case CMD_SET_FREQ:
0192     case CMD_AMP_ENABLE:
0193     case CMD_SAMPLE_RATE_SET:
0194     case CMD_BASEBAND_FILTER_BANDWIDTH_SET:
0195         pipe = usb_sndctrlpipe(dev->udev, 0);
0196         requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
0197         break;
0198     case CMD_BOARD_ID_READ:
0199     case CMD_VERSION_STRING_READ:
0200     case CMD_SET_LNA_GAIN:
0201     case CMD_SET_VGA_GAIN:
0202     case CMD_SET_TXVGA_GAIN:
0203         pipe = usb_rcvctrlpipe(dev->udev, 0);
0204         requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
0205         break;
0206     default:
0207         dev_err(dev->dev, "Unknown command %02x\n", request);
0208         ret = -EINVAL;
0209         goto err;
0210     }
0211 
0212     /* write request */
0213     if (!(requesttype & USB_DIR_IN))
0214         memcpy(dev->buf, data, size);
0215 
0216     ret = usb_control_msg(dev->udev, pipe, request, requesttype, value,
0217             index, dev->buf, size, 1000);
0218     hackrf_dbg_usb_control_msg(dev->dev, request, requesttype, value,
0219             index, dev->buf, size);
0220     if (ret < 0) {
0221         dev_err(dev->dev, "usb_control_msg() failed %d request %02x\n",
0222                 ret, request);
0223         goto err;
0224     }
0225 
0226     /* read request */
0227     if (requesttype & USB_DIR_IN)
0228         memcpy(data, dev->buf, size);
0229 
0230     return 0;
0231 err:
0232     return ret;
0233 }
0234 
0235 static int hackrf_set_params(struct hackrf_dev *dev)
0236 {
0237     struct usb_interface *intf = dev->intf;
0238     int ret, i;
0239     u8 buf[8], u8tmp;
0240     unsigned int uitmp, uitmp1, uitmp2;
0241     const bool rx = test_bit(RX_ON, &dev->flags);
0242     const bool tx = test_bit(TX_ON, &dev->flags);
0243     static const struct {
0244         u32 freq;
0245     } bandwidth_lut[] = {
0246         { 1750000}, /*  1.75 MHz */
0247         { 2500000}, /*  2.5  MHz */
0248         { 3500000}, /*  3.5  MHz */
0249         { 5000000}, /*  5    MHz */
0250         { 5500000}, /*  5.5  MHz */
0251         { 6000000}, /*  6    MHz */
0252         { 7000000}, /*  7    MHz */
0253         { 8000000}, /*  8    MHz */
0254         { 9000000}, /*  9    MHz */
0255         {10000000}, /* 10    MHz */
0256         {12000000}, /* 12    MHz */
0257         {14000000}, /* 14    MHz */
0258         {15000000}, /* 15    MHz */
0259         {20000000}, /* 20    MHz */
0260         {24000000}, /* 24    MHz */
0261         {28000000}, /* 28    MHz */
0262     };
0263 
0264     if (!rx && !tx) {
0265         dev_dbg(&intf->dev, "device is sleeping\n");
0266         return 0;
0267     }
0268 
0269     /* ADC / DAC frequency */
0270     if (rx && test_and_clear_bit(RX_ADC_FREQUENCY, &dev->flags)) {
0271         dev_dbg(&intf->dev, "RX ADC frequency=%u Hz\n", dev->f_adc);
0272         uitmp1 = dev->f_adc;
0273         uitmp2 = 1;
0274         set_bit(TX_DAC_FREQUENCY, &dev->flags);
0275     } else if (tx && test_and_clear_bit(TX_DAC_FREQUENCY, &dev->flags)) {
0276         dev_dbg(&intf->dev, "TX DAC frequency=%u Hz\n", dev->f_dac);
0277         uitmp1 = dev->f_dac;
0278         uitmp2 = 1;
0279         set_bit(RX_ADC_FREQUENCY, &dev->flags);
0280     } else {
0281         uitmp1 = uitmp2 = 0;
0282     }
0283     if (uitmp1 || uitmp2) {
0284         buf[0] = (uitmp1 >>  0) & 0xff;
0285         buf[1] = (uitmp1 >>  8) & 0xff;
0286         buf[2] = (uitmp1 >> 16) & 0xff;
0287         buf[3] = (uitmp1 >> 24) & 0xff;
0288         buf[4] = (uitmp2 >>  0) & 0xff;
0289         buf[5] = (uitmp2 >>  8) & 0xff;
0290         buf[6] = (uitmp2 >> 16) & 0xff;
0291         buf[7] = (uitmp2 >> 24) & 0xff;
0292         ret = hackrf_ctrl_msg(dev, CMD_SAMPLE_RATE_SET, 0, 0, buf, 8);
0293         if (ret)
0294             goto err;
0295     }
0296 
0297     /* bandwidth */
0298     if (rx && test_and_clear_bit(RX_BANDWIDTH, &dev->flags)) {
0299         if (dev->rx_bandwidth_auto->val == true)
0300             uitmp = dev->f_adc;
0301         else
0302             uitmp = dev->rx_bandwidth->val;
0303 
0304         for (i = 0; i < ARRAY_SIZE(bandwidth_lut); i++) {
0305             if (uitmp <= bandwidth_lut[i].freq) {
0306                 uitmp = bandwidth_lut[i].freq;
0307                 break;
0308             }
0309         }
0310         dev->rx_bandwidth->val = uitmp;
0311         dev->rx_bandwidth->cur.val = uitmp;
0312         dev_dbg(&intf->dev, "RX bandwidth selected=%u\n", uitmp);
0313         set_bit(TX_BANDWIDTH, &dev->flags);
0314     } else if (tx && test_and_clear_bit(TX_BANDWIDTH, &dev->flags)) {
0315         if (dev->tx_bandwidth_auto->val == true)
0316             uitmp = dev->f_dac;
0317         else
0318             uitmp = dev->tx_bandwidth->val;
0319 
0320         for (i = 0; i < ARRAY_SIZE(bandwidth_lut); i++) {
0321             if (uitmp <= bandwidth_lut[i].freq) {
0322                 uitmp = bandwidth_lut[i].freq;
0323                 break;
0324             }
0325         }
0326         dev->tx_bandwidth->val = uitmp;
0327         dev->tx_bandwidth->cur.val = uitmp;
0328         dev_dbg(&intf->dev, "TX bandwidth selected=%u\n", uitmp);
0329         set_bit(RX_BANDWIDTH, &dev->flags);
0330     } else {
0331         uitmp = 0;
0332     }
0333     if (uitmp) {
0334         uitmp1 = uitmp2 = 0;
0335         uitmp1 |= ((uitmp >>  0) & 0xff) << 0;
0336         uitmp1 |= ((uitmp >>  8) & 0xff) << 8;
0337         uitmp2 |= ((uitmp >> 16) & 0xff) << 0;
0338         uitmp2 |= ((uitmp >> 24) & 0xff) << 8;
0339         ret = hackrf_ctrl_msg(dev, CMD_BASEBAND_FILTER_BANDWIDTH_SET,
0340                       uitmp1, uitmp2, NULL, 0);
0341         if (ret)
0342             goto err;
0343     }
0344 
0345     /* RX / TX RF frequency */
0346     if (rx && test_and_clear_bit(RX_RF_FREQUENCY, &dev->flags)) {
0347         dev_dbg(&intf->dev, "RX RF frequency=%u Hz\n", dev->f_rx);
0348         uitmp1 = dev->f_rx / 1000000;
0349         uitmp2 = dev->f_rx % 1000000;
0350         set_bit(TX_RF_FREQUENCY, &dev->flags);
0351     } else if (tx && test_and_clear_bit(TX_RF_FREQUENCY, &dev->flags)) {
0352         dev_dbg(&intf->dev, "TX RF frequency=%u Hz\n", dev->f_tx);
0353         uitmp1 = dev->f_tx / 1000000;
0354         uitmp2 = dev->f_tx % 1000000;
0355         set_bit(RX_RF_FREQUENCY, &dev->flags);
0356     } else {
0357         uitmp1 = uitmp2 = 0;
0358     }
0359     if (uitmp1 || uitmp2) {
0360         buf[0] = (uitmp1 >>  0) & 0xff;
0361         buf[1] = (uitmp1 >>  8) & 0xff;
0362         buf[2] = (uitmp1 >> 16) & 0xff;
0363         buf[3] = (uitmp1 >> 24) & 0xff;
0364         buf[4] = (uitmp2 >>  0) & 0xff;
0365         buf[5] = (uitmp2 >>  8) & 0xff;
0366         buf[6] = (uitmp2 >> 16) & 0xff;
0367         buf[7] = (uitmp2 >> 24) & 0xff;
0368         ret = hackrf_ctrl_msg(dev, CMD_SET_FREQ, 0, 0, buf, 8);
0369         if (ret)
0370             goto err;
0371     }
0372 
0373     /* RX RF gain */
0374     if (rx && test_and_clear_bit(RX_RF_GAIN, &dev->flags)) {
0375         dev_dbg(&intf->dev, "RX RF gain val=%d->%d\n",
0376             dev->rx_rf_gain->cur.val, dev->rx_rf_gain->val);
0377 
0378         u8tmp = (dev->rx_rf_gain->val) ? 1 : 0;
0379         ret = hackrf_ctrl_msg(dev, CMD_AMP_ENABLE, u8tmp, 0, NULL, 0);
0380         if (ret)
0381             goto err;
0382         set_bit(TX_RF_GAIN, &dev->flags);
0383     }
0384 
0385     /* TX RF gain */
0386     if (tx && test_and_clear_bit(TX_RF_GAIN, &dev->flags)) {
0387         dev_dbg(&intf->dev, "TX RF gain val=%d->%d\n",
0388             dev->tx_rf_gain->cur.val, dev->tx_rf_gain->val);
0389 
0390         u8tmp = (dev->tx_rf_gain->val) ? 1 : 0;
0391         ret = hackrf_ctrl_msg(dev, CMD_AMP_ENABLE, u8tmp, 0, NULL, 0);
0392         if (ret)
0393             goto err;
0394         set_bit(RX_RF_GAIN, &dev->flags);
0395     }
0396 
0397     /* RX LNA gain */
0398     if (rx && test_and_clear_bit(RX_LNA_GAIN, &dev->flags)) {
0399         dev_dbg(dev->dev, "RX LNA gain val=%d->%d\n",
0400             dev->rx_lna_gain->cur.val, dev->rx_lna_gain->val);
0401 
0402         ret = hackrf_ctrl_msg(dev, CMD_SET_LNA_GAIN, 0,
0403                       dev->rx_lna_gain->val, &u8tmp, 1);
0404         if (ret)
0405             goto err;
0406     }
0407 
0408     /* RX IF gain */
0409     if (rx && test_and_clear_bit(RX_IF_GAIN, &dev->flags)) {
0410         dev_dbg(&intf->dev, "IF gain val=%d->%d\n",
0411             dev->rx_if_gain->cur.val, dev->rx_if_gain->val);
0412 
0413         ret = hackrf_ctrl_msg(dev, CMD_SET_VGA_GAIN, 0,
0414                       dev->rx_if_gain->val, &u8tmp, 1);
0415         if (ret)
0416             goto err;
0417     }
0418 
0419     /* TX LNA gain */
0420     if (tx && test_and_clear_bit(TX_LNA_GAIN, &dev->flags)) {
0421         dev_dbg(&intf->dev, "TX LNA gain val=%d->%d\n",
0422             dev->tx_lna_gain->cur.val, dev->tx_lna_gain->val);
0423 
0424         ret = hackrf_ctrl_msg(dev, CMD_SET_TXVGA_GAIN, 0,
0425                       dev->tx_lna_gain->val, &u8tmp, 1);
0426         if (ret)
0427             goto err;
0428     }
0429 
0430     return 0;
0431 err:
0432     dev_dbg(&intf->dev, "failed=%d\n", ret);
0433     return ret;
0434 }
0435 
0436 /* Private functions */
0437 static struct hackrf_buffer *hackrf_get_next_buffer(struct hackrf_dev *dev,
0438                             struct list_head *buffer_list)
0439 {
0440     unsigned long flags;
0441     struct hackrf_buffer *buffer = NULL;
0442 
0443     spin_lock_irqsave(&dev->buffer_list_lock, flags);
0444     if (list_empty(buffer_list))
0445         goto leave;
0446 
0447     buffer = list_entry(buffer_list->next, struct hackrf_buffer, list);
0448     list_del(&buffer->list);
0449 leave:
0450     spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
0451     return buffer;
0452 }
0453 
0454 static void hackrf_copy_stream(struct hackrf_dev *dev, void *dst, void *src,
0455                    unsigned int src_len)
0456 {
0457     memcpy(dst, src, src_len);
0458 
0459     /* calculate sample rate and output it in 10 seconds intervals */
0460     if (unlikely(time_is_before_jiffies(dev->jiffies_next))) {
0461         #define MSECS 10000UL
0462         unsigned int msecs = jiffies_to_msecs(jiffies -
0463                 dev->jiffies_next + msecs_to_jiffies(MSECS));
0464         unsigned int samples = dev->sample - dev->sample_measured;
0465 
0466         dev->jiffies_next = jiffies + msecs_to_jiffies(MSECS);
0467         dev->sample_measured = dev->sample;
0468         dev_dbg(dev->dev, "slen=%u samples=%u msecs=%u sample rate=%lu\n",
0469                 src_len, samples, msecs,
0470                 samples * 1000UL / msecs);
0471     }
0472 
0473     /* total number of samples */
0474     dev->sample += src_len / 2;
0475 }
0476 
0477 /*
0478  * This gets called for the bulk stream pipe. This is done in interrupt
0479  * time, so it has to be fast, not crash, and not stall. Neat.
0480  */
0481 static void hackrf_urb_complete_in(struct urb *urb)
0482 {
0483     struct hackrf_dev *dev = urb->context;
0484     struct usb_interface *intf = dev->intf;
0485     struct hackrf_buffer *buffer;
0486     unsigned int len;
0487 
0488     dev_dbg_ratelimited(&intf->dev, "status=%d length=%u/%u\n", urb->status,
0489                 urb->actual_length, urb->transfer_buffer_length);
0490 
0491     switch (urb->status) {
0492     case 0:             /* success */
0493     case -ETIMEDOUT:    /* NAK */
0494         break;
0495     case -ECONNRESET:   /* kill */
0496     case -ENOENT:
0497     case -ESHUTDOWN:
0498         return;
0499     default:            /* error */
0500         dev_err_ratelimited(&intf->dev, "URB failed %d\n", urb->status);
0501         goto exit_usb_submit_urb;
0502     }
0503 
0504     /* get buffer to write */
0505     buffer = hackrf_get_next_buffer(dev, &dev->rx_buffer_list);
0506     if (unlikely(buffer == NULL)) {
0507         dev->vb_full++;
0508         dev_notice_ratelimited(&intf->dev,
0509                        "buffer is full - %u packets dropped\n",
0510                        dev->vb_full);
0511         goto exit_usb_submit_urb;
0512     }
0513 
0514     len = min_t(unsigned long, vb2_plane_size(&buffer->vb.vb2_buf, 0),
0515             urb->actual_length);
0516     hackrf_copy_stream(dev, vb2_plane_vaddr(&buffer->vb.vb2_buf, 0),
0517             urb->transfer_buffer, len);
0518     vb2_set_plane_payload(&buffer->vb.vb2_buf, 0, len);
0519     buffer->vb.sequence = dev->sequence++;
0520     buffer->vb.vb2_buf.timestamp = ktime_get_ns();
0521     vb2_buffer_done(&buffer->vb.vb2_buf, VB2_BUF_STATE_DONE);
0522 exit_usb_submit_urb:
0523     usb_submit_urb(urb, GFP_ATOMIC);
0524 }
0525 
0526 static void hackrf_urb_complete_out(struct urb *urb)
0527 {
0528     struct hackrf_dev *dev = urb->context;
0529     struct usb_interface *intf = dev->intf;
0530     struct hackrf_buffer *buffer;
0531     unsigned int len;
0532 
0533     dev_dbg_ratelimited(&intf->dev, "status=%d length=%u/%u\n", urb->status,
0534                 urb->actual_length, urb->transfer_buffer_length);
0535 
0536     switch (urb->status) {
0537     case 0:             /* success */
0538     case -ETIMEDOUT:    /* NAK */
0539         break;
0540     case -ECONNRESET:   /* kill */
0541     case -ENOENT:
0542     case -ESHUTDOWN:
0543         return;
0544     default:            /* error */
0545         dev_err_ratelimited(&intf->dev, "URB failed %d\n", urb->status);
0546     }
0547 
0548     /* get buffer to read */
0549     buffer = hackrf_get_next_buffer(dev, &dev->tx_buffer_list);
0550     if (unlikely(buffer == NULL)) {
0551         dev->vb_empty++;
0552         dev_notice_ratelimited(&intf->dev,
0553                        "buffer is empty - %u packets dropped\n",
0554                        dev->vb_empty);
0555         urb->actual_length = 0;
0556         goto exit_usb_submit_urb;
0557     }
0558 
0559     len = min_t(unsigned long, urb->transfer_buffer_length,
0560             vb2_get_plane_payload(&buffer->vb.vb2_buf, 0));
0561     hackrf_copy_stream(dev, urb->transfer_buffer,
0562                vb2_plane_vaddr(&buffer->vb.vb2_buf, 0), len);
0563     urb->actual_length = len;
0564     buffer->vb.sequence = dev->sequence++;
0565     buffer->vb.vb2_buf.timestamp = ktime_get_ns();
0566     vb2_buffer_done(&buffer->vb.vb2_buf, VB2_BUF_STATE_DONE);
0567 exit_usb_submit_urb:
0568     usb_submit_urb(urb, GFP_ATOMIC);
0569 }
0570 
0571 static int hackrf_kill_urbs(struct hackrf_dev *dev)
0572 {
0573     int i;
0574 
0575     for (i = dev->urbs_submitted - 1; i >= 0; i--) {
0576         dev_dbg(dev->dev, "kill urb=%d\n", i);
0577         /* stop the URB */
0578         usb_kill_urb(dev->urb_list[i]);
0579     }
0580     dev->urbs_submitted = 0;
0581 
0582     return 0;
0583 }
0584 
0585 static int hackrf_submit_urbs(struct hackrf_dev *dev)
0586 {
0587     int i, ret;
0588 
0589     for (i = 0; i < dev->urbs_initialized; i++) {
0590         dev_dbg(dev->dev, "submit urb=%d\n", i);
0591         ret = usb_submit_urb(dev->urb_list[i], GFP_KERNEL);
0592         if (ret) {
0593             dev_err(dev->dev, "Could not submit URB no. %d - get them all back\n",
0594                     i);
0595             hackrf_kill_urbs(dev);
0596             return ret;
0597         }
0598         dev->urbs_submitted++;
0599     }
0600 
0601     return 0;
0602 }
0603 
0604 static int hackrf_free_stream_bufs(struct hackrf_dev *dev)
0605 {
0606     if (dev->flags & USB_STATE_URB_BUF) {
0607         while (dev->buf_num) {
0608             dev->buf_num--;
0609             dev_dbg(dev->dev, "free buf=%d\n", dev->buf_num);
0610             usb_free_coherent(dev->udev, dev->buf_size,
0611                       dev->buf_list[dev->buf_num],
0612                       dev->dma_addr[dev->buf_num]);
0613         }
0614     }
0615     dev->flags &= ~USB_STATE_URB_BUF;
0616 
0617     return 0;
0618 }
0619 
0620 static int hackrf_alloc_stream_bufs(struct hackrf_dev *dev)
0621 {
0622     dev->buf_num = 0;
0623     dev->buf_size = BULK_BUFFER_SIZE;
0624 
0625     dev_dbg(dev->dev, "all in all I will use %u bytes for streaming\n",
0626             MAX_BULK_BUFS * BULK_BUFFER_SIZE);
0627 
0628     for (dev->buf_num = 0; dev->buf_num < MAX_BULK_BUFS; dev->buf_num++) {
0629         dev->buf_list[dev->buf_num] = usb_alloc_coherent(dev->udev,
0630                 BULK_BUFFER_SIZE, GFP_KERNEL,
0631                 &dev->dma_addr[dev->buf_num]);
0632         if (!dev->buf_list[dev->buf_num]) {
0633             dev_dbg(dev->dev, "alloc buf=%d failed\n",
0634                     dev->buf_num);
0635             hackrf_free_stream_bufs(dev);
0636             return -ENOMEM;
0637         }
0638 
0639         dev_dbg(dev->dev, "alloc buf=%d %p (dma %llu)\n", dev->buf_num,
0640                 dev->buf_list[dev->buf_num],
0641                 (long long)dev->dma_addr[dev->buf_num]);
0642         dev->flags |= USB_STATE_URB_BUF;
0643     }
0644 
0645     return 0;
0646 }
0647 
0648 static int hackrf_free_urbs(struct hackrf_dev *dev)
0649 {
0650     int i;
0651 
0652     hackrf_kill_urbs(dev);
0653 
0654     for (i = dev->urbs_initialized - 1; i >= 0; i--) {
0655         if (dev->urb_list[i]) {
0656             dev_dbg(dev->dev, "free urb=%d\n", i);
0657             /* free the URBs */
0658             usb_free_urb(dev->urb_list[i]);
0659         }
0660     }
0661     dev->urbs_initialized = 0;
0662 
0663     return 0;
0664 }
0665 
0666 static int hackrf_alloc_urbs(struct hackrf_dev *dev, bool rcv)
0667 {
0668     int i, j;
0669     unsigned int pipe;
0670     usb_complete_t complete;
0671 
0672     if (rcv) {
0673         pipe = usb_rcvbulkpipe(dev->udev, 0x81);
0674         complete = &hackrf_urb_complete_in;
0675     } else {
0676         pipe = usb_sndbulkpipe(dev->udev, 0x02);
0677         complete = &hackrf_urb_complete_out;
0678     }
0679 
0680     /* allocate the URBs */
0681     for (i = 0; i < MAX_BULK_BUFS; i++) {
0682         dev_dbg(dev->dev, "alloc urb=%d\n", i);
0683         dev->urb_list[i] = usb_alloc_urb(0, GFP_KERNEL);
0684         if (!dev->urb_list[i]) {
0685             for (j = 0; j < i; j++)
0686                 usb_free_urb(dev->urb_list[j]);
0687             return -ENOMEM;
0688         }
0689         usb_fill_bulk_urb(dev->urb_list[i],
0690                 dev->udev,
0691                 pipe,
0692                 dev->buf_list[i],
0693                 BULK_BUFFER_SIZE,
0694                 complete, dev);
0695 
0696         dev->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
0697         dev->urb_list[i]->transfer_dma = dev->dma_addr[i];
0698         dev->urbs_initialized++;
0699     }
0700 
0701     return 0;
0702 }
0703 
0704 /* The user yanked out the cable... */
0705 static void hackrf_disconnect(struct usb_interface *intf)
0706 {
0707     struct v4l2_device *v = usb_get_intfdata(intf);
0708     struct hackrf_dev *dev = container_of(v, struct hackrf_dev, v4l2_dev);
0709 
0710     dev_dbg(dev->dev, "\n");
0711 
0712     mutex_lock(&dev->vb_queue_lock);
0713     mutex_lock(&dev->v4l2_lock);
0714     /* No need to keep the urbs around after disconnection */
0715     dev->udev = NULL;
0716     v4l2_device_disconnect(&dev->v4l2_dev);
0717     video_unregister_device(&dev->tx_vdev);
0718     video_unregister_device(&dev->rx_vdev);
0719     mutex_unlock(&dev->v4l2_lock);
0720     mutex_unlock(&dev->vb_queue_lock);
0721 
0722     v4l2_device_put(&dev->v4l2_dev);
0723 }
0724 
0725 /* Videobuf2 operations */
0726 static void hackrf_return_all_buffers(struct vb2_queue *vq,
0727                       enum vb2_buffer_state state)
0728 {
0729     struct hackrf_dev *dev = vb2_get_drv_priv(vq);
0730     struct usb_interface *intf = dev->intf;
0731     struct hackrf_buffer *buffer, *node;
0732     struct list_head *buffer_list;
0733     unsigned long flags;
0734 
0735     dev_dbg(&intf->dev, "\n");
0736 
0737     if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
0738         buffer_list = &dev->rx_buffer_list;
0739     else
0740         buffer_list = &dev->tx_buffer_list;
0741 
0742     spin_lock_irqsave(&dev->buffer_list_lock, flags);
0743     list_for_each_entry_safe(buffer, node, buffer_list, list) {
0744         dev_dbg(&intf->dev, "list_for_each_entry_safe\n");
0745         vb2_buffer_done(&buffer->vb.vb2_buf, state);
0746         list_del(&buffer->list);
0747     }
0748     spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
0749 }
0750 
0751 static int hackrf_queue_setup(struct vb2_queue *vq,
0752         unsigned int *nbuffers,
0753         unsigned int *nplanes, unsigned int sizes[], struct device *alloc_devs[])
0754 {
0755     struct hackrf_dev *dev = vb2_get_drv_priv(vq);
0756 
0757     dev_dbg(dev->dev, "nbuffers=%d\n", *nbuffers);
0758 
0759     /* Need at least 8 buffers */
0760     if (vq->num_buffers + *nbuffers < 8)
0761         *nbuffers = 8 - vq->num_buffers;
0762     *nplanes = 1;
0763     sizes[0] = PAGE_ALIGN(dev->buffersize);
0764 
0765     dev_dbg(dev->dev, "nbuffers=%d sizes[0]=%d\n", *nbuffers, sizes[0]);
0766     return 0;
0767 }
0768 
0769 static void hackrf_buf_queue(struct vb2_buffer *vb)
0770 {
0771     struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
0772     struct vb2_queue *vq = vb->vb2_queue;
0773     struct hackrf_dev *dev = vb2_get_drv_priv(vq);
0774     struct hackrf_buffer *buffer = container_of(vbuf, struct hackrf_buffer, vb);
0775     struct list_head *buffer_list;
0776     unsigned long flags;
0777 
0778     dev_dbg_ratelimited(&dev->intf->dev, "\n");
0779 
0780     if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
0781         buffer_list = &dev->rx_buffer_list;
0782     else
0783         buffer_list = &dev->tx_buffer_list;
0784 
0785     spin_lock_irqsave(&dev->buffer_list_lock, flags);
0786     list_add_tail(&buffer->list, buffer_list);
0787     spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
0788 }
0789 
0790 static int hackrf_start_streaming(struct vb2_queue *vq, unsigned int count)
0791 {
0792     struct hackrf_dev *dev = vb2_get_drv_priv(vq);
0793     struct usb_interface *intf = dev->intf;
0794     int ret;
0795     unsigned int mode;
0796 
0797     dev_dbg(&intf->dev, "count=%i\n", count);
0798 
0799     mutex_lock(&dev->v4l2_lock);
0800 
0801     /* Allow only RX or TX, not both same time */
0802     if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE) {
0803         if (test_bit(TX_ON, &dev->flags)) {
0804             ret = -EBUSY;
0805             goto err_hackrf_return_all_buffers;
0806         }
0807 
0808         mode = 1;
0809         set_bit(RX_ON, &dev->flags);
0810     } else {
0811         if (test_bit(RX_ON, &dev->flags)) {
0812             ret = -EBUSY;
0813             goto err_hackrf_return_all_buffers;
0814         }
0815 
0816         mode = 2;
0817         set_bit(TX_ON, &dev->flags);
0818     }
0819 
0820     dev->sequence = 0;
0821 
0822     ret = hackrf_alloc_stream_bufs(dev);
0823     if (ret)
0824         goto err;
0825 
0826     ret = hackrf_alloc_urbs(dev, (mode == 1));
0827     if (ret)
0828         goto err;
0829 
0830     ret = hackrf_submit_urbs(dev);
0831     if (ret)
0832         goto err;
0833 
0834     ret = hackrf_set_params(dev);
0835     if (ret)
0836         goto err;
0837 
0838     /* start hardware streaming */
0839     ret = hackrf_ctrl_msg(dev, CMD_SET_TRANSCEIVER_MODE, mode, 0, NULL, 0);
0840     if (ret)
0841         goto err;
0842 
0843     mutex_unlock(&dev->v4l2_lock);
0844 
0845     return 0;
0846 err:
0847     hackrf_kill_urbs(dev);
0848     hackrf_free_urbs(dev);
0849     hackrf_free_stream_bufs(dev);
0850     clear_bit(RX_ON, &dev->flags);
0851     clear_bit(TX_ON, &dev->flags);
0852 err_hackrf_return_all_buffers:
0853     hackrf_return_all_buffers(vq, VB2_BUF_STATE_QUEUED);
0854     mutex_unlock(&dev->v4l2_lock);
0855     dev_dbg(&intf->dev, "failed=%d\n", ret);
0856     return ret;
0857 }
0858 
0859 static void hackrf_stop_streaming(struct vb2_queue *vq)
0860 {
0861     struct hackrf_dev *dev = vb2_get_drv_priv(vq);
0862     struct usb_interface *intf = dev->intf;
0863 
0864     dev_dbg(&intf->dev, "\n");
0865 
0866     mutex_lock(&dev->v4l2_lock);
0867 
0868     /* stop hardware streaming */
0869     hackrf_ctrl_msg(dev, CMD_SET_TRANSCEIVER_MODE, 0, 0, NULL, 0);
0870 
0871     hackrf_kill_urbs(dev);
0872     hackrf_free_urbs(dev);
0873     hackrf_free_stream_bufs(dev);
0874 
0875     hackrf_return_all_buffers(vq, VB2_BUF_STATE_ERROR);
0876 
0877     if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
0878         clear_bit(RX_ON, &dev->flags);
0879     else
0880         clear_bit(TX_ON, &dev->flags);
0881 
0882     mutex_unlock(&dev->v4l2_lock);
0883 }
0884 
0885 static const struct vb2_ops hackrf_vb2_ops = {
0886     .queue_setup            = hackrf_queue_setup,
0887     .buf_queue              = hackrf_buf_queue,
0888     .start_streaming        = hackrf_start_streaming,
0889     .stop_streaming         = hackrf_stop_streaming,
0890     .wait_prepare           = vb2_ops_wait_prepare,
0891     .wait_finish            = vb2_ops_wait_finish,
0892 };
0893 
0894 static int hackrf_querycap(struct file *file, void *fh,
0895         struct v4l2_capability *cap)
0896 {
0897     struct hackrf_dev *dev = video_drvdata(file);
0898     struct usb_interface *intf = dev->intf;
0899 
0900     dev_dbg(&intf->dev, "\n");
0901 
0902     cap->capabilities = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER |
0903                 V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR |
0904                 V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
0905                 V4L2_CAP_DEVICE_CAPS;
0906     strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
0907     strscpy(cap->card, dev->rx_vdev.name, sizeof(cap->card));
0908     usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
0909 
0910     return 0;
0911 }
0912 
0913 static int hackrf_s_fmt_sdr(struct file *file, void *priv,
0914                 struct v4l2_format *f)
0915 {
0916     struct hackrf_dev *dev = video_drvdata(file);
0917     struct video_device *vdev = video_devdata(file);
0918     struct vb2_queue *q;
0919     int i;
0920 
0921     dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
0922             (char *)&f->fmt.sdr.pixelformat);
0923 
0924     if (vdev->vfl_dir == VFL_DIR_RX)
0925         q = &dev->rx_vb2_queue;
0926     else
0927         q = &dev->tx_vb2_queue;
0928 
0929     if (vb2_is_busy(q))
0930         return -EBUSY;
0931 
0932     for (i = 0; i < NUM_FORMATS; i++) {
0933         if (f->fmt.sdr.pixelformat == formats[i].pixelformat) {
0934             dev->pixelformat = formats[i].pixelformat;
0935             dev->buffersize = formats[i].buffersize;
0936             f->fmt.sdr.buffersize = formats[i].buffersize;
0937             return 0;
0938         }
0939     }
0940 
0941     dev->pixelformat = formats[0].pixelformat;
0942     dev->buffersize = formats[0].buffersize;
0943     f->fmt.sdr.pixelformat = formats[0].pixelformat;
0944     f->fmt.sdr.buffersize = formats[0].buffersize;
0945 
0946     return 0;
0947 }
0948 
0949 static int hackrf_g_fmt_sdr(struct file *file, void *priv,
0950                 struct v4l2_format *f)
0951 {
0952     struct hackrf_dev *dev = video_drvdata(file);
0953 
0954     dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
0955             (char *)&dev->pixelformat);
0956 
0957     f->fmt.sdr.pixelformat = dev->pixelformat;
0958     f->fmt.sdr.buffersize = dev->buffersize;
0959 
0960     return 0;
0961 }
0962 
0963 static int hackrf_try_fmt_sdr(struct file *file, void *priv,
0964                   struct v4l2_format *f)
0965 {
0966     struct hackrf_dev *dev = video_drvdata(file);
0967     int i;
0968 
0969     dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
0970             (char *)&f->fmt.sdr.pixelformat);
0971 
0972     for (i = 0; i < NUM_FORMATS; i++) {
0973         if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
0974             f->fmt.sdr.buffersize = formats[i].buffersize;
0975             return 0;
0976         }
0977     }
0978 
0979     f->fmt.sdr.pixelformat = formats[0].pixelformat;
0980     f->fmt.sdr.buffersize = formats[0].buffersize;
0981 
0982     return 0;
0983 }
0984 
0985 static int hackrf_enum_fmt_sdr(struct file *file, void *priv,
0986                    struct v4l2_fmtdesc *f)
0987 {
0988     struct hackrf_dev *dev = video_drvdata(file);
0989 
0990     dev_dbg(dev->dev, "index=%d\n", f->index);
0991 
0992     if (f->index >= NUM_FORMATS)
0993         return -EINVAL;
0994 
0995     f->pixelformat = formats[f->index].pixelformat;
0996 
0997     return 0;
0998 }
0999 
1000 static int hackrf_s_tuner(struct file *file, void *priv,
1001         const struct v4l2_tuner *v)
1002 {
1003     struct hackrf_dev *dev = video_drvdata(file);
1004     int ret;
1005 
1006     dev_dbg(dev->dev, "index=%d\n", v->index);
1007 
1008     if (v->index == 0)
1009         ret = 0;
1010     else if (v->index == 1)
1011         ret = 0;
1012     else
1013         ret = -EINVAL;
1014 
1015     return ret;
1016 }
1017 
1018 static int hackrf_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
1019 {
1020     struct hackrf_dev *dev = video_drvdata(file);
1021     int ret;
1022 
1023     dev_dbg(dev->dev, "index=%d\n", v->index);
1024 
1025     if (v->index == 0) {
1026         strscpy(v->name, "HackRF ADC", sizeof(v->name));
1027         v->type = V4L2_TUNER_SDR;
1028         v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1029         v->rangelow  = bands_adc_dac[0].rangelow;
1030         v->rangehigh = bands_adc_dac[0].rangehigh;
1031         ret = 0;
1032     } else if (v->index == 1) {
1033         strscpy(v->name, "HackRF RF", sizeof(v->name));
1034         v->type = V4L2_TUNER_RF;
1035         v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1036         v->rangelow  = bands_rx_tx[0].rangelow;
1037         v->rangehigh = bands_rx_tx[0].rangehigh;
1038         ret = 0;
1039     } else {
1040         ret = -EINVAL;
1041     }
1042 
1043     return ret;
1044 }
1045 
1046 static int hackrf_s_modulator(struct file *file, void *fh,
1047                   const struct v4l2_modulator *a)
1048 {
1049     struct hackrf_dev *dev = video_drvdata(file);
1050 
1051     dev_dbg(dev->dev, "index=%d\n", a->index);
1052 
1053     return a->index > 1 ? -EINVAL : 0;
1054 }
1055 
1056 static int hackrf_g_modulator(struct file *file, void *fh,
1057                   struct v4l2_modulator *a)
1058 {
1059     struct hackrf_dev *dev = video_drvdata(file);
1060     int ret;
1061 
1062     dev_dbg(dev->dev, "index=%d\n", a->index);
1063 
1064     if (a->index == 0) {
1065         strscpy(a->name, "HackRF DAC", sizeof(a->name));
1066         a->type = V4L2_TUNER_SDR;
1067         a->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1068         a->rangelow  = bands_adc_dac[0].rangelow;
1069         a->rangehigh = bands_adc_dac[0].rangehigh;
1070         ret = 0;
1071     } else if (a->index == 1) {
1072         strscpy(a->name, "HackRF RF", sizeof(a->name));
1073         a->type = V4L2_TUNER_RF;
1074         a->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1075         a->rangelow  = bands_rx_tx[0].rangelow;
1076         a->rangehigh = bands_rx_tx[0].rangehigh;
1077         ret = 0;
1078     } else {
1079         ret = -EINVAL;
1080     }
1081 
1082     return ret;
1083 }
1084 
1085 static int hackrf_s_frequency(struct file *file, void *priv,
1086         const struct v4l2_frequency *f)
1087 {
1088     struct hackrf_dev *dev = video_drvdata(file);
1089     struct usb_interface *intf = dev->intf;
1090     struct video_device *vdev = video_devdata(file);
1091     int ret;
1092     unsigned int uitmp;
1093 
1094     dev_dbg(&intf->dev, "tuner=%d type=%d frequency=%u\n",
1095             f->tuner, f->type, f->frequency);
1096 
1097     if (f->tuner == 0) {
1098         uitmp = clamp(f->frequency, bands_adc_dac[0].rangelow,
1099                   bands_adc_dac[0].rangehigh);
1100         if (vdev->vfl_dir == VFL_DIR_RX) {
1101             dev->f_adc = uitmp;
1102             set_bit(RX_ADC_FREQUENCY, &dev->flags);
1103         } else {
1104             dev->f_dac = uitmp;
1105             set_bit(TX_DAC_FREQUENCY, &dev->flags);
1106         }
1107     } else if (f->tuner == 1) {
1108         uitmp = clamp(f->frequency, bands_rx_tx[0].rangelow,
1109                   bands_rx_tx[0].rangehigh);
1110         if (vdev->vfl_dir == VFL_DIR_RX) {
1111             dev->f_rx = uitmp;
1112             set_bit(RX_RF_FREQUENCY, &dev->flags);
1113         } else {
1114             dev->f_tx = uitmp;
1115             set_bit(TX_RF_FREQUENCY, &dev->flags);
1116         }
1117     } else {
1118         ret = -EINVAL;
1119         goto err;
1120     }
1121 
1122     ret = hackrf_set_params(dev);
1123     if (ret)
1124         goto err;
1125 
1126     return 0;
1127 err:
1128     dev_dbg(&intf->dev, "failed=%d\n", ret);
1129     return ret;
1130 }
1131 
1132 static int hackrf_g_frequency(struct file *file, void *priv,
1133         struct v4l2_frequency *f)
1134 {
1135     struct hackrf_dev *dev = video_drvdata(file);
1136     struct usb_interface *intf = dev->intf;
1137     struct video_device *vdev = video_devdata(file);
1138     int ret;
1139 
1140     dev_dbg(dev->dev, "tuner=%d type=%d\n", f->tuner, f->type);
1141 
1142     if (f->tuner == 0) {
1143         f->type = V4L2_TUNER_SDR;
1144         if (vdev->vfl_dir == VFL_DIR_RX)
1145             f->frequency = dev->f_adc;
1146         else
1147             f->frequency = dev->f_dac;
1148     } else if (f->tuner == 1) {
1149         f->type = V4L2_TUNER_RF;
1150         if (vdev->vfl_dir == VFL_DIR_RX)
1151             f->frequency = dev->f_rx;
1152         else
1153             f->frequency = dev->f_tx;
1154     } else {
1155         ret = -EINVAL;
1156         goto err;
1157     }
1158 
1159     return 0;
1160 err:
1161     dev_dbg(&intf->dev, "failed=%d\n", ret);
1162     return ret;
1163 }
1164 
1165 static int hackrf_enum_freq_bands(struct file *file, void *priv,
1166         struct v4l2_frequency_band *band)
1167 {
1168     struct hackrf_dev *dev = video_drvdata(file);
1169     int ret;
1170 
1171     dev_dbg(dev->dev, "tuner=%d type=%d index=%d\n",
1172             band->tuner, band->type, band->index);
1173 
1174     if (band->tuner == 0) {
1175         if (band->index >= ARRAY_SIZE(bands_adc_dac)) {
1176             ret = -EINVAL;
1177         } else {
1178             *band = bands_adc_dac[band->index];
1179             ret = 0;
1180         }
1181     } else if (band->tuner == 1) {
1182         if (band->index >= ARRAY_SIZE(bands_rx_tx)) {
1183             ret = -EINVAL;
1184         } else {
1185             *band = bands_rx_tx[band->index];
1186             ret = 0;
1187         }
1188     } else {
1189         ret = -EINVAL;
1190     }
1191 
1192     return ret;
1193 }
1194 
1195 static const struct v4l2_ioctl_ops hackrf_ioctl_ops = {
1196     .vidioc_querycap          = hackrf_querycap,
1197 
1198     .vidioc_s_fmt_sdr_cap     = hackrf_s_fmt_sdr,
1199     .vidioc_g_fmt_sdr_cap     = hackrf_g_fmt_sdr,
1200     .vidioc_enum_fmt_sdr_cap  = hackrf_enum_fmt_sdr,
1201     .vidioc_try_fmt_sdr_cap   = hackrf_try_fmt_sdr,
1202 
1203     .vidioc_s_fmt_sdr_out     = hackrf_s_fmt_sdr,
1204     .vidioc_g_fmt_sdr_out     = hackrf_g_fmt_sdr,
1205     .vidioc_enum_fmt_sdr_out  = hackrf_enum_fmt_sdr,
1206     .vidioc_try_fmt_sdr_out   = hackrf_try_fmt_sdr,
1207 
1208     .vidioc_reqbufs           = vb2_ioctl_reqbufs,
1209     .vidioc_create_bufs       = vb2_ioctl_create_bufs,
1210     .vidioc_prepare_buf       = vb2_ioctl_prepare_buf,
1211     .vidioc_querybuf          = vb2_ioctl_querybuf,
1212     .vidioc_qbuf              = vb2_ioctl_qbuf,
1213     .vidioc_dqbuf             = vb2_ioctl_dqbuf,
1214     .vidioc_expbuf            = vb2_ioctl_expbuf,
1215 
1216     .vidioc_streamon          = vb2_ioctl_streamon,
1217     .vidioc_streamoff         = vb2_ioctl_streamoff,
1218 
1219     .vidioc_s_tuner           = hackrf_s_tuner,
1220     .vidioc_g_tuner           = hackrf_g_tuner,
1221 
1222     .vidioc_s_modulator       = hackrf_s_modulator,
1223     .vidioc_g_modulator       = hackrf_g_modulator,
1224 
1225     .vidioc_s_frequency       = hackrf_s_frequency,
1226     .vidioc_g_frequency       = hackrf_g_frequency,
1227     .vidioc_enum_freq_bands   = hackrf_enum_freq_bands,
1228 
1229     .vidioc_subscribe_event   = v4l2_ctrl_subscribe_event,
1230     .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1231     .vidioc_log_status        = v4l2_ctrl_log_status,
1232 };
1233 
1234 static const struct v4l2_file_operations hackrf_fops = {
1235     .owner                    = THIS_MODULE,
1236     .open                     = v4l2_fh_open,
1237     .release                  = vb2_fop_release,
1238     .read                     = vb2_fop_read,
1239     .write                    = vb2_fop_write,
1240     .poll                     = vb2_fop_poll,
1241     .mmap                     = vb2_fop_mmap,
1242     .unlocked_ioctl           = video_ioctl2,
1243 };
1244 
1245 static const struct video_device hackrf_template = {
1246     .name                     = "HackRF One",
1247     .release                  = video_device_release_empty,
1248     .fops                     = &hackrf_fops,
1249     .ioctl_ops                = &hackrf_ioctl_ops,
1250 };
1251 
1252 static void hackrf_video_release(struct v4l2_device *v)
1253 {
1254     struct hackrf_dev *dev = container_of(v, struct hackrf_dev, v4l2_dev);
1255 
1256     dev_dbg(dev->dev, "\n");
1257 
1258     v4l2_ctrl_handler_free(&dev->rx_ctrl_handler);
1259     v4l2_ctrl_handler_free(&dev->tx_ctrl_handler);
1260     v4l2_device_unregister(&dev->v4l2_dev);
1261     kfree(dev);
1262 }
1263 
1264 static int hackrf_s_ctrl_rx(struct v4l2_ctrl *ctrl)
1265 {
1266     struct hackrf_dev *dev = container_of(ctrl->handler,
1267             struct hackrf_dev, rx_ctrl_handler);
1268     struct usb_interface *intf = dev->intf;
1269     int ret;
1270 
1271     switch (ctrl->id) {
1272     case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1273     case V4L2_CID_RF_TUNER_BANDWIDTH:
1274         set_bit(RX_BANDWIDTH, &dev->flags);
1275         break;
1276     case  V4L2_CID_RF_TUNER_RF_GAIN:
1277         set_bit(RX_RF_GAIN, &dev->flags);
1278         break;
1279     case  V4L2_CID_RF_TUNER_LNA_GAIN:
1280         set_bit(RX_LNA_GAIN, &dev->flags);
1281         break;
1282     case  V4L2_CID_RF_TUNER_IF_GAIN:
1283         set_bit(RX_IF_GAIN, &dev->flags);
1284         break;
1285     default:
1286         dev_dbg(&intf->dev, "unknown ctrl: id=%d name=%s\n",
1287             ctrl->id, ctrl->name);
1288         ret = -EINVAL;
1289         goto err;
1290     }
1291 
1292     ret = hackrf_set_params(dev);
1293     if (ret)
1294         goto err;
1295 
1296     return 0;
1297 err:
1298     dev_dbg(&intf->dev, "failed=%d\n", ret);
1299     return ret;
1300 }
1301 
1302 static int hackrf_s_ctrl_tx(struct v4l2_ctrl *ctrl)
1303 {
1304     struct hackrf_dev *dev = container_of(ctrl->handler,
1305             struct hackrf_dev, tx_ctrl_handler);
1306     struct usb_interface *intf = dev->intf;
1307     int ret;
1308 
1309     switch (ctrl->id) {
1310     case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1311     case V4L2_CID_RF_TUNER_BANDWIDTH:
1312         set_bit(TX_BANDWIDTH, &dev->flags);
1313         break;
1314     case  V4L2_CID_RF_TUNER_LNA_GAIN:
1315         set_bit(TX_LNA_GAIN, &dev->flags);
1316         break;
1317     case  V4L2_CID_RF_TUNER_RF_GAIN:
1318         set_bit(TX_RF_GAIN, &dev->flags);
1319         break;
1320     default:
1321         dev_dbg(&intf->dev, "unknown ctrl: id=%d name=%s\n",
1322             ctrl->id, ctrl->name);
1323         ret = -EINVAL;
1324         goto err;
1325     }
1326 
1327     ret = hackrf_set_params(dev);
1328     if (ret)
1329         goto err;
1330 
1331     return 0;
1332 err:
1333     dev_dbg(&intf->dev, "failed=%d\n", ret);
1334     return ret;
1335 }
1336 
1337 static const struct v4l2_ctrl_ops hackrf_ctrl_ops_rx = {
1338     .s_ctrl = hackrf_s_ctrl_rx,
1339 };
1340 
1341 static const struct v4l2_ctrl_ops hackrf_ctrl_ops_tx = {
1342     .s_ctrl = hackrf_s_ctrl_tx,
1343 };
1344 
1345 static int hackrf_probe(struct usb_interface *intf,
1346         const struct usb_device_id *id)
1347 {
1348     struct hackrf_dev *dev;
1349     int ret;
1350     u8 u8tmp, buf[BUF_SIZE];
1351 
1352     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1353     if (!dev) {
1354         ret = -ENOMEM;
1355         goto err;
1356     }
1357 
1358     mutex_init(&dev->v4l2_lock);
1359     mutex_init(&dev->vb_queue_lock);
1360     spin_lock_init(&dev->buffer_list_lock);
1361     INIT_LIST_HEAD(&dev->rx_buffer_list);
1362     INIT_LIST_HEAD(&dev->tx_buffer_list);
1363     dev->intf = intf;
1364     dev->dev = &intf->dev;
1365     dev->udev = interface_to_usbdev(intf);
1366     dev->pixelformat = formats[0].pixelformat;
1367     dev->buffersize = formats[0].buffersize;
1368     dev->f_adc = bands_adc_dac[0].rangelow;
1369     dev->f_dac = bands_adc_dac[0].rangelow;
1370     dev->f_rx = bands_rx_tx[0].rangelow;
1371     dev->f_tx = bands_rx_tx[0].rangelow;
1372     set_bit(RX_ADC_FREQUENCY, &dev->flags);
1373     set_bit(TX_DAC_FREQUENCY, &dev->flags);
1374     set_bit(RX_RF_FREQUENCY, &dev->flags);
1375     set_bit(TX_RF_FREQUENCY, &dev->flags);
1376 
1377     /* Detect device */
1378     ret = hackrf_ctrl_msg(dev, CMD_BOARD_ID_READ, 0, 0, &u8tmp, 1);
1379     if (ret == 0)
1380         ret = hackrf_ctrl_msg(dev, CMD_VERSION_STRING_READ, 0, 0,
1381                 buf, BUF_SIZE);
1382     if (ret) {
1383         dev_err(dev->dev, "Could not detect board\n");
1384         goto err_kfree;
1385     }
1386 
1387     buf[BUF_SIZE - 1] = '\0';
1388     dev_info(dev->dev, "Board ID: %02x\n", u8tmp);
1389     dev_info(dev->dev, "Firmware version: %s\n", buf);
1390 
1391     /* Init vb2 queue structure for receiver */
1392     dev->rx_vb2_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1393     dev->rx_vb2_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF |
1394                      VB2_READ;
1395     dev->rx_vb2_queue.ops = &hackrf_vb2_ops;
1396     dev->rx_vb2_queue.mem_ops = &vb2_vmalloc_memops;
1397     dev->rx_vb2_queue.drv_priv = dev;
1398     dev->rx_vb2_queue.buf_struct_size = sizeof(struct hackrf_buffer);
1399     dev->rx_vb2_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1400     ret = vb2_queue_init(&dev->rx_vb2_queue);
1401     if (ret) {
1402         dev_err(dev->dev, "Could not initialize rx vb2 queue\n");
1403         goto err_kfree;
1404     }
1405 
1406     /* Init vb2 queue structure for transmitter */
1407     dev->tx_vb2_queue.type = V4L2_BUF_TYPE_SDR_OUTPUT;
1408     dev->tx_vb2_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF |
1409                      VB2_WRITE;
1410     dev->tx_vb2_queue.ops = &hackrf_vb2_ops;
1411     dev->tx_vb2_queue.mem_ops = &vb2_vmalloc_memops;
1412     dev->tx_vb2_queue.drv_priv = dev;
1413     dev->tx_vb2_queue.buf_struct_size = sizeof(struct hackrf_buffer);
1414     dev->tx_vb2_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1415     ret = vb2_queue_init(&dev->tx_vb2_queue);
1416     if (ret) {
1417         dev_err(dev->dev, "Could not initialize tx vb2 queue\n");
1418         goto err_kfree;
1419     }
1420 
1421     /* Register controls for receiver */
1422     v4l2_ctrl_handler_init(&dev->rx_ctrl_handler, 5);
1423     dev->rx_bandwidth_auto = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1424         &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1425         0, 1, 0, 1);
1426     dev->rx_bandwidth = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1427         &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_BANDWIDTH,
1428         1750000, 28000000, 50000, 1750000);
1429     v4l2_ctrl_auto_cluster(2, &dev->rx_bandwidth_auto, 0, false);
1430     dev->rx_rf_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1431         &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_RF_GAIN, 0, 12, 12, 0);
1432     dev->rx_lna_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1433         &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_LNA_GAIN, 0, 40, 8, 0);
1434     dev->rx_if_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1435         &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_IF_GAIN, 0, 62, 2, 0);
1436     if (dev->rx_ctrl_handler.error) {
1437         ret = dev->rx_ctrl_handler.error;
1438         dev_err(dev->dev, "Could not initialize controls\n");
1439         goto err_v4l2_ctrl_handler_free_rx;
1440     }
1441     v4l2_ctrl_grab(dev->rx_rf_gain, !hackrf_enable_rf_gain_ctrl);
1442     v4l2_ctrl_handler_setup(&dev->rx_ctrl_handler);
1443 
1444     /* Register controls for transmitter */
1445     v4l2_ctrl_handler_init(&dev->tx_ctrl_handler, 4);
1446     dev->tx_bandwidth_auto = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1447         &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1448         0, 1, 0, 1);
1449     dev->tx_bandwidth = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1450         &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_BANDWIDTH,
1451         1750000, 28000000, 50000, 1750000);
1452     v4l2_ctrl_auto_cluster(2, &dev->tx_bandwidth_auto, 0, false);
1453     dev->tx_lna_gain = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1454         &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_LNA_GAIN, 0, 47, 1, 0);
1455     dev->tx_rf_gain = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1456         &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_RF_GAIN, 0, 15, 15, 0);
1457     if (dev->tx_ctrl_handler.error) {
1458         ret = dev->tx_ctrl_handler.error;
1459         dev_err(dev->dev, "Could not initialize controls\n");
1460         goto err_v4l2_ctrl_handler_free_tx;
1461     }
1462     v4l2_ctrl_grab(dev->tx_rf_gain, !hackrf_enable_rf_gain_ctrl);
1463     v4l2_ctrl_handler_setup(&dev->tx_ctrl_handler);
1464 
1465     /* Register the v4l2_device structure */
1466     dev->v4l2_dev.release = hackrf_video_release;
1467     ret = v4l2_device_register(&intf->dev, &dev->v4l2_dev);
1468     if (ret) {
1469         dev_err(dev->dev, "Failed to register v4l2-device (%d)\n", ret);
1470         goto err_v4l2_ctrl_handler_free_tx;
1471     }
1472 
1473     /* Init video_device structure for receiver */
1474     dev->rx_vdev = hackrf_template;
1475     dev->rx_vdev.queue = &dev->rx_vb2_queue;
1476     dev->rx_vdev.queue->lock = &dev->vb_queue_lock;
1477     dev->rx_vdev.v4l2_dev = &dev->v4l2_dev;
1478     dev->rx_vdev.ctrl_handler = &dev->rx_ctrl_handler;
1479     dev->rx_vdev.lock = &dev->v4l2_lock;
1480     dev->rx_vdev.vfl_dir = VFL_DIR_RX;
1481     dev->rx_vdev.device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
1482                    V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
1483     video_set_drvdata(&dev->rx_vdev, dev);
1484     ret = video_register_device(&dev->rx_vdev, VFL_TYPE_SDR, -1);
1485     if (ret) {
1486         dev_err(dev->dev,
1487             "Failed to register as video device (%d)\n", ret);
1488         goto err_v4l2_device_unregister;
1489     }
1490     dev_info(dev->dev, "Registered as %s\n",
1491          video_device_node_name(&dev->rx_vdev));
1492 
1493     /* Init video_device structure for transmitter */
1494     dev->tx_vdev = hackrf_template;
1495     dev->tx_vdev.queue = &dev->tx_vb2_queue;
1496     dev->tx_vdev.queue->lock = &dev->vb_queue_lock;
1497     dev->tx_vdev.v4l2_dev = &dev->v4l2_dev;
1498     dev->tx_vdev.ctrl_handler = &dev->tx_ctrl_handler;
1499     dev->tx_vdev.lock = &dev->v4l2_lock;
1500     dev->tx_vdev.vfl_dir = VFL_DIR_TX;
1501     dev->tx_vdev.device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
1502                    V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR;
1503     video_set_drvdata(&dev->tx_vdev, dev);
1504     ret = video_register_device(&dev->tx_vdev, VFL_TYPE_SDR, -1);
1505     if (ret) {
1506         dev_err(dev->dev,
1507             "Failed to register as video device (%d)\n", ret);
1508         goto err_video_unregister_device_rx;
1509     }
1510     dev_info(dev->dev, "Registered as %s\n",
1511          video_device_node_name(&dev->tx_vdev));
1512 
1513     dev_notice(dev->dev, "SDR API is still slightly experimental and functionality changes may follow\n");
1514     return 0;
1515 err_video_unregister_device_rx:
1516     video_unregister_device(&dev->rx_vdev);
1517 err_v4l2_device_unregister:
1518     v4l2_device_unregister(&dev->v4l2_dev);
1519 err_v4l2_ctrl_handler_free_tx:
1520     v4l2_ctrl_handler_free(&dev->tx_ctrl_handler);
1521 err_v4l2_ctrl_handler_free_rx:
1522     v4l2_ctrl_handler_free(&dev->rx_ctrl_handler);
1523 err_kfree:
1524     kfree(dev);
1525 err:
1526     dev_dbg(&intf->dev, "failed=%d\n", ret);
1527     return ret;
1528 }
1529 
1530 /* USB device ID list */
1531 static const struct usb_device_id hackrf_id_table[] = {
1532     { USB_DEVICE(0x1d50, 0x6089) }, /* HackRF One */
1533     { }
1534 };
1535 MODULE_DEVICE_TABLE(usb, hackrf_id_table);
1536 
1537 /* USB subsystem interface */
1538 static struct usb_driver hackrf_driver = {
1539     .name                     = KBUILD_MODNAME,
1540     .probe                    = hackrf_probe,
1541     .disconnect               = hackrf_disconnect,
1542     .id_table                 = hackrf_id_table,
1543 };
1544 
1545 module_usb_driver(hackrf_driver);
1546 
1547 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1548 MODULE_DESCRIPTION("HackRF");
1549 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!