drivers/media/usb/hackrf/hackrf.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * HackRF driver
   4  *
   5  * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/slab.h>
  10 #include <linux/usb.h>
  11 #include <media/v4l2-device.h>
  12 #include <media/v4l2-ioctl.h>
  13 #include <media/v4l2-ctrls.h>
  14 #include <media/v4l2-event.h>
  15 #include <media/videobuf2-v4l2.h>
  16 #include <media/videobuf2-vmalloc.h>
  17
  18 /*
  19  * Used Avago MGA-81563 RF amplifier could be destroyed pretty easily with too
  20  * strong signal or transmitting to bad antenna.
  21  * Set RF gain control to 'grabbed' state by default for sure.
  22  */
  23 static bool hackrf_enable_rf_gain_ctrl;
  24 module_param_named(enable_rf_gain_ctrl, hackrf_enable_rf_gain_ctrl, bool, 0644);
  25 MODULE_PARM_DESC(enable_rf_gain_ctrl, "enable RX/TX RF amplifier control (warn: could damage amplifier)");
  26
  27 /* HackRF USB API commands (from HackRF Library) */
  28 enum {
  29         CMD_SET_TRANSCEIVER_MODE           = 0x01,
  30         CMD_SAMPLE_RATE_SET                = 0x06,
  31         CMD_BASEBAND_FILTER_BANDWIDTH_SET  = 0x07,
  32         CMD_BOARD_ID_READ                  = 0x0e,
  33         CMD_VERSION_STRING_READ            = 0x0f,
  34         CMD_SET_FREQ                       = 0x10,
  35         CMD_AMP_ENABLE                     = 0x11,
  36         CMD_SET_LNA_GAIN                   = 0x13,
  37         CMD_SET_VGA_GAIN                   = 0x14,
  38         CMD_SET_TXVGA_GAIN                 = 0x15,
  39 };
  40
  41 /*
  42  *       bEndpointAddress     0x81  EP 1 IN
  43  *         Transfer Type            Bulk
  44  *       wMaxPacketSize     0x0200  1x 512 bytes
  45  */
  46 #define MAX_BULK_BUFS            (6)
  47 #define BULK_BUFFER_SIZE         (128 * 512)
  48
  49 static const struct v4l2_frequency_band bands_adc_dac[] = {
  50         {
  51                 .tuner = 0,
  52                 .type = V4L2_TUNER_SDR,
  53                 .index = 0,
  54                 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
  55                 .rangelow   =   200000,
  56                 .rangehigh  = 24000000,
  57         },
  58 };
  59
  60 static const struct v4l2_frequency_band bands_rx_tx[] = {
  61         {
  62                 .tuner = 1,
  63                 .type = V4L2_TUNER_RF,
  64                 .index = 0,
  65                 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
  66                 .rangelow   =          1,
  67                 .rangehigh  = 4294967294LL, /* max u32, hw goes over 7GHz */
  68         },
  69 };
  70
  71 /* stream formats */
  72 struct hackrf_format {
  73         u32     pixelformat;
  74         u32     buffersize;
  75 };
  76
  77 /* format descriptions for capture and preview */
  78 static struct hackrf_format formats[] = {
  79         {
  80                 .pixelformat    = V4L2_SDR_FMT_CS8,
  81                 .buffersize     = BULK_BUFFER_SIZE,
  82         },
  83 };
  84
  85 static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats);
  86
  87 /* intermediate buffers with raw data from the USB device */
  88 struct hackrf_buffer {
  89         struct vb2_v4l2_buffer vb;
  90         struct list_head list;
  91 };
  92
  93 struct hackrf_dev {
  94 #define USB_STATE_URB_BUF                1 /* XXX: set manually */
  95 #define RX_ON                            4
  96 #define TX_ON                            5
  97 #define RX_ADC_FREQUENCY                11
  98 #define TX_DAC_FREQUENCY                12
  99 #define RX_BANDWIDTH                    13
 100 #define TX_BANDWIDTH                    14
 101 #define RX_RF_FREQUENCY                 15
 102 #define TX_RF_FREQUENCY                 16
 103 #define RX_RF_GAIN                      17
 104 #define TX_RF_GAIN                      18
 105 #define RX_IF_GAIN                      19
 106 #define RX_LNA_GAIN                     20
 107 #define TX_LNA_GAIN                     21
 108         unsigned long flags;
 109
 110         struct usb_interface *intf;
 111         struct device *dev;
 112         struct usb_device *udev;
 113         struct video_device rx_vdev;
 114         struct video_device tx_vdev;
 115         struct v4l2_device v4l2_dev;
 116
 117         /* videobuf2 queue and queued buffers list */
 118         struct vb2_queue rx_vb2_queue;
 119         struct vb2_queue tx_vb2_queue;
 120         struct list_head rx_buffer_list;
 121         struct list_head tx_buffer_list;
 122         spinlock_t buffer_list_lock; /* Protects buffer_list */
 123         unsigned int sequence;       /* Buffer sequence counter */
 124         unsigned int vb_full;        /* vb is full and packets dropped */
 125         unsigned int vb_empty;       /* vb is empty and packets dropped */
 126
 127         /* Note if taking both locks v4l2_lock must always be locked first! */
 128         struct mutex v4l2_lock;      /* Protects everything else */
 129         struct mutex vb_queue_lock;  /* Protects vb_queue */
 130
 131         struct urb     *urb_list[MAX_BULK_BUFS];
 132         int            buf_num;
 133         unsigned long  buf_size;
 134         u8             *buf_list[MAX_BULK_BUFS];
 135         dma_addr_t     dma_addr[MAX_BULK_BUFS];
 136         int            urbs_initialized;
 137         int            urbs_submitted;
 138
 139         /* USB control message buffer */
 140         #define BUF_SIZE 24
 141         u8 buf[BUF_SIZE];
 142
 143         /* Current configuration */
 144         unsigned int f_adc;
 145         unsigned int f_dac;
 146         unsigned int f_rx;
 147         unsigned int f_tx;
 148         u32 pixelformat;
 149         u32 buffersize;
 150
 151         /* Controls */
 152         struct v4l2_ctrl_handler rx_ctrl_handler;
 153         struct v4l2_ctrl *rx_bandwidth_auto;
 154         struct v4l2_ctrl *rx_bandwidth;
 155         struct v4l2_ctrl *rx_rf_gain;
 156         struct v4l2_ctrl *rx_lna_gain;
 157         struct v4l2_ctrl *rx_if_gain;
 158         struct v4l2_ctrl_handler tx_ctrl_handler;
 159         struct v4l2_ctrl *tx_bandwidth_auto;
 160         struct v4l2_ctrl *tx_bandwidth;
 161         struct v4l2_ctrl *tx_rf_gain;
 162         struct v4l2_ctrl *tx_lna_gain;
 163
 164         /* Sample rate calc */
 165         unsigned long jiffies_next;
 166         unsigned int sample;
 167         unsigned int sample_measured;
 168 };
 169
 170 #define hackrf_dbg_usb_control_msg(_dev, _r, _t, _v, _i, _b, _l) { \
 171         char *_direction; \
 172         if (_t & USB_DIR_IN) \
 173                 _direction = "<<<"; \
 174         else \
 175                 _direction = ">>>"; \
 176         dev_dbg(_dev, "%02x %02x %02x %02x %02x %02x %02x %02x %s %*ph\n", \
 177                         _t, _r, _v & 0xff, _v >> 8, _i & 0xff, \
 178                         _i >> 8, _l & 0xff, _l >> 8, _direction, _l, _b); \
 179 }
 180
 181 /* execute firmware command */
 182 static int hackrf_ctrl_msg(struct hackrf_dev *dev, u8 request, u16 value,
 183                 u16 index, u8 *data, u16 size)
 184 {
 185         int ret;
 186         unsigned int pipe;
 187         u8 requesttype;
 188
 189         switch (request) {
 190         case CMD_SET_TRANSCEIVER_MODE:
 191         case CMD_SET_FREQ:
 192         case CMD_AMP_ENABLE:
 193         case CMD_SAMPLE_RATE_SET:
 194         case CMD_BASEBAND_FILTER_BANDWIDTH_SET:
 195                 pipe = usb_sndctrlpipe(dev->udev, 0);
 196                 requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
 197                 break;
 198         case CMD_BOARD_ID_READ:
 199         case CMD_VERSION_STRING_READ:
 200         case CMD_SET_LNA_GAIN:
 201         case CMD_SET_VGA_GAIN:
 202         case CMD_SET_TXVGA_GAIN:
 203                 pipe = usb_rcvctrlpipe(dev->udev, 0);
 204                 requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
 205                 break;
 206         default:
 207                 dev_err(dev->dev, "Unknown command %02x\n", request);
 208                 ret = -EINVAL;
 209                 goto err;
 210         }
 211
 212         /* write request */
 213         if (!(requesttype & USB_DIR_IN))
 214                 memcpy(dev->buf, data, size);
 215
 216         ret = usb_control_msg(dev->udev, pipe, request, requesttype, value,
 217                         index, dev->buf, size, 1000);
 218         hackrf_dbg_usb_control_msg(dev->dev, request, requesttype, value,
 219                         index, dev->buf, size);
 220         if (ret < 0) {
 221                 dev_err(dev->dev, "usb_control_msg() failed %d request %02x\n",
 222                                 ret, request);
 223                 goto err;
 224         }
 225
 226         /* read request */
 227         if (requesttype & USB_DIR_IN)
 228                 memcpy(data, dev->buf, size);
 229
 230         return 0;
 231 err:
 232         return ret;
 233 }
 234
 235 static int hackrf_set_params(struct hackrf_dev *dev)
 236 {
 237         struct usb_interface *intf = dev->intf;
 238         int ret, i;
 239         u8 buf[8], u8tmp;
 240         unsigned int uitmp, uitmp1, uitmp2;
 241         const bool rx = test_bit(RX_ON, &dev->flags);
 242         const bool tx = test_bit(TX_ON, &dev->flags);
 243         static const struct {
 244                 u32 freq;
 245         } bandwidth_lut[] = {
 246                 { 1750000}, /*  1.75 MHz */
 247                 { 2500000}, /*  2.5  MHz */
 248                 { 3500000}, /*  3.5  MHz */
 249                 { 5000000}, /*  5    MHz */
 250                 { 5500000}, /*  5.5  MHz */
 251                 { 6000000}, /*  6    MHz */
 252                 { 7000000}, /*  7    MHz */
 253                 { 8000000}, /*  8    MHz */
 254                 { 9000000}, /*  9    MHz */
 255                 {10000000}, /* 10    MHz */
 256                 {12000000}, /* 12    MHz */
 257                 {14000000}, /* 14    MHz */
 258                 {15000000}, /* 15    MHz */
 259                 {20000000}, /* 20    MHz */
 260                 {24000000}, /* 24    MHz */
 261                 {28000000}, /* 28    MHz */
 262         };
 263
 264         if (!rx && !tx) {
 265                 dev_dbg(&intf->dev, "device is sleeping\n");
 266                 return 0;
 267         }
 268
 269         /* ADC / DAC frequency */
 270         if (rx && test_and_clear_bit(RX_ADC_FREQUENCY, &dev->flags)) {
 271                 dev_dbg(&intf->dev, "RX ADC frequency=%u Hz\n", dev->f_adc);
 272                 uitmp1 = dev->f_adc;
 273                 uitmp2 = 1;
 274                 set_bit(TX_DAC_FREQUENCY, &dev->flags);
 275         } else if (tx && test_and_clear_bit(TX_DAC_FREQUENCY, &dev->flags)) {
 276                 dev_dbg(&intf->dev, "TX DAC frequency=%u Hz\n", dev->f_dac);
 277                 uitmp1 = dev->f_dac;
 278                 uitmp2 = 1;
 279                 set_bit(RX_ADC_FREQUENCY, &dev->flags);
 280         } else {
 281                 uitmp1 = uitmp2 = 0;
 282         }
 283         if (uitmp1 || uitmp2) {
 284                 buf[0] = (uitmp1 >>  0) & 0xff;
 285                 buf[1] = (uitmp1 >>  8) & 0xff;
 286                 buf[2] = (uitmp1 >> 16) & 0xff;
 287                 buf[3] = (uitmp1 >> 24) & 0xff;
 288                 buf[4] = (uitmp2 >>  0) & 0xff;
 289                 buf[5] = (uitmp2 >>  8) & 0xff;
 290                 buf[6] = (uitmp2 >> 16) & 0xff;
 291                 buf[7] = (uitmp2 >> 24) & 0xff;
 292                 ret = hackrf_ctrl_msg(dev, CMD_SAMPLE_RATE_SET, 0, 0, buf, 8);
 293                 if (ret)
 294                         goto err;
 295         }
 296
 297         /* bandwidth */
 298         if (rx && test_and_clear_bit(RX_BANDWIDTH, &dev->flags)) {
 299                 if (dev->rx_bandwidth_auto->val == true)
 300                         uitmp = dev->f_adc;
 301                 else
 302                         uitmp = dev->rx_bandwidth->val;
 303
 304                 for (i = 0; i < ARRAY_SIZE(bandwidth_lut); i++) {
 305                         if (uitmp <= bandwidth_lut[i].freq) {
 306                                 uitmp = bandwidth_lut[i].freq;
 307                                 break;
 308                         }
 309                 }
 310                 dev->rx_bandwidth->val = uitmp;
 311                 dev->rx_bandwidth->cur.val = uitmp;
 312                 dev_dbg(&intf->dev, "RX bandwidth selected=%u\n", uitmp);
 313                 set_bit(TX_BANDWIDTH, &dev->flags);
 314         } else if (tx && test_and_clear_bit(TX_BANDWIDTH, &dev->flags)) {
 315                 if (dev->tx_bandwidth_auto->val == true)
 316                         uitmp = dev->f_dac;
 317                 else
 318                         uitmp = dev->tx_bandwidth->val;
 319
 320                 for (i = 0; i < ARRAY_SIZE(bandwidth_lut); i++) {
 321                         if (uitmp <= bandwidth_lut[i].freq) {
 322                                 uitmp = bandwidth_lut[i].freq;
 323                                 break;
 324                         }
 325                 }
 326                 dev->tx_bandwidth->val = uitmp;
 327                 dev->tx_bandwidth->cur.val = uitmp;
 328                 dev_dbg(&intf->dev, "TX bandwidth selected=%u\n", uitmp);
 329                 set_bit(RX_BANDWIDTH, &dev->flags);
 330         } else {
 331                 uitmp = 0;
 332         }
 333         if (uitmp) {
 334                 uitmp1 = uitmp2 = 0;
 335                 uitmp1 |= ((uitmp >>  0) & 0xff) << 0;
 336                 uitmp1 |= ((uitmp >>  8) & 0xff) << 8;
 337                 uitmp2 |= ((uitmp >> 16) & 0xff) << 0;
 338                 uitmp2 |= ((uitmp >> 24) & 0xff) << 8;
 339                 ret = hackrf_ctrl_msg(dev, CMD_BASEBAND_FILTER_BANDWIDTH_SET,
 340                                       uitmp1, uitmp2, NULL, 0);
 341                 if (ret)
 342                         goto err;
 343         }
 344
 345         /* RX / TX RF frequency */
 346         if (rx && test_and_clear_bit(RX_RF_FREQUENCY, &dev->flags)) {
 347                 dev_dbg(&intf->dev, "RX RF frequency=%u Hz\n", dev->f_rx);
 348                 uitmp1 = dev->f_rx / 1000000;
 349                 uitmp2 = dev->f_rx % 1000000;
 350                 set_bit(TX_RF_FREQUENCY, &dev->flags);
 351         } else if (tx && test_and_clear_bit(TX_RF_FREQUENCY, &dev->flags)) {
 352                 dev_dbg(&intf->dev, "TX RF frequency=%u Hz\n", dev->f_tx);
 353                 uitmp1 = dev->f_tx / 1000000;
 354                 uitmp2 = dev->f_tx % 1000000;
 355                 set_bit(RX_RF_FREQUENCY, &dev->flags);
 356         } else {
 357                 uitmp1 = uitmp2 = 0;
 358         }
 359         if (uitmp1 || uitmp2) {
 360                 buf[0] = (uitmp1 >>  0) & 0xff;
 361                 buf[1] = (uitmp1 >>  8) & 0xff;
 362                 buf[2] = (uitmp1 >> 16) & 0xff;
 363                 buf[3] = (uitmp1 >> 24) & 0xff;
 364                 buf[4] = (uitmp2 >>  0) & 0xff;
 365                 buf[5] = (uitmp2 >>  8) & 0xff;
 366                 buf[6] = (uitmp2 >> 16) & 0xff;
 367                 buf[7] = (uitmp2 >> 24) & 0xff;
 368                 ret = hackrf_ctrl_msg(dev, CMD_SET_FREQ, 0, 0, buf, 8);
 369                 if (ret)
 370                         goto err;
 371         }
 372
 373         /* RX RF gain */
 374         if (rx && test_and_clear_bit(RX_RF_GAIN, &dev->flags)) {
 375                 dev_dbg(&intf->dev, "RX RF gain val=%d->%d\n",
 376                         dev->rx_rf_gain->cur.val, dev->rx_rf_gain->val);
 377
 378                 u8tmp = (dev->rx_rf_gain->val) ? 1 : 0;
 379                 ret = hackrf_ctrl_msg(dev, CMD_AMP_ENABLE, u8tmp, 0, NULL, 0);
 380                 if (ret)
 381                         goto err;
 382                 set_bit(TX_RF_GAIN, &dev->flags);
 383         }
 384
 385         /* TX RF gain */
 386         if (tx && test_and_clear_bit(TX_RF_GAIN, &dev->flags)) {
 387                 dev_dbg(&intf->dev, "TX RF gain val=%d->%d\n",
 388                         dev->tx_rf_gain->cur.val, dev->tx_rf_gain->val);
 389
 390                 u8tmp = (dev->tx_rf_gain->val) ? 1 : 0;
 391                 ret = hackrf_ctrl_msg(dev, CMD_AMP_ENABLE, u8tmp, 0, NULL, 0);
 392                 if (ret)
 393                         goto err;
 394                 set_bit(RX_RF_GAIN, &dev->flags);
 395         }
 396
 397         /* RX LNA gain */
 398         if (rx && test_and_clear_bit(RX_LNA_GAIN, &dev->flags)) {
 399                 dev_dbg(dev->dev, "RX LNA gain val=%d->%d\n",
 400                         dev->rx_lna_gain->cur.val, dev->rx_lna_gain->val);
 401
 402                 ret = hackrf_ctrl_msg(dev, CMD_SET_LNA_GAIN, 0,
 403                                       dev->rx_lna_gain->val, &u8tmp, 1);
 404                 if (ret)
 405                         goto err;
 406         }
 407
 408         /* RX IF gain */
 409         if (rx && test_and_clear_bit(RX_IF_GAIN, &dev->flags)) {
 410                 dev_dbg(&intf->dev, "IF gain val=%d->%d\n",
 411                         dev->rx_if_gain->cur.val, dev->rx_if_gain->val);
 412
 413                 ret = hackrf_ctrl_msg(dev, CMD_SET_VGA_GAIN, 0,
 414                                       dev->rx_if_gain->val, &u8tmp, 1);
 415                 if (ret)
 416                         goto err;
 417         }
 418
 419         /* TX LNA gain */
 420         if (tx && test_and_clear_bit(TX_LNA_GAIN, &dev->flags)) {
 421                 dev_dbg(&intf->dev, "TX LNA gain val=%d->%d\n",
 422                         dev->tx_lna_gain->cur.val, dev->tx_lna_gain->val);
 423
 424                 ret = hackrf_ctrl_msg(dev, CMD_SET_TXVGA_GAIN, 0,
 425                                       dev->tx_lna_gain->val, &u8tmp, 1);
 426                 if (ret)
 427                         goto err;
 428         }
 429
 430         return 0;
 431 err:
 432         dev_dbg(&intf->dev, "failed=%d\n", ret);
 433         return ret;
 434 }
 435
 436 /* Private functions */
 437 static struct hackrf_buffer *hackrf_get_next_buffer(struct hackrf_dev *dev,
 438                                                     struct list_head *buffer_list)
 439 {
 440         unsigned long flags;
 441         struct hackrf_buffer *buffer = NULL;
 442
 443         spin_lock_irqsave(&dev->buffer_list_lock, flags);
 444         if (list_empty(buffer_list))
 445                 goto leave;
 446
 447         buffer = list_entry(buffer_list->next, struct hackrf_buffer, list);
 448         list_del(&buffer->list);
 449 leave:
 450         spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
 451         return buffer;
 452 }
 453
 454 static void hackrf_copy_stream(struct hackrf_dev *dev, void *dst, void *src,
 455                                unsigned int src_len)
 456 {
 457         memcpy(dst, src, src_len);
 458
 459         /* calculate sample rate and output it in 10 seconds intervals */
 460         if (unlikely(time_is_before_jiffies(dev->jiffies_next))) {
 461                 #define MSECS 10000UL
 462                 unsigned int msecs = jiffies_to_msecs(jiffies -
 463                                 dev->jiffies_next + msecs_to_jiffies(MSECS));
 464                 unsigned int samples = dev->sample - dev->sample_measured;
 465
 466                 dev->jiffies_next = jiffies + msecs_to_jiffies(MSECS);
 467                 dev->sample_measured = dev->sample;
 468                 dev_dbg(dev->dev, "slen=%u samples=%u msecs=%u sample rate=%lu\n",
 469                                 src_len, samples, msecs,
 470                                 samples * 1000UL / msecs);
 471         }
 472
 473         /* total number of samples */
 474         dev->sample += src_len / 2;
 475 }
 476
 477 /*
 478  * This gets called for the bulk stream pipe. This is done in interrupt
 479  * time, so it has to be fast, not crash, and not stall. Neat.
 480  */
 481 static void hackrf_urb_complete_in(struct urb *urb)
 482 {
 483         struct hackrf_dev *dev = urb->context;
 484         struct usb_interface *intf = dev->intf;
 485         struct hackrf_buffer *buffer;
 486         unsigned int len;
 487
 488         dev_dbg_ratelimited(&intf->dev, "status=%d length=%u/%u\n", urb->status,
 489                             urb->actual_length, urb->transfer_buffer_length);
 490
 491         switch (urb->status) {
 492         case 0:             /* success */
 493         case -ETIMEDOUT:    /* NAK */
 494                 break;
 495         case -ECONNRESET:   /* kill */
 496         case -ENOENT:
 497         case -ESHUTDOWN:
 498                 return;
 499         default:            /* error */
 500                 dev_err_ratelimited(&intf->dev, "URB failed %d\n", urb->status);
 501                 goto exit_usb_submit_urb;
 502         }
 503
 504         /* get buffer to write */
 505         buffer = hackrf_get_next_buffer(dev, &dev->rx_buffer_list);
 506         if (unlikely(buffer == NULL)) {
 507                 dev->vb_full++;
 508                 dev_notice_ratelimited(&intf->dev,
 509                                        "buffer is full - %u packets dropped\n",
 510                                        dev->vb_full);
 511                 goto exit_usb_submit_urb;
 512         }
 513
 514         len = min_t(unsigned long, vb2_plane_size(&buffer->vb.vb2_buf, 0),
 515                     urb->actual_length);
 516         hackrf_copy_stream(dev, vb2_plane_vaddr(&buffer->vb.vb2_buf, 0),
 517                     urb->transfer_buffer, len);
 518         vb2_set_plane_payload(&buffer->vb.vb2_buf, 0, len);
 519         buffer->vb.sequence = dev->sequence++;
 520         buffer->vb.vb2_buf.timestamp = ktime_get_ns();
 521         vb2_buffer_done(&buffer->vb.vb2_buf, VB2_BUF_STATE_DONE);
 522 exit_usb_submit_urb:
 523         usb_submit_urb(urb, GFP_ATOMIC);
 524 }
 525
 526 static void hackrf_urb_complete_out(struct urb *urb)
 527 {
 528         struct hackrf_dev *dev = urb->context;
 529         struct usb_interface *intf = dev->intf;
 530         struct hackrf_buffer *buffer;
 531         unsigned int len;
 532
 533         dev_dbg_ratelimited(&intf->dev, "status=%d length=%u/%u\n", urb->status,
 534                             urb->actual_length, urb->transfer_buffer_length);
 535
 536         switch (urb->status) {
 537         case 0:             /* success */
 538         case -ETIMEDOUT:    /* NAK */
 539                 break;
 540         case -ECONNRESET:   /* kill */
 541         case -ENOENT:
 542         case -ESHUTDOWN:
 543                 return;
 544         default:            /* error */
 545                 dev_err_ratelimited(&intf->dev, "URB failed %d\n", urb->status);
 546         }
 547
 548         /* get buffer to read */
 549         buffer = hackrf_get_next_buffer(dev, &dev->tx_buffer_list);
 550         if (unlikely(buffer == NULL)) {
 551                 dev->vb_empty++;
 552                 dev_notice_ratelimited(&intf->dev,
 553                                        "buffer is empty - %u packets dropped\n",
 554                                        dev->vb_empty);
 555                 urb->actual_length = 0;
 556                 goto exit_usb_submit_urb;
 557         }
 558
 559         len = min_t(unsigned long, urb->transfer_buffer_length,
 560                     vb2_get_plane_payload(&buffer->vb.vb2_buf, 0));
 561         hackrf_copy_stream(dev, urb->transfer_buffer,
 562                            vb2_plane_vaddr(&buffer->vb.vb2_buf, 0), len);
 563         urb->actual_length = len;
 564         buffer->vb.sequence = dev->sequence++;
 565         buffer->vb.vb2_buf.timestamp = ktime_get_ns();
 566         vb2_buffer_done(&buffer->vb.vb2_buf, VB2_BUF_STATE_DONE);
 567 exit_usb_submit_urb:
 568         usb_submit_urb(urb, GFP_ATOMIC);
 569 }
 570
 571 static int hackrf_kill_urbs(struct hackrf_dev *dev)
 572 {
 573         int i;
 574
 575         for (i = dev->urbs_submitted - 1; i >= 0; i--) {
 576                 dev_dbg(dev->dev, "kill urb=%d\n", i);
 577                 /* stop the URB */
 578                 usb_kill_urb(dev->urb_list[i]);
 579         }
 580         dev->urbs_submitted = 0;
 581
 582         return 0;
 583 }
 584
 585 static int hackrf_submit_urbs(struct hackrf_dev *dev)
 586 {
 587         int i, ret;
 588
 589         for (i = 0; i < dev->urbs_initialized; i++) {
 590                 dev_dbg(dev->dev, "submit urb=%d\n", i);
 591                 ret = usb_submit_urb(dev->urb_list[i], GFP_KERNEL);
 592                 if (ret) {
 593                         dev_err(dev->dev, "Could not submit URB no. %d - get them all back\n",
 594                                         i);
 595                         hackrf_kill_urbs(dev);
 596                         return ret;
 597                 }
 598                 dev->urbs_submitted++;
 599         }
 600
 601         return 0;
 602 }
 603
 604 static int hackrf_free_stream_bufs(struct hackrf_dev *dev)
 605 {
 606         if (dev->flags & USB_STATE_URB_BUF) {
 607                 while (dev->buf_num) {
 608                         dev->buf_num--;
 609                         dev_dbg(dev->dev, "free buf=%d\n", dev->buf_num);
 610                         usb_free_coherent(dev->udev, dev->buf_size,
 611                                           dev->buf_list[dev->buf_num],
 612                                           dev->dma_addr[dev->buf_num]);
 613                 }
 614         }
 615         dev->flags &= ~USB_STATE_URB_BUF;
 616
 617         return 0;
 618 }
 619
 620 static int hackrf_alloc_stream_bufs(struct hackrf_dev *dev)
 621 {
 622         dev->buf_num = 0;
 623         dev->buf_size = BULK_BUFFER_SIZE;
 624
 625         dev_dbg(dev->dev, "all in all I will use %u bytes for streaming\n",
 626                         MAX_BULK_BUFS * BULK_BUFFER_SIZE);
 627
 628         for (dev->buf_num = 0; dev->buf_num < MAX_BULK_BUFS; dev->buf_num++) {
 629                 dev->buf_list[dev->buf_num] = usb_alloc_coherent(dev->udev,
 630                                 BULK_BUFFER_SIZE, GFP_KERNEL,
 631                                 &dev->dma_addr[dev->buf_num]);
 632                 if (!dev->buf_list[dev->buf_num]) {
 633                         dev_dbg(dev->dev, "alloc buf=%d failed\n",
 634                                         dev->buf_num);
 635                         hackrf_free_stream_bufs(dev);
 636                         return -ENOMEM;
 637                 }
 638
 639                 dev_dbg(dev->dev, "alloc buf=%d %p (dma %llu)\n", dev->buf_num,
 640                                 dev->buf_list[dev->buf_num],
 641                                 (long long)dev->dma_addr[dev->buf_num]);
 642                 dev->flags |= USB_STATE_URB_BUF;
 643         }
 644
 645         return 0;
 646 }
 647
 648 static int hackrf_free_urbs(struct hackrf_dev *dev)
 649 {
 650         int i;
 651
 652         hackrf_kill_urbs(dev);
 653
 654         for (i = dev->urbs_initialized - 1; i >= 0; i--) {
 655                 if (dev->urb_list[i]) {
 656                         dev_dbg(dev->dev, "free urb=%d\n", i);
 657                         /* free the URBs */
 658                         usb_free_urb(dev->urb_list[i]);
 659                 }
 660         }
 661         dev->urbs_initialized = 0;
 662
 663         return 0;
 664 }
 665
 666 static int hackrf_alloc_urbs(struct hackrf_dev *dev, bool rcv)
 667 {
 668         int i, j;
 669         unsigned int pipe;
 670         usb_complete_t complete;
 671
 672         if (rcv) {
 673                 pipe = usb_rcvbulkpipe(dev->udev, 0x81);
 674                 complete = &hackrf_urb_complete_in;
 675         } else {
 676                 pipe = usb_sndbulkpipe(dev->udev, 0x02);
 677                 complete = &hackrf_urb_complete_out;
 678         }
 679
 680         /* allocate the URBs */
 681         for (i = 0; i < MAX_BULK_BUFS; i++) {
 682                 dev_dbg(dev->dev, "alloc urb=%d\n", i);
 683                 dev->urb_list[i] = usb_alloc_urb(0, GFP_KERNEL);
 684                 if (!dev->urb_list[i]) {
 685                         for (j = 0; j < i; j++)
 686                                 usb_free_urb(dev->urb_list[j]);
 687                         return -ENOMEM;
 688                 }
 689                 usb_fill_bulk_urb(dev->urb_list[i],
 690                                 dev->udev,
 691                                 pipe,
 692                                 dev->buf_list[i],
 693                                 BULK_BUFFER_SIZE,
 694                                 complete, dev);
 695
 696                 dev->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 697                 dev->urb_list[i]->transfer_dma = dev->dma_addr[i];
 698                 dev->urbs_initialized++;
 699         }
 700
 701         return 0;
 702 }
 703
 704 /* The user yanked out the cable... */
 705 static void hackrf_disconnect(struct usb_interface *intf)
 706 {
 707         struct v4l2_device *v = usb_get_intfdata(intf);
 708         struct hackrf_dev *dev = container_of(v, struct hackrf_dev, v4l2_dev);
 709
 710         dev_dbg(dev->dev, "\n");
 711
 712         mutex_lock(&dev->vb_queue_lock);
 713         mutex_lock(&dev->v4l2_lock);
 714         /* No need to keep the urbs around after disconnection */
 715         dev->udev = NULL;
 716         v4l2_device_disconnect(&dev->v4l2_dev);
 717         video_unregister_device(&dev->tx_vdev);
 718         video_unregister_device(&dev->rx_vdev);
 719         mutex_unlock(&dev->v4l2_lock);
 720         mutex_unlock(&dev->vb_queue_lock);
 721
 722         v4l2_device_put(&dev->v4l2_dev);
 723 }
 724
 725 /* Videobuf2 operations */
 726 static void hackrf_return_all_buffers(struct vb2_queue *vq,
 727                                       enum vb2_buffer_state state)
 728 {
 729         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 730         struct usb_interface *intf = dev->intf;
 731         struct hackrf_buffer *buffer, *node;
 732         struct list_head *buffer_list;
 733         unsigned long flags;
 734
 735         dev_dbg(&intf->dev, "\n");
 736
 737         if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
 738                 buffer_list = &dev->rx_buffer_list;
 739         else
 740                 buffer_list = &dev->tx_buffer_list;
 741
 742         spin_lock_irqsave(&dev->buffer_list_lock, flags);
 743         list_for_each_entry_safe(buffer, node, buffer_list, list) {
 744                 dev_dbg(&intf->dev, "list_for_each_entry_safe\n");
 745                 vb2_buffer_done(&buffer->vb.vb2_buf, state);
 746                 list_del(&buffer->list);
 747         }
 748         spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
 749 }
 750
 751 static int hackrf_queue_setup(struct vb2_queue *vq,
 752                 unsigned int *nbuffers,
 753                 unsigned int *nplanes, unsigned int sizes[], struct device *alloc_devs[])
 754 {
 755         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 756         unsigned int q_num_bufs = vb2_get_num_buffers(vq);
 757
 758         dev_dbg(dev->dev, "nbuffers=%d\n", *nbuffers);
 759
 760         /* Need at least 8 buffers */
 761         if (q_num_bufs + *nbuffers < 8)
 762                 *nbuffers = 8 - q_num_bufs;
 763         *nplanes = 1;
 764         sizes[0] = PAGE_ALIGN(dev->buffersize);
 765
 766         dev_dbg(dev->dev, "nbuffers=%d sizes[0]=%d\n", *nbuffers, sizes[0]);
 767         return 0;
 768 }
 769
 770 static void hackrf_buf_queue(struct vb2_buffer *vb)
 771 {
 772         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 773         struct vb2_queue *vq = vb->vb2_queue;
 774         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 775         struct hackrf_buffer *buffer = container_of(vbuf, struct hackrf_buffer, vb);
 776         struct list_head *buffer_list;
 777         unsigned long flags;
 778
 779         dev_dbg_ratelimited(&dev->intf->dev, "\n");
 780
 781         if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
 782                 buffer_list = &dev->rx_buffer_list;
 783         else
 784                 buffer_list = &dev->tx_buffer_list;
 785
 786         spin_lock_irqsave(&dev->buffer_list_lock, flags);
 787         list_add_tail(&buffer->list, buffer_list);
 788         spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
 789 }
 790
 791 static int hackrf_start_streaming(struct vb2_queue *vq, unsigned int count)
 792 {
 793         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 794         struct usb_interface *intf = dev->intf;
 795         int ret;
 796         unsigned int mode;
 797
 798         dev_dbg(&intf->dev, "count=%i\n", count);
 799
 800         mutex_lock(&dev->v4l2_lock);
 801
 802         /* Allow only RX or TX, not both same time */
 803         if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE) {
 804                 if (test_bit(TX_ON, &dev->flags)) {
 805                         ret = -EBUSY;
 806                         goto err_hackrf_return_all_buffers;
 807                 }
 808
 809                 mode = 1;
 810                 set_bit(RX_ON, &dev->flags);
 811         } else {
 812                 if (test_bit(RX_ON, &dev->flags)) {
 813                         ret = -EBUSY;
 814                         goto err_hackrf_return_all_buffers;
 815                 }
 816
 817                 mode = 2;
 818                 set_bit(TX_ON, &dev->flags);
 819         }
 820
 821         dev->sequence = 0;
 822
 823         ret = hackrf_alloc_stream_bufs(dev);
 824         if (ret)
 825                 goto err;
 826
 827         ret = hackrf_alloc_urbs(dev, (mode == 1));
 828         if (ret)
 829                 goto err;
 830
 831         ret = hackrf_submit_urbs(dev);
 832         if (ret)
 833                 goto err;
 834
 835         ret = hackrf_set_params(dev);
 836         if (ret)
 837                 goto err;
 838
 839         /* start hardware streaming */
 840         ret = hackrf_ctrl_msg(dev, CMD_SET_TRANSCEIVER_MODE, mode, 0, NULL, 0);
 841         if (ret)
 842                 goto err;
 843
 844         mutex_unlock(&dev->v4l2_lock);
 845
 846         return 0;
 847 err:
 848         hackrf_kill_urbs(dev);
 849         hackrf_free_urbs(dev);
 850         hackrf_free_stream_bufs(dev);
 851         clear_bit(RX_ON, &dev->flags);
 852         clear_bit(TX_ON, &dev->flags);
 853 err_hackrf_return_all_buffers:
 854         hackrf_return_all_buffers(vq, VB2_BUF_STATE_QUEUED);
 855         mutex_unlock(&dev->v4l2_lock);
 856         dev_dbg(&intf->dev, "failed=%d\n", ret);
 857         return ret;
 858 }
 859
 860 static void hackrf_stop_streaming(struct vb2_queue *vq)
 861 {
 862         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 863         struct usb_interface *intf = dev->intf;
 864
 865         dev_dbg(&intf->dev, "\n");
 866
 867         mutex_lock(&dev->v4l2_lock);
 868
 869         /* stop hardware streaming */
 870         hackrf_ctrl_msg(dev, CMD_SET_TRANSCEIVER_MODE, 0, 0, NULL, 0);
 871
 872         hackrf_kill_urbs(dev);
 873         hackrf_free_urbs(dev);
 874         hackrf_free_stream_bufs(dev);
 875
 876         hackrf_return_all_buffers(vq, VB2_BUF_STATE_ERROR);
 877
 878         if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
 879                 clear_bit(RX_ON, &dev->flags);
 880         else
 881                 clear_bit(TX_ON, &dev->flags);
 882
 883         mutex_unlock(&dev->v4l2_lock);
 884 }
 885
 886 static const struct vb2_ops hackrf_vb2_ops = {
 887         .queue_setup            = hackrf_queue_setup,
 888         .buf_queue              = hackrf_buf_queue,
 889         .start_streaming        = hackrf_start_streaming,
 890         .stop_streaming         = hackrf_stop_streaming,
 891         .wait_prepare           = vb2_ops_wait_prepare,
 892         .wait_finish            = vb2_ops_wait_finish,
 893 };
 894
 895 static int hackrf_querycap(struct file *file, void *fh,
 896                 struct v4l2_capability *cap)
 897 {
 898         struct hackrf_dev *dev = video_drvdata(file);
 899         struct usb_interface *intf = dev->intf;
 900
 901         dev_dbg(&intf->dev, "\n");
 902
 903         cap->capabilities = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER |
 904                             V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR |
 905                             V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
 906                             V4L2_CAP_DEVICE_CAPS;
 907         strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
 908         strscpy(cap->card, dev->rx_vdev.name, sizeof(cap->card));
 909         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 910
 911         return 0;
 912 }
 913
 914 static int hackrf_s_fmt_sdr(struct file *file, void *priv,
 915                             struct v4l2_format *f)
 916 {
 917         struct hackrf_dev *dev = video_drvdata(file);
 918         struct video_device *vdev = video_devdata(file);
 919         struct vb2_queue *q;
 920         int i;
 921
 922         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 923                         (char *)&f->fmt.sdr.pixelformat);
 924
 925         if (vdev->vfl_dir == VFL_DIR_RX)
 926                 q = &dev->rx_vb2_queue;
 927         else
 928                 q = &dev->tx_vb2_queue;
 929
 930         if (vb2_is_busy(q))
 931                 return -EBUSY;
 932
 933         for (i = 0; i < NUM_FORMATS; i++) {
 934                 if (f->fmt.sdr.pixelformat == formats[i].pixelformat) {
 935                         dev->pixelformat = formats[i].pixelformat;
 936                         dev->buffersize = formats[i].buffersize;
 937                         f->fmt.sdr.buffersize = formats[i].buffersize;
 938                         return 0;
 939                 }
 940         }
 941
 942         dev->pixelformat = formats[0].pixelformat;
 943         dev->buffersize = formats[0].buffersize;
 944         f->fmt.sdr.pixelformat = formats[0].pixelformat;
 945         f->fmt.sdr.buffersize = formats[0].buffersize;
 946
 947         return 0;
 948 }
 949
 950 static int hackrf_g_fmt_sdr(struct file *file, void *priv,
 951                             struct v4l2_format *f)
 952 {
 953         struct hackrf_dev *dev = video_drvdata(file);
 954
 955         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 956                         (char *)&dev->pixelformat);
 957
 958         f->fmt.sdr.pixelformat = dev->pixelformat;
 959         f->fmt.sdr.buffersize = dev->buffersize;
 960
 961         return 0;
 962 }
 963
 964 static int hackrf_try_fmt_sdr(struct file *file, void *priv,
 965                               struct v4l2_format *f)
 966 {
 967         struct hackrf_dev *dev = video_drvdata(file);
 968         int i;
 969
 970         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 971                         (char *)&f->fmt.sdr.pixelformat);
 972
 973         for (i = 0; i < NUM_FORMATS; i++) {
 974                 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
 975                         f->fmt.sdr.buffersize = formats[i].buffersize;
 976                         return 0;
 977                 }
 978         }
 979
 980         f->fmt.sdr.pixelformat = formats[0].pixelformat;
 981         f->fmt.sdr.buffersize = formats[0].buffersize;
 982
 983         return 0;
 984 }
 985
 986 static int hackrf_enum_fmt_sdr(struct file *file, void *priv,
 987                                struct v4l2_fmtdesc *f)
 988 {
 989         struct hackrf_dev *dev = video_drvdata(file);
 990
 991         dev_dbg(dev->dev, "index=%d\n", f->index);
 992
 993         if (f->index >= NUM_FORMATS)
 994                 return -EINVAL;
 995
 996         f->pixelformat = formats[f->index].pixelformat;
 997
 998         return 0;
 999 }
