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
 757         dev_dbg(dev->dev, "nbuffers=%d\n", *nbuffers);
 758
 759         /* Need at least 8 buffers */
 760         if (vq->num_buffers + *nbuffers < 8)
 761                 *nbuffers = 8 - vq->num_buffers;
 762         *nplanes = 1;
 763         sizes[0] = PAGE_ALIGN(dev->buffersize);
 764
 765         dev_dbg(dev->dev, "nbuffers=%d sizes[0]=%d\n", *nbuffers, sizes[0]);
 766         return 0;
 767 }
 768
 769 static void hackrf_buf_queue(struct vb2_buffer *vb)
 770 {
 771         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 772         struct vb2_queue *vq = vb->vb2_queue;
 773         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 774         struct hackrf_buffer *buffer = container_of(vbuf, struct hackrf_buffer, vb);
 775         struct list_head *buffer_list;
 776         unsigned long flags;
 777
 778         dev_dbg_ratelimited(&dev->intf->dev, "\n");
 779
 780         if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
 781                 buffer_list = &dev->rx_buffer_list;
 782         else
 783                 buffer_list = &dev->tx_buffer_list;
 784
 785         spin_lock_irqsave(&dev->buffer_list_lock, flags);
 786         list_add_tail(&buffer->list, buffer_list);
 787         spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
 788 }
 789
 790 static int hackrf_start_streaming(struct vb2_queue *vq, unsigned int count)
 791 {
 792         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 793         struct usb_interface *intf = dev->intf;
 794         int ret;
 795         unsigned int mode;
 796
 797         dev_dbg(&intf->dev, "count=%i\n", count);
 798
 799         mutex_lock(&dev->v4l2_lock);
 800
 801         /* Allow only RX or TX, not both same time */
 802         if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE) {
 803                 if (test_bit(TX_ON, &dev->flags)) {
 804                         ret = -EBUSY;
 805                         goto err_hackrf_return_all_buffers;
 806                 }
 807
 808                 mode = 1;
 809                 set_bit(RX_ON, &dev->flags);
 810         } else {
 811                 if (test_bit(RX_ON, &dev->flags)) {
 812                         ret = -EBUSY;
 813                         goto err_hackrf_return_all_buffers;
 814                 }
 815
 816                 mode = 2;
 817                 set_bit(TX_ON, &dev->flags);
 818         }
 819
 820         dev->sequence = 0;
 821
 822         ret = hackrf_alloc_stream_bufs(dev);
 823         if (ret)
 824                 goto err;
 825
 826         ret = hackrf_alloc_urbs(dev, (mode == 1));
 827         if (ret)
 828                 goto err;
 829
 830         ret = hackrf_submit_urbs(dev);
 831         if (ret)
 832                 goto err;
 833
 834         ret = hackrf_set_params(dev);
 835         if (ret)
 836                 goto err;
 837
 838         /* start hardware streaming */
 839         ret = hackrf_ctrl_msg(dev, CMD_SET_TRANSCEIVER_MODE, mode, 0, NULL, 0);
 840         if (ret)
 841                 goto err;
 842
 843         mutex_unlock(&dev->v4l2_lock);
 844
 845         return 0;
 846 err:
 847         hackrf_kill_urbs(dev);
 848         hackrf_free_urbs(dev);
 849         hackrf_free_stream_bufs(dev);
 850         clear_bit(RX_ON, &dev->flags);
 851         clear_bit(TX_ON, &dev->flags);
 852 err_hackrf_return_all_buffers:
 853         hackrf_return_all_buffers(vq, VB2_BUF_STATE_QUEUED);
 854         mutex_unlock(&dev->v4l2_lock);
 855         dev_dbg(&intf->dev, "failed=%d\n", ret);
 856         return ret;
 857 }
 858
 859 static void hackrf_stop_streaming(struct vb2_queue *vq)
 860 {
 861         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 862         struct usb_interface *intf = dev->intf;
 863
 864         dev_dbg(&intf->dev, "\n");
 865
 866         mutex_lock(&dev->v4l2_lock);
 867
 868         /* stop hardware streaming */
 869         hackrf_ctrl_msg(dev, CMD_SET_TRANSCEIVER_MODE, 0, 0, NULL, 0);
 870
 871         hackrf_kill_urbs(dev);
 872         hackrf_free_urbs(dev);
 873         hackrf_free_stream_bufs(dev);
 874
 875         hackrf_return_all_buffers(vq, VB2_BUF_STATE_ERROR);
 876
 877         if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
 878                 clear_bit(RX_ON, &dev->flags);
 879         else
 880                 clear_bit(TX_ON, &dev->flags);
 881
 882         mutex_unlock(&dev->v4l2_lock);
 883 }
 884
 885 static const struct vb2_ops hackrf_vb2_ops = {
 886         .queue_setup            = hackrf_queue_setup,
 887         .buf_queue              = hackrf_buf_queue,
 888         .start_streaming        = hackrf_start_streaming,
 889         .stop_streaming         = hackrf_stop_streaming,
 890         .wait_prepare           = vb2_ops_wait_prepare,
 891         .wait_finish            = vb2_ops_wait_finish,
 892 };
 893
 894 static int hackrf_querycap(struct file *file, void *fh,
 895                 struct v4l2_capability *cap)
 896 {
 897         struct hackrf_dev *dev = video_drvdata(file);
 898         struct usb_interface *intf = dev->intf;
 899
 900         dev_dbg(&intf->dev, "\n");
 901
 902         cap->capabilities = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER |
 903                             V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR |
 904                             V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
 905                             V4L2_CAP_DEVICE_CAPS;
 906         strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
 907         strscpy(cap->card, dev->rx_vdev.name, sizeof(cap->card));
 908         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 909
 910         return 0;
 911 }
 912
 913 static int hackrf_s_fmt_sdr(struct file *file, void *priv,
 914                             struct v4l2_format *f)
 915 {
 916         struct hackrf_dev *dev = video_drvdata(file);
 917         struct video_device *vdev = video_devdata(file);
 918         struct vb2_queue *q;
 919         int i;
 920
 921         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 922                         (char *)&f->fmt.sdr.pixelformat);
 923
 924         if (vdev->vfl_dir == VFL_DIR_RX)
 925                 q = &dev->rx_vb2_queue;
 926         else
 927                 q = &dev->tx_vb2_queue;
 928
 929         if (vb2_is_busy(q))
 930                 return -EBUSY;
 931
 932         for (i = 0; i < NUM_FORMATS; i++) {
 933                 if (f->fmt.sdr.pixelformat == formats[i].pixelformat) {
 934                         dev->pixelformat = formats[i].pixelformat;
 935                         dev->buffersize = formats[i].buffersize;
 936                         f->fmt.sdr.buffersize = formats[i].buffersize;
 937                         return 0;
 938                 }
 939         }
 940
 941         dev->pixelformat = formats[0].pixelformat;
 942         dev->buffersize = formats[0].buffersize;
 943         f->fmt.sdr.pixelformat = formats[0].pixelformat;
 944         f->fmt.sdr.buffersize = formats[0].buffersize;
 945
 946         return 0;
 947 }
 948
 949 static int hackrf_g_fmt_sdr(struct file *file, void *priv,
 950                             struct v4l2_format *f)
 951 {
 952         struct hackrf_dev *dev = video_drvdata(file);
 953
 954         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 955                         (char *)&dev->pixelformat);
 956
 957         f->fmt.sdr.pixelformat = dev->pixelformat;
 958         f->fmt.sdr.buffersize = dev->buffersize;
 959
 960         return 0;
 961 }
 962
 963 static int hackrf_try_fmt_sdr(struct file *file, void *priv,
 964                               struct v4l2_format *f)
 965 {
 966         struct hackrf_dev *dev = video_drvdata(file);
 967         int i;
 968
 969         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 970                         (char *)&f->fmt.sdr.pixelformat);
 971
 972         for (i = 0; i < NUM_FORMATS; i++) {
 973                 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
 974                         f->fmt.sdr.buffersize = formats[i].buffersize;
 975                         return 0;
 976                 }
 977         }
 978
 979         f->fmt.sdr.pixelformat = formats[0].pixelformat;
 980         f->fmt.sdr.buffersize = formats[0].buffersize;
 981
 982         return 0;
 983 }
 984
 985 static int hackrf_enum_fmt_sdr(struct file *file, void *priv,
 986                                struct v4l2_fmtdesc *f)
 987 {
 988         struct hackrf_dev *dev = video_drvdata(file);
 989
 990         dev_dbg(dev->dev, "index=%d\n", f->index);
 991
 992         if (f->index >= NUM_FORMATS)
 993                 return -EINVAL;
 994
 995         f->pixelformat = formats[f->index].pixelformat;
 996
 997         return 0;
 998 }
 999
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");