1000
1001 static int hackrf_s_tuner(struct file *file, void *priv,
1002                 const struct v4l2_tuner *v)
1003 {
1004         struct hackrf_dev *dev = video_drvdata(file);
1005         int ret;
1006
1007         dev_dbg(dev->dev, "index=%d\n", v->index);
1008
1009         if (v->index == 0)
1010                 ret = 0;
1011         else if (v->index == 1)
1012                 ret = 0;
1013         else
1014                 ret = -EINVAL;
1015
1016         return ret;
1017 }
1018
1019 static int hackrf_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
1020 {
1021         struct hackrf_dev *dev = video_drvdata(file);
1022         int ret;
1023
1024         dev_dbg(dev->dev, "index=%d\n", v->index);
1025
1026         if (v->index == 0) {
1027                 strscpy(v->name, "HackRF ADC", sizeof(v->name));
1028                 v->type = V4L2_TUNER_SDR;
1029                 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1030                 v->rangelow  = bands_adc_dac[0].rangelow;
1031                 v->rangehigh = bands_adc_dac[0].rangehigh;
1032                 ret = 0;
1033         } else if (v->index == 1) {
1034                 strscpy(v->name, "HackRF RF", sizeof(v->name));
1035                 v->type = V4L2_TUNER_RF;
1036                 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1037                 v->rangelow  = bands_rx_tx[0].rangelow;
1038                 v->rangehigh = bands_rx_tx[0].rangehigh;
1039                 ret = 0;
1040         } else {
1041                 ret = -EINVAL;
1042         }
1043
1044         return ret;
1045 }
1046
1047 static int hackrf_s_modulator(struct file *file, void *fh,
1048                               const struct v4l2_modulator *a)
1049 {
1050         struct hackrf_dev *dev = video_drvdata(file);
1051
1052         dev_dbg(dev->dev, "index=%d\n", a->index);
1053
1054         return a->index > 1 ? -EINVAL : 0;
1055 }
1056
1057 static int hackrf_g_modulator(struct file *file, void *fh,
1058                               struct v4l2_modulator *a)
1059 {
1060         struct hackrf_dev *dev = video_drvdata(file);
1061         int ret;
1062
1063         dev_dbg(dev->dev, "index=%d\n", a->index);
1064
1065         if (a->index == 0) {
1066                 strscpy(a->name, "HackRF DAC", sizeof(a->name));
1067                 a->type = V4L2_TUNER_SDR;
1068                 a->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1069                 a->rangelow  = bands_adc_dac[0].rangelow;
1070                 a->rangehigh = bands_adc_dac[0].rangehigh;
1071                 ret = 0;
1072         } else if (a->index == 1) {
1073                 strscpy(a->name, "HackRF RF", sizeof(a->name));
1074                 a->type = V4L2_TUNER_RF;
1075                 a->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1076                 a->rangelow  = bands_rx_tx[0].rangelow;
1077                 a->rangehigh = bands_rx_tx[0].rangehigh;
1078                 ret = 0;
1079         } else {
1080                 ret = -EINVAL;
1081         }
1082
1083         return ret;
1084 }
1085
1086 static int hackrf_s_frequency(struct file *file, void *priv,
1087                 const struct v4l2_frequency *f)
1088 {
1089         struct hackrf_dev *dev = video_drvdata(file);
1090         struct usb_interface *intf = dev->intf;
1091         struct video_device *vdev = video_devdata(file);
1092         int ret;
1093         unsigned int uitmp;
1094
1095         dev_dbg(&intf->dev, "tuner=%d type=%d frequency=%u\n",
1096                         f->tuner, f->type, f->frequency);
1097
1098         if (f->tuner == 0) {
1099                 uitmp = clamp(f->frequency, bands_adc_dac[0].rangelow,
1100                               bands_adc_dac[0].rangehigh);
1101                 if (vdev->vfl_dir == VFL_DIR_RX) {
1102                         dev->f_adc = uitmp;
1103                         set_bit(RX_ADC_FREQUENCY, &dev->flags);
1104                 } else {
1105                         dev->f_dac = uitmp;
1106                         set_bit(TX_DAC_FREQUENCY, &dev->flags);
1107                 }
1108         } else if (f->tuner == 1) {
1109                 uitmp = clamp(f->frequency, bands_rx_tx[0].rangelow,
1110                               bands_rx_tx[0].rangehigh);
1111                 if (vdev->vfl_dir == VFL_DIR_RX) {
1112                         dev->f_rx = uitmp;
1113                         set_bit(RX_RF_FREQUENCY, &dev->flags);
1114                 } else {
1115                         dev->f_tx = uitmp;
1116                         set_bit(TX_RF_FREQUENCY, &dev->flags);
1117                 }
1118         } else {
1119                 ret = -EINVAL;
1120                 goto err;
1121         }
1122
1123         ret = hackrf_set_params(dev);
1124         if (ret)
1125                 goto err;
1126
1127         return 0;
1128 err:
1129         dev_dbg(&intf->dev, "failed=%d\n", ret);
1130         return ret;
1131 }
1132
1133 static int hackrf_g_frequency(struct file *file, void *priv,
1134                 struct v4l2_frequency *f)
1135 {
1136         struct hackrf_dev *dev = video_drvdata(file);
1137         struct usb_interface *intf = dev->intf;
1138         struct video_device *vdev = video_devdata(file);
1139         int ret;
1140
1141         dev_dbg(dev->dev, "tuner=%d type=%d\n", f->tuner, f->type);
1142
1143         if (f->tuner == 0) {
1144                 f->type = V4L2_TUNER_SDR;
1145                 if (vdev->vfl_dir == VFL_DIR_RX)
1146                         f->frequency = dev->f_adc;
1147                 else
1148                         f->frequency = dev->f_dac;
1149         } else if (f->tuner == 1) {
1150                 f->type = V4L2_TUNER_RF;
1151                 if (vdev->vfl_dir == VFL_DIR_RX)
1152                         f->frequency = dev->f_rx;
1153                 else
1154                         f->frequency = dev->f_tx;
1155         } else {
1156                 ret = -EINVAL;
1157                 goto err;
1158         }
1159
1160         return 0;
1161 err:
1162         dev_dbg(&intf->dev, "failed=%d\n", ret);
1163         return ret;
1164 }
1165
1166 static int hackrf_enum_freq_bands(struct file *file, void *priv,
1167                 struct v4l2_frequency_band *band)
1168 {
1169         struct hackrf_dev *dev = video_drvdata(file);
1170         int ret;
1171
1172         dev_dbg(dev->dev, "tuner=%d type=%d index=%d\n",
1173                         band->tuner, band->type, band->index);
1174
1175         if (band->tuner == 0) {
1176                 if (band->index >= ARRAY_SIZE(bands_adc_dac)) {
1177                         ret = -EINVAL;
1178                 } else {
1179                         *band = bands_adc_dac[band->index];
1180                         ret = 0;
1181                 }
1182         } else if (band->tuner == 1) {
1183                 if (band->index >= ARRAY_SIZE(bands_rx_tx)) {
1184                         ret = -EINVAL;
1185                 } else {
1186                         *band = bands_rx_tx[band->index];
1187                         ret = 0;
1188                 }
1189         } else {
1190                 ret = -EINVAL;
1191         }
1192
1193         return ret;
1194 }
1195
1196 static const struct v4l2_ioctl_ops hackrf_ioctl_ops = {
1197         .vidioc_querycap          = hackrf_querycap,
1198
1199         .vidioc_s_fmt_sdr_cap     = hackrf_s_fmt_sdr,
1200         .vidioc_g_fmt_sdr_cap     = hackrf_g_fmt_sdr,
1201         .vidioc_enum_fmt_sdr_cap  = hackrf_enum_fmt_sdr,
1202         .vidioc_try_fmt_sdr_cap   = hackrf_try_fmt_sdr,
1203
1204         .vidioc_s_fmt_sdr_out     = hackrf_s_fmt_sdr,
1205         .vidioc_g_fmt_sdr_out     = hackrf_g_fmt_sdr,
1206         .vidioc_enum_fmt_sdr_out  = hackrf_enum_fmt_sdr,
1207         .vidioc_try_fmt_sdr_out   = hackrf_try_fmt_sdr,
1208
1209         .vidioc_reqbufs           = vb2_ioctl_reqbufs,
1210         .vidioc_create_bufs       = vb2_ioctl_create_bufs,
1211         .vidioc_prepare_buf       = vb2_ioctl_prepare_buf,
1212         .vidioc_querybuf          = vb2_ioctl_querybuf,
1213         .vidioc_qbuf              = vb2_ioctl_qbuf,
1214         .vidioc_dqbuf             = vb2_ioctl_dqbuf,
1215         .vidioc_expbuf            = vb2_ioctl_expbuf,
1216
1217         .vidioc_streamon          = vb2_ioctl_streamon,
1218         .vidioc_streamoff         = vb2_ioctl_streamoff,
1219
1220         .vidioc_s_tuner           = hackrf_s_tuner,
1221         .vidioc_g_tuner           = hackrf_g_tuner,
1222
1223         .vidioc_s_modulator       = hackrf_s_modulator,
1224         .vidioc_g_modulator       = hackrf_g_modulator,
1225
1226         .vidioc_s_frequency       = hackrf_s_frequency,
1227         .vidioc_g_frequency       = hackrf_g_frequency,
1228         .vidioc_enum_freq_bands   = hackrf_enum_freq_bands,
1229
1230         .vidioc_subscribe_event   = v4l2_ctrl_subscribe_event,
1231         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1232         .vidioc_log_status        = v4l2_ctrl_log_status,
1233 };
1234
1235 static const struct v4l2_file_operations hackrf_fops = {
1236         .owner                    = THIS_MODULE,
1237         .open                     = v4l2_fh_open,
1238         .release                  = vb2_fop_release,
1239         .read                     = vb2_fop_read,
1240         .write                    = vb2_fop_write,
1241         .poll                     = vb2_fop_poll,
1242         .mmap                     = vb2_fop_mmap,
1243         .unlocked_ioctl           = video_ioctl2,
1244 };
1245
1246 static const struct video_device hackrf_template = {
1247         .name                     = "HackRF One",
1248         .release                  = video_device_release_empty,
1249         .fops                     = &hackrf_fops,
1250         .ioctl_ops                = &hackrf_ioctl_ops,
1251 };
1252
1253 static void hackrf_video_release(struct v4l2_device *v)
1254 {
1255         struct hackrf_dev *dev = container_of(v, struct hackrf_dev, v4l2_dev);
1256
1257         dev_dbg(dev->dev, "\n");
1258
1259         v4l2_ctrl_handler_free(&dev->rx_ctrl_handler);
1260         v4l2_ctrl_handler_free(&dev->tx_ctrl_handler);
1261         v4l2_device_unregister(&dev->v4l2_dev);
1262         kfree(dev);
1263 }
1264
1265 static int hackrf_s_ctrl_rx(struct v4l2_ctrl *ctrl)
1266 {
1267         struct hackrf_dev *dev = container_of(ctrl->handler,
1268                         struct hackrf_dev, rx_ctrl_handler);
1269         struct usb_interface *intf = dev->intf;
1270         int ret;
1271
1272         switch (ctrl->id) {
1273         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1274         case V4L2_CID_RF_TUNER_BANDWIDTH:
1275                 set_bit(RX_BANDWIDTH, &dev->flags);
1276                 break;
1277         case  V4L2_CID_RF_TUNER_RF_GAIN:
1278                 set_bit(RX_RF_GAIN, &dev->flags);
1279                 break;
1280         case  V4L2_CID_RF_TUNER_LNA_GAIN:
1281                 set_bit(RX_LNA_GAIN, &dev->flags);
1282                 break;
1283         case  V4L2_CID_RF_TUNER_IF_GAIN:
1284                 set_bit(RX_IF_GAIN, &dev->flags);
1285                 break;
1286         default:
1287                 dev_dbg(&intf->dev, "unknown ctrl: id=%d name=%s\n",
1288                         ctrl->id, ctrl->name);
1289                 ret = -EINVAL;
1290                 goto err;
1291         }
1292
1293         ret = hackrf_set_params(dev);
1294         if (ret)
1295                 goto err;
1296
1297         return 0;
1298 err:
1299         dev_dbg(&intf->dev, "failed=%d\n", ret);
1300         return ret;
1301 }
1302
1303 static int hackrf_s_ctrl_tx(struct v4l2_ctrl *ctrl)
1304 {
1305         struct hackrf_dev *dev = container_of(ctrl->handler,
1306                         struct hackrf_dev, tx_ctrl_handler);
1307         struct usb_interface *intf = dev->intf;
1308         int ret;
1309
1310         switch (ctrl->id) {
1311         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1312         case V4L2_CID_RF_TUNER_BANDWIDTH:
1313                 set_bit(TX_BANDWIDTH, &dev->flags);
1314                 break;
1315         case  V4L2_CID_RF_TUNER_LNA_GAIN:
1316                 set_bit(TX_LNA_GAIN, &dev->flags);
1317                 break;
1318         case  V4L2_CID_RF_TUNER_RF_GAIN:
1319                 set_bit(TX_RF_GAIN, &dev->flags);
1320                 break;
1321         default:
1322                 dev_dbg(&intf->dev, "unknown ctrl: id=%d name=%s\n",
1323                         ctrl->id, ctrl->name);
1324                 ret = -EINVAL;
1325                 goto err;
1326         }
1327
1328         ret = hackrf_set_params(dev);
1329         if (ret)
1330                 goto err;
1331
1332         return 0;
1333 err:
1334         dev_dbg(&intf->dev, "failed=%d\n", ret);
1335         return ret;
1336 }
1337
1338 static const struct v4l2_ctrl_ops hackrf_ctrl_ops_rx = {
1339         .s_ctrl = hackrf_s_ctrl_rx,
1340 };
1341
1342 static const struct v4l2_ctrl_ops hackrf_ctrl_ops_tx = {
1343         .s_ctrl = hackrf_s_ctrl_tx,
1344 };
1345
1346 static int hackrf_probe(struct usb_interface *intf,
1347                 const struct usb_device_id *id)
1348 {
1349         struct hackrf_dev *dev;
1350         int ret;
1351         u8 u8tmp, buf[BUF_SIZE];
1352
1353         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1354         if (!dev) {
1355                 ret = -ENOMEM;
1356                 goto err;
1357         }
1358
1359         mutex_init(&dev->v4l2_lock);
1360         mutex_init(&dev->vb_queue_lock);
1361         spin_lock_init(&dev->buffer_list_lock);
1362         INIT_LIST_HEAD(&dev->rx_buffer_list);
1363         INIT_LIST_HEAD(&dev->tx_buffer_list);
1364         dev->intf = intf;
1365         dev->dev = &intf->dev;
1366         dev->udev = interface_to_usbdev(intf);
1367         dev->pixelformat = formats[0].pixelformat;
1368         dev->buffersize = formats[0].buffersize;
1369         dev->f_adc = bands_adc_dac[0].rangelow;
1370         dev->f_dac = bands_adc_dac[0].rangelow;
1371         dev->f_rx = bands_rx_tx[0].rangelow;
1372         dev->f_tx = bands_rx_tx[0].rangelow;
1373         set_bit(RX_ADC_FREQUENCY, &dev->flags);
1374         set_bit(TX_DAC_FREQUENCY, &dev->flags);
1375         set_bit(RX_RF_FREQUENCY, &dev->flags);
1376         set_bit(TX_RF_FREQUENCY, &dev->flags);
1377
1378         /* Detect device */
1379         ret = hackrf_ctrl_msg(dev, CMD_BOARD_ID_READ, 0, 0, &u8tmp, 1);
1380         if (ret == 0)
1381                 ret = hackrf_ctrl_msg(dev, CMD_VERSION_STRING_READ, 0, 0,
1382                                 buf, BUF_SIZE);
1383         if (ret) {
1384                 dev_err(dev->dev, "Could not detect board\n");
1385                 goto err_kfree;
1386         }
1387
1388         buf[BUF_SIZE - 1] = '\0';
1389         dev_info(dev->dev, "Board ID: %02x\n", u8tmp);
1390         dev_info(dev->dev, "Firmware version: %s\n", buf);
1391
1392         /* Init vb2 queue structure for receiver */
1393         dev->rx_vb2_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1394         dev->rx_vb2_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF |
1395                                      VB2_READ;
1396         dev->rx_vb2_queue.ops = &hackrf_vb2_ops;
1397         dev->rx_vb2_queue.mem_ops = &vb2_vmalloc_memops;
1398         dev->rx_vb2_queue.drv_priv = dev;
1399         dev->rx_vb2_queue.buf_struct_size = sizeof(struct hackrf_buffer);
1400         dev->rx_vb2_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1401         ret = vb2_queue_init(&dev->rx_vb2_queue);
1402         if (ret) {
1403                 dev_err(dev->dev, "Could not initialize rx vb2 queue\n");
1404                 goto err_kfree;
1405         }
1406
1407         /* Init vb2 queue structure for transmitter */
1408         dev->tx_vb2_queue.type = V4L2_BUF_TYPE_SDR_OUTPUT;
1409         dev->tx_vb2_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF |
1410                                      VB2_WRITE;
1411         dev->tx_vb2_queue.ops = &hackrf_vb2_ops;
1412         dev->tx_vb2_queue.mem_ops = &vb2_vmalloc_memops;
1413         dev->tx_vb2_queue.drv_priv = dev;
1414         dev->tx_vb2_queue.buf_struct_size = sizeof(struct hackrf_buffer);
1415         dev->tx_vb2_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1416         ret = vb2_queue_init(&dev->tx_vb2_queue);
1417         if (ret) {
1418                 dev_err(dev->dev, "Could not initialize tx vb2 queue\n");
1419                 goto err_kfree;
1420         }
1421
1422         /* Register controls for receiver */
1423         v4l2_ctrl_handler_init(&dev->rx_ctrl_handler, 5);
1424         dev->rx_bandwidth_auto = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1425                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1426                 0, 1, 0, 1);
1427         dev->rx_bandwidth = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1428                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_BANDWIDTH,
1429                 1750000, 28000000, 50000, 1750000);
1430         v4l2_ctrl_auto_cluster(2, &dev->rx_bandwidth_auto, 0, false);
1431         dev->rx_rf_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1432                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_RF_GAIN, 0, 12, 12, 0);
1433         dev->rx_lna_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1434                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_LNA_GAIN, 0, 40, 8, 0);
1435         dev->rx_if_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1436                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_IF_GAIN, 0, 62, 2, 0);
1437         if (dev->rx_ctrl_handler.error) {
1438                 ret = dev->rx_ctrl_handler.error;
1439                 dev_err(dev->dev, "Could not initialize controls\n");
1440                 goto err_v4l2_ctrl_handler_free_rx;
1441         }
1442         v4l2_ctrl_grab(dev->rx_rf_gain, !hackrf_enable_rf_gain_ctrl);
1443         v4l2_ctrl_handler_setup(&dev->rx_ctrl_handler);
1444
1445         /* Register controls for transmitter */
1446         v4l2_ctrl_handler_init(&dev->tx_ctrl_handler, 4);
1447         dev->tx_bandwidth_auto = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1448                 &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1449                 0, 1, 0, 1);
1450         dev->tx_bandwidth = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1451                 &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_BANDWIDTH,
1452                 1750000, 28000000, 50000, 1750000);
1453         v4l2_ctrl_auto_cluster(2, &dev->tx_bandwidth_auto, 0, false);
1454         dev->tx_lna_gain = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1455                 &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_LNA_GAIN, 0, 47, 1, 0);
1456         dev->tx_rf_gain = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1457                 &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_RF_GAIN, 0, 15, 15, 0);
1458         if (dev->tx_ctrl_handler.error) {
1459                 ret = dev->tx_ctrl_handler.error;
1460                 dev_err(dev->dev, "Could not initialize controls\n");
1461                 goto err_v4l2_ctrl_handler_free_tx;
1462         }
1463         v4l2_ctrl_grab(dev->tx_rf_gain, !hackrf_enable_rf_gain_ctrl);
1464         v4l2_ctrl_handler_setup(&dev->tx_ctrl_handler);
1465
1466         /* Register the v4l2_device structure */
1467         dev->v4l2_dev.release = hackrf_video_release;
1468         ret = v4l2_device_register(&intf->dev, &dev->v4l2_dev);
1469         if (ret) {
1470                 dev_err(dev->dev, "Failed to register v4l2-device (%d)\n", ret);
1471                 goto err_v4l2_ctrl_handler_free_tx;
1472         }
1473
1474         /* Init video_device structure for receiver */
1475         dev->rx_vdev = hackrf_template;
1476         dev->rx_vdev.queue = &dev->rx_vb2_queue;
1477         dev->rx_vdev.queue->lock = &dev->vb_queue_lock;
1478         dev->rx_vdev.v4l2_dev = &dev->v4l2_dev;
1479         dev->rx_vdev.ctrl_handler = &dev->rx_ctrl_handler;
1480         dev->rx_vdev.lock = &dev->v4l2_lock;
1481         dev->rx_vdev.vfl_dir = VFL_DIR_RX;
1482         dev->rx_vdev.device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
1483                                    V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
1484         video_set_drvdata(&dev->rx_vdev, dev);
1485         ret = video_register_device(&dev->rx_vdev, VFL_TYPE_SDR, -1);
1486         if (ret) {
1487                 dev_err(dev->dev,
1488                         "Failed to register as video device (%d)\n", ret);
1489                 goto err_v4l2_device_unregister;
1490         }
1491         dev_info(dev->dev, "Registered as %s\n",
1492                  video_device_node_name(&dev->rx_vdev));
1493
1494         /* Init video_device structure for transmitter */
1495         dev->tx_vdev = hackrf_template;
1496         dev->tx_vdev.queue = &dev->tx_vb2_queue;
1497         dev->tx_vdev.queue->lock = &dev->vb_queue_lock;
1498         dev->tx_vdev.v4l2_dev = &dev->v4l2_dev;
1499         dev->tx_vdev.ctrl_handler = &dev->tx_ctrl_handler;
1500         dev->tx_vdev.lock = &dev->v4l2_lock;
1501         dev->tx_vdev.vfl_dir = VFL_DIR_TX;
1502         dev->tx_vdev.device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
1503                                    V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR;
1504         video_set_drvdata(&dev->tx_vdev, dev);
1505         ret = video_register_device(&dev->tx_vdev, VFL_TYPE_SDR, -1);
1506         if (ret) {
1507                 dev_err(dev->dev,
1508                         "Failed to register as video device (%d)\n", ret);
1509                 goto err_video_unregister_device_rx;
1510         }
1511         dev_info(dev->dev, "Registered as %s\n",
1512                  video_device_node_name(&dev->tx_vdev));
1513
1514         dev_notice(dev->dev, "SDR API is still slightly experimental and functionality changes may follow\n");
1515         return 0;
1516 err_video_unregister_device_rx:
1517         video_unregister_device(&dev->rx_vdev);
1518 err_v4l2_device_unregister:
1519         v4l2_device_unregister(&dev->v4l2_dev);
1520 err_v4l2_ctrl_handler_free_tx:
1521         v4l2_ctrl_handler_free(&dev->tx_ctrl_handler);
1522 err_v4l2_ctrl_handler_free_rx:
1523         v4l2_ctrl_handler_free(&dev->rx_ctrl_handler);
1524 err_kfree:
1525         kfree(dev);
1526 err:
1527         dev_dbg(&intf->dev, "failed=%d\n", ret);
1528         return ret;
1529 }
1530
1531 /* USB device ID list */
1532 static const struct usb_device_id hackrf_id_table[] = {
1533         { USB_DEVICE(0x1d50, 0x6089) }, /* HackRF One */
1534         { }
1535 };
1536 MODULE_DEVICE_TABLE(usb, hackrf_id_table);
1537
1538 /* USB subsystem interface */
1539 static struct usb_driver hackrf_driver = {
1540         .name                     = KBUILD_MODNAME,
1541         .probe                    = hackrf_probe,
1542         .disconnect               = hackrf_disconnect,
1543         .id_table                 = hackrf_id_table,
1544 };
1545
1546 module_usb_driver(hackrf_driver);
1547
1548 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1549 MODULE_DESCRIPTION("HackRF");
1550 MODULE_LICENSE("GPL");