drivers/media/usb/hackrf/hackrf.c

   1 /*
   2  * HackRF driver
   3  *
   4  * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
   5  *
   6  *    This program is free software; you can redistribute it and/or modify
   7  *    it under the terms of the GNU General Public License as published by
   8  *    the Free Software Foundation; either version 2 of the License, or
   9  *    (at your option) any later version.
  10  *
  11  *    This program is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU General Public License for more details.
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/slab.h>
  19 #include <linux/usb.h>
  20 #include <media/v4l2-device.h>
  21 #include <media/v4l2-ioctl.h>
  22 #include <media/v4l2-ctrls.h>
  23 #include <media/v4l2-event.h>
  24 #include <media/videobuf2-v4l2.h>
  25 #include <media/videobuf2-vmalloc.h>
  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 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         v4l2_get_timestamp(&buffer->vb.timestamp);
 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         v4l2_get_timestamp(&buffer->vb.timestamp);
 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_ATOMIC);
 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_ATOMIC,
 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_ATOMIC);
 684                 if (!dev->urb_list[i]) {
 685                         dev_dbg(dev->dev, "failed\n");
 686                         for (j = 0; j < i; j++)
 687                                 usb_free_urb(dev->urb_list[j]);
 688                         return -ENOMEM;
 689                 }
 690                 usb_fill_bulk_urb(dev->urb_list[i],
 691                                 dev->udev,
 692                                 pipe,
 693                                 dev->buf_list[i],
 694                                 BULK_BUFFER_SIZE,
 695                                 complete, dev);
 696
 697                 dev->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 698                 dev->urb_list[i]->transfer_dma = dev->dma_addr[i];
 699                 dev->urbs_initialized++;
 700         }
 701
 702         return 0;
 703 }
 704
 705 /* The user yanked out the cable... */
 706 static void hackrf_disconnect(struct usb_interface *intf)
 707 {
 708         struct v4l2_device *v = usb_get_intfdata(intf);
 709         struct hackrf_dev *dev = container_of(v, struct hackrf_dev, v4l2_dev);
 710
 711         dev_dbg(dev->dev, "\n");
 712
 713         mutex_lock(&dev->vb_queue_lock);
 714         mutex_lock(&dev->v4l2_lock);
 715         /* No need to keep the urbs around after disconnection */
 716         dev->udev = NULL;
 717         v4l2_device_disconnect(&dev->v4l2_dev);
 718         video_unregister_device(&dev->tx_vdev);
 719         video_unregister_device(&dev->rx_vdev);
 720         mutex_unlock(&dev->v4l2_lock);
 721         mutex_unlock(&dev->vb_queue_lock);
 722
 723         v4l2_device_put(&dev->v4l2_dev);
 724 }
 725
 726 /* Videobuf2 operations */
 727 static void hackrf_return_all_buffers(struct vb2_queue *vq,
 728                                       enum vb2_buffer_state state)
 729 {
 730         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 731         struct usb_interface *intf = dev->intf;
 732         struct hackrf_buffer *buffer, *node;
 733         struct list_head *buffer_list;
 734         unsigned long flags;
 735
 736         dev_dbg(&intf->dev, "\n");
 737
 738         if (vq->type == V4L2_BUF_TYPE_SDR_CAPTURE)
 739                 buffer_list = &dev->rx_buffer_list;
 740         else
 741                 buffer_list = &dev->tx_buffer_list;
 742
 743         spin_lock_irqsave(&dev->buffer_list_lock, flags);
 744         list_for_each_entry_safe(buffer, node, buffer_list, list) {
 745                 dev_dbg(&intf->dev, "list_for_each_entry_safe\n");
 746                 vb2_buffer_done(&buffer->vb.vb2_buf, state);
 747                 list_del(&buffer->list);
 748         }
 749         spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
 750 }
 751
 752 static int hackrf_queue_setup(struct vb2_queue *vq,
 753                 const void *parg, unsigned int *nbuffers,
 754                 unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
 755 {
 756         struct hackrf_dev *dev = vb2_get_drv_priv(vq);
 757
 758         dev_dbg(dev->dev, "nbuffers=%d\n", *nbuffers);
 759
 760         /* Need at least 8 buffers */
 761         if (vq->num_buffers + *nbuffers < 8)
 762                 *nbuffers = 8 - vq->num_buffers;
 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 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         struct video_device *vdev = video_devdata(file);
 901
 902         dev_dbg(&intf->dev, "\n");
 903
 904         if (vdev->vfl_dir == VFL_DIR_RX)
 905                 cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER |
 906                                    V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 907
 908         else
 909                 cap->device_caps = V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR |
 910                                    V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 911
 912         cap->capabilities = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER |
 913                             V4L2_CAP_SDR_OUTPUT | V4L2_CAP_MODULATOR |
 914                             V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
 915                             V4L2_CAP_DEVICE_CAPS;
 916         strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
 917         strlcpy(cap->card, dev->rx_vdev.name, sizeof(cap->card));
 918         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 919
 920         return 0;
 921 }
 922
 923 static int hackrf_s_fmt_sdr(struct file *file, void *priv,
 924                             struct v4l2_format *f)
 925 {
 926         struct hackrf_dev *dev = video_drvdata(file);
 927         struct video_device *vdev = video_devdata(file);
 928         struct vb2_queue *q;
 929         int i;
 930
 931         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 932                         (char *)&f->fmt.sdr.pixelformat);
 933
 934         if (vdev->vfl_dir == VFL_DIR_RX)
 935                 q = &dev->rx_vb2_queue;
 936         else
 937                 q = &dev->tx_vb2_queue;
 938
 939         if (vb2_is_busy(q))
 940                 return -EBUSY;
 941
 942         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
 943         for (i = 0; i < NUM_FORMATS; i++) {
 944                 if (f->fmt.sdr.pixelformat == formats[i].pixelformat) {
 945                         dev->pixelformat = formats[i].pixelformat;
 946                         dev->buffersize = formats[i].buffersize;
 947                         f->fmt.sdr.buffersize = formats[i].buffersize;
 948                         return 0;
 949                 }
 950         }
 951
 952         dev->pixelformat = formats[0].pixelformat;
 953         dev->buffersize = formats[0].buffersize;
 954         f->fmt.sdr.pixelformat = formats[0].pixelformat;
 955         f->fmt.sdr.buffersize = formats[0].buffersize;
 956
 957         return 0;
 958 }
 959
 960 static int hackrf_g_fmt_sdr(struct file *file, void *priv,
 961                             struct v4l2_format *f)
 962 {
 963         struct hackrf_dev *dev = video_drvdata(file);
 964
 965         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 966                         (char *)&dev->pixelformat);
 967
 968         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
 969         f->fmt.sdr.pixelformat = dev->pixelformat;
 970         f->fmt.sdr.buffersize = dev->buffersize;
 971
 972         return 0;
 973 }
 974
 975 static int hackrf_try_fmt_sdr(struct file *file, void *priv,
 976                               struct v4l2_format *f)
 977 {
 978         struct hackrf_dev *dev = video_drvdata(file);
 979         int i;
 980
 981         dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
 982                         (char *)&f->fmt.sdr.pixelformat);
 983
 984         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
 985         for (i = 0; i < NUM_FORMATS; i++) {
 986                 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
 987                         f->fmt.sdr.buffersize = formats[i].buffersize;
 988                         return 0;
 989                 }
 990         }
 991
 992         f->fmt.sdr.pixelformat = formats[0].pixelformat;
 993         f->fmt.sdr.buffersize = formats[0].buffersize;
 994
 995         return 0;
 996 }
 997
 998 static int hackrf_enum_fmt_sdr(struct file *file, void *priv,
 999                                struct v4l2_fmtdesc *f)
1000 {
1001         struct hackrf_dev *dev = video_drvdata(file);
1002
1003         dev_dbg(dev->dev, "index=%d\n", f->index);
1004
1005         if (f->index >= NUM_FORMATS)
1006                 return -EINVAL;
1007
1008         f->pixelformat = formats[f->index].pixelformat;
1009
1010         return 0;
1011 }
1012
1013 static int hackrf_s_tuner(struct file *file, void *priv,
1014                 const struct v4l2_tuner *v)
1015 {
1016         struct hackrf_dev *dev = video_drvdata(file);
1017         int ret;
1018
1019         dev_dbg(dev->dev, "index=%d\n", v->index);
1020
1021         if (v->index == 0)
1022                 ret = 0;
1023         else if (v->index == 1)
1024                 ret = 0;
1025         else
1026                 ret = -EINVAL;
1027
1028         return ret;
1029 }
1030
1031 static int hackrf_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
1032 {
1033         struct hackrf_dev *dev = video_drvdata(file);
1034         int ret;
1035
1036         dev_dbg(dev->dev, "index=%d\n", v->index);
1037
1038         if (v->index == 0) {
1039                 strlcpy(v->name, "HackRF ADC", sizeof(v->name));
1040                 v->type = V4L2_TUNER_SDR;
1041                 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1042                 v->rangelow  = bands_adc_dac[0].rangelow;
1043                 v->rangehigh = bands_adc_dac[0].rangehigh;
1044                 ret = 0;
1045         } else if (v->index == 1) {
1046                 strlcpy(v->name, "HackRF RF", sizeof(v->name));
1047                 v->type = V4L2_TUNER_RF;
1048                 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1049                 v->rangelow  = bands_rx_tx[0].rangelow;
1050                 v->rangehigh = bands_rx_tx[0].rangehigh;
1051                 ret = 0;
1052         } else {
1053                 ret = -EINVAL;
1054         }
1055
1056         return ret;
1057 }
1058
1059 static int hackrf_s_modulator(struct file *file, void *fh,
1060                               const struct v4l2_modulator *a)
1061 {
1062         struct hackrf_dev *dev = video_drvdata(file);
1063
1064         dev_dbg(dev->dev, "index=%d\n", a->index);
1065
1066         return a->index > 1 ? -EINVAL : 0;
1067 }
1068
1069 static int hackrf_g_modulator(struct file *file, void *fh,
1070                               struct v4l2_modulator *a)
1071 {
1072         struct hackrf_dev *dev = video_drvdata(file);
1073         int ret;
1074
1075         dev_dbg(dev->dev, "index=%d\n", a->index);
1076
1077         if (a->index == 0) {
1078                 strlcpy(a->name, "HackRF DAC", sizeof(a->name));
1079                 a->type = V4L2_TUNER_SDR;
1080                 a->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1081                 a->rangelow  = bands_adc_dac[0].rangelow;
1082                 a->rangehigh = bands_adc_dac[0].rangehigh;
1083                 ret = 0;
1084         } else if (a->index == 1) {
1085                 strlcpy(a->name, "HackRF RF", sizeof(a->name));
1086                 a->type = V4L2_TUNER_RF;
1087                 a->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1088                 a->rangelow  = bands_rx_tx[0].rangelow;
1089                 a->rangehigh = bands_rx_tx[0].rangehigh;
1090                 ret = 0;
1091         } else {
1092                 ret = -EINVAL;
1093         }
1094
1095         return ret;
1096 }
1097
1098 static int hackrf_s_frequency(struct file *file, void *priv,
1099                 const struct v4l2_frequency *f)
1100 {
1101         struct hackrf_dev *dev = video_drvdata(file);
1102         struct usb_interface *intf = dev->intf;
1103         struct video_device *vdev = video_devdata(file);
1104         int ret;
1105         unsigned int uitmp;
1106
1107         dev_dbg(&intf->dev, "tuner=%d type=%d frequency=%u\n",
1108                         f->tuner, f->type, f->frequency);
1109
1110         if (f->tuner == 0) {
1111                 uitmp = clamp(f->frequency, bands_adc_dac[0].rangelow,
1112                               bands_adc_dac[0].rangehigh);
1113                 if (vdev->vfl_dir == VFL_DIR_RX) {
1114                         dev->f_adc = uitmp;
1115                         set_bit(RX_ADC_FREQUENCY, &dev->flags);
1116                 } else {
1117                         dev->f_dac = uitmp;
1118                         set_bit(TX_DAC_FREQUENCY, &dev->flags);
1119                 }
1120         } else if (f->tuner == 1) {
1121                 uitmp = clamp(f->frequency, bands_rx_tx[0].rangelow,
1122                               bands_rx_tx[0].rangehigh);
1123                 if (vdev->vfl_dir == VFL_DIR_RX) {
1124                         dev->f_rx = uitmp;
1125                         set_bit(RX_RF_FREQUENCY, &dev->flags);
1126                 } else {
1127                         dev->f_tx = uitmp;
1128                         set_bit(TX_RF_FREQUENCY, &dev->flags);
1129                 }
1130         } else {
1131                 ret = -EINVAL;
1132                 goto err;
1133         }
1134
1135         ret = hackrf_set_params(dev);
1136         if (ret)
1137                 goto err;
1138
1139         return 0;
1140 err:
1141         dev_dbg(&intf->dev, "failed=%d\n", ret);
1142         return ret;
1143 }
1144
1145 static int hackrf_g_frequency(struct file *file, void *priv,
1146                 struct v4l2_frequency *f)
1147 {
1148         struct hackrf_dev *dev = video_drvdata(file);
1149         struct usb_interface *intf = dev->intf;
1150         struct video_device *vdev = video_devdata(file);
1151         int ret;
1152
1153         dev_dbg(dev->dev, "tuner=%d type=%d\n", f->tuner, f->type);
1154
1155         if (f->tuner == 0) {
1156                 f->type = V4L2_TUNER_SDR;
1157                 if (vdev->vfl_dir == VFL_DIR_RX)
1158                         f->frequency = dev->f_adc;
1159                 else
1160                         f->frequency = dev->f_dac;
1161         } else if (f->tuner == 1) {
1162                 f->type = V4L2_TUNER_RF;
1163                 if (vdev->vfl_dir == VFL_DIR_RX)
1164                         f->frequency = dev->f_rx;
1165                 else
1166                         f->frequency = dev->f_tx;
1167         } else {
1168                 ret = -EINVAL;
1169                 goto err;
1170         }
1171
1172         return 0;
1173 err:
1174         dev_dbg(&intf->dev, "failed=%d\n", ret);
1175         return ret;
1176 }
1177
1178 static int hackrf_enum_freq_bands(struct file *file, void *priv,
1179                 struct v4l2_frequency_band *band)
1180 {
1181         struct hackrf_dev *dev = video_drvdata(file);
1182         int ret;
1183
1184         dev_dbg(dev->dev, "tuner=%d type=%d index=%d\n",
1185                         band->tuner, band->type, band->index);
1186
1187         if (band->tuner == 0) {
1188                 if (band->index >= ARRAY_SIZE(bands_adc_dac)) {
1189                         ret = -EINVAL;
1190                 } else {
1191                         *band = bands_adc_dac[band->index];
1192                         ret = 0;
1193                 }
1194         } else if (band->tuner == 1) {
1195                 if (band->index >= ARRAY_SIZE(bands_rx_tx)) {
1196                         ret = -EINVAL;
1197                 } else {
1198                         *band = bands_rx_tx[band->index];
1199                         ret = 0;
1200                 }
1201         } else {
1202                 ret = -EINVAL;
1203         }
1204
1205         return ret;
1206 }
1207
1208 static const struct v4l2_ioctl_ops hackrf_ioctl_ops = {
1209         .vidioc_querycap          = hackrf_querycap,
1210
1211         .vidioc_s_fmt_sdr_cap     = hackrf_s_fmt_sdr,
1212         .vidioc_g_fmt_sdr_cap     = hackrf_g_fmt_sdr,
1213         .vidioc_enum_fmt_sdr_cap  = hackrf_enum_fmt_sdr,
1214         .vidioc_try_fmt_sdr_cap   = hackrf_try_fmt_sdr,
1215
1216         .vidioc_s_fmt_sdr_out     = hackrf_s_fmt_sdr,
1217         .vidioc_g_fmt_sdr_out     = hackrf_g_fmt_sdr,
1218         .vidioc_enum_fmt_sdr_out  = hackrf_enum_fmt_sdr,
1219         .vidioc_try_fmt_sdr_out   = hackrf_try_fmt_sdr,
1220
1221         .vidioc_reqbufs           = vb2_ioctl_reqbufs,
1222         .vidioc_create_bufs       = vb2_ioctl_create_bufs,
1223         .vidioc_prepare_buf       = vb2_ioctl_prepare_buf,
1224         .vidioc_querybuf          = vb2_ioctl_querybuf,
1225         .vidioc_qbuf              = vb2_ioctl_qbuf,
1226         .vidioc_dqbuf             = vb2_ioctl_dqbuf,
1227         .vidioc_expbuf            = vb2_ioctl_expbuf,
1228
1229         .vidioc_streamon          = vb2_ioctl_streamon,
1230         .vidioc_streamoff         = vb2_ioctl_streamoff,
1231
1232         .vidioc_s_tuner           = hackrf_s_tuner,
1233         .vidioc_g_tuner           = hackrf_g_tuner,
1234
1235         .vidioc_s_modulator       = hackrf_s_modulator,
1236         .vidioc_g_modulator       = hackrf_g_modulator,
1237
1238         .vidioc_s_frequency       = hackrf_s_frequency,
1239         .vidioc_g_frequency       = hackrf_g_frequency,
1240         .vidioc_enum_freq_bands   = hackrf_enum_freq_bands,
1241
1242         .vidioc_subscribe_event   = v4l2_ctrl_subscribe_event,
1243         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1244         .vidioc_log_status        = v4l2_ctrl_log_status,
1245 };
1246
1247 static const struct v4l2_file_operations hackrf_fops = {
1248         .owner                    = THIS_MODULE,
1249         .open                     = v4l2_fh_open,
1250         .release                  = vb2_fop_release,
1251         .read                     = vb2_fop_read,
1252         .write                    = vb2_fop_write,
1253         .poll                     = vb2_fop_poll,
1254         .mmap                     = vb2_fop_mmap,
1255         .unlocked_ioctl           = video_ioctl2,
1256 };
1257
1258 static struct video_device hackrf_template = {
1259         .name                     = "HackRF One",
1260         .release                  = video_device_release_empty,
1261         .fops                     = &hackrf_fops,
1262         .ioctl_ops                = &hackrf_ioctl_ops,
1263 };
1264
1265 static void hackrf_video_release(struct v4l2_device *v)
1266 {
1267         struct hackrf_dev *dev = container_of(v, struct hackrf_dev, v4l2_dev);
1268
1269         dev_dbg(dev->dev, "\n");
1270
1271         v4l2_ctrl_handler_free(&dev->rx_ctrl_handler);
1272         v4l2_ctrl_handler_free(&dev->tx_ctrl_handler);
1273         v4l2_device_unregister(&dev->v4l2_dev);
1274         kfree(dev);
1275 }
1276
1277 static int hackrf_s_ctrl_rx(struct v4l2_ctrl *ctrl)
1278 {
1279         struct hackrf_dev *dev = container_of(ctrl->handler,
1280                         struct hackrf_dev, rx_ctrl_handler);
1281         struct usb_interface *intf = dev->intf;
1282         int ret;
1283
1284         switch (ctrl->id) {
1285         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1286         case V4L2_CID_RF_TUNER_BANDWIDTH:
1287                 set_bit(RX_BANDWIDTH, &dev->flags);
1288                 break;
1289         case  V4L2_CID_RF_TUNER_RF_GAIN:
1290                 set_bit(RX_RF_GAIN, &dev->flags);
1291                 break;
1292         case  V4L2_CID_RF_TUNER_LNA_GAIN:
1293                 set_bit(RX_LNA_GAIN, &dev->flags);
1294                 break;
1295         case  V4L2_CID_RF_TUNER_IF_GAIN:
1296                 set_bit(RX_IF_GAIN, &dev->flags);
1297                 break;
1298         default:
1299                 dev_dbg(&intf->dev, "unknown ctrl: id=%d name=%s\n",
1300                         ctrl->id, ctrl->name);
1301                 ret = -EINVAL;
1302                 goto err;
1303         }
1304
1305         ret = hackrf_set_params(dev);
1306         if (ret)
1307                 goto err;
1308
1309         return 0;
1310 err:
1311         dev_dbg(&intf->dev, "failed=%d\n", ret);
1312         return ret;
1313 }
1314
1315 static int hackrf_s_ctrl_tx(struct v4l2_ctrl *ctrl)
1316 {
1317         struct hackrf_dev *dev = container_of(ctrl->handler,
1318                         struct hackrf_dev, tx_ctrl_handler);
1319         struct usb_interface *intf = dev->intf;
1320         int ret;
1321
1322         switch (ctrl->id) {
1323         case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1324         case V4L2_CID_RF_TUNER_BANDWIDTH:
1325                 set_bit(TX_BANDWIDTH, &dev->flags);
1326                 break;
1327         case  V4L2_CID_RF_TUNER_LNA_GAIN:
1328                 set_bit(TX_LNA_GAIN, &dev->flags);
1329                 break;
1330         case  V4L2_CID_RF_TUNER_RF_GAIN:
1331                 set_bit(TX_RF_GAIN, &dev->flags);
1332                 break;
1333         default:
1334                 dev_dbg(&intf->dev, "unknown ctrl: id=%d name=%s\n",
1335                         ctrl->id, ctrl->name);
1336                 ret = -EINVAL;
1337                 goto err;
1338         }
1339
1340         ret = hackrf_set_params(dev);
1341         if (ret)
1342                 goto err;
1343
1344         return 0;
1345 err:
1346         dev_dbg(&intf->dev, "failed=%d\n", ret);
1347         return ret;
1348 }
1349
1350 static const struct v4l2_ctrl_ops hackrf_ctrl_ops_rx = {
1351         .s_ctrl = hackrf_s_ctrl_rx,
1352 };
1353
1354 static const struct v4l2_ctrl_ops hackrf_ctrl_ops_tx = {
1355         .s_ctrl = hackrf_s_ctrl_tx,
1356 };
1357
1358 static int hackrf_probe(struct usb_interface *intf,
1359                 const struct usb_device_id *id)
1360 {
1361         struct hackrf_dev *dev;
1362         int ret;
1363         u8 u8tmp, buf[BUF_SIZE];
1364
1365         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1366         if (!dev) {
1367                 ret = -ENOMEM;
1368                 goto err;
1369         }
1370
1371         mutex_init(&dev->v4l2_lock);
1372         mutex_init(&dev->vb_queue_lock);
1373         spin_lock_init(&dev->buffer_list_lock);
1374         INIT_LIST_HEAD(&dev->rx_buffer_list);
1375         INIT_LIST_HEAD(&dev->tx_buffer_list);
1376         dev->intf = intf;
1377         dev->dev = &intf->dev;
1378         dev->udev = interface_to_usbdev(intf);
1379         dev->pixelformat = formats[0].pixelformat;
1380         dev->buffersize = formats[0].buffersize;
1381         dev->f_adc = bands_adc_dac[0].rangelow;
1382         dev->f_dac = bands_adc_dac[0].rangelow;
1383         dev->f_rx = bands_rx_tx[0].rangelow;
1384         dev->f_tx = bands_rx_tx[0].rangelow;
1385         set_bit(RX_ADC_FREQUENCY, &dev->flags);
1386         set_bit(TX_DAC_FREQUENCY, &dev->flags);
1387         set_bit(RX_RF_FREQUENCY, &dev->flags);
1388         set_bit(TX_RF_FREQUENCY, &dev->flags);
1389
1390         /* Detect device */
1391         ret = hackrf_ctrl_msg(dev, CMD_BOARD_ID_READ, 0, 0, &u8tmp, 1);
1392         if (ret == 0)
1393                 ret = hackrf_ctrl_msg(dev, CMD_VERSION_STRING_READ, 0, 0,
1394                                 buf, BUF_SIZE);
1395         if (ret) {
1396                 dev_err(dev->dev, "Could not detect board\n");
1397                 goto err_kfree;
1398         }
1399
1400         buf[BUF_SIZE - 1] = '\0';
1401         dev_info(dev->dev, "Board ID: %02x\n", u8tmp);
1402         dev_info(dev->dev, "Firmware version: %s\n", buf);
1403
1404         /* Init vb2 queue structure for receiver */
1405         dev->rx_vb2_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1406         dev->rx_vb2_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF |
1407                                      VB2_READ;
1408         dev->rx_vb2_queue.ops = &hackrf_vb2_ops;
1409         dev->rx_vb2_queue.mem_ops = &vb2_vmalloc_memops;
1410         dev->rx_vb2_queue.drv_priv = dev;
1411         dev->rx_vb2_queue.buf_struct_size = sizeof(struct hackrf_buffer);
1412         dev->rx_vb2_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1413         ret = vb2_queue_init(&dev->rx_vb2_queue);
1414         if (ret) {
1415                 dev_err(dev->dev, "Could not initialize rx vb2 queue\n");
1416                 goto err_kfree;
1417         }
1418
1419         /* Init vb2 queue structure for transmitter */
1420         dev->tx_vb2_queue.type = V4L2_BUF_TYPE_SDR_OUTPUT;
1421         dev->tx_vb2_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF |
1422                                      VB2_WRITE;
1423         dev->tx_vb2_queue.ops = &hackrf_vb2_ops;
1424         dev->tx_vb2_queue.mem_ops = &vb2_vmalloc_memops;
1425         dev->tx_vb2_queue.drv_priv = dev;
1426         dev->tx_vb2_queue.buf_struct_size = sizeof(struct hackrf_buffer);
1427         dev->tx_vb2_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1428         ret = vb2_queue_init(&dev->tx_vb2_queue);
1429         if (ret) {
1430                 dev_err(dev->dev, "Could not initialize tx vb2 queue\n");
1431                 goto err_kfree;
1432         }
1433
1434         /* Register controls for receiver */
1435         v4l2_ctrl_handler_init(&dev->rx_ctrl_handler, 5);
1436         dev->rx_bandwidth_auto = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1437                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1438                 0, 1, 0, 1);
1439         dev->rx_bandwidth = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1440                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_BANDWIDTH,
1441                 1750000, 28000000, 50000, 1750000);
1442         v4l2_ctrl_auto_cluster(2, &dev->rx_bandwidth_auto, 0, false);
1443         dev->rx_rf_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1444                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_RF_GAIN, 0, 12, 12, 0);
1445         dev->rx_lna_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1446                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_LNA_GAIN, 0, 40, 8, 0);
1447         dev->rx_if_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1448                 &hackrf_ctrl_ops_rx, V4L2_CID_RF_TUNER_IF_GAIN, 0, 62, 2, 0);
1449         if (dev->rx_ctrl_handler.error) {
1450                 ret = dev->rx_ctrl_handler.error;
1451                 dev_err(dev->dev, "Could not initialize controls\n");
1452                 goto err_v4l2_ctrl_handler_free_rx;
1453         }
1454         v4l2_ctrl_handler_setup(&dev->rx_ctrl_handler);
1455
1456         /* Register controls for transmitter */
1457         v4l2_ctrl_handler_init(&dev->tx_ctrl_handler, 4);
1458         dev->tx_bandwidth_auto = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1459                 &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1460                 0, 1, 0, 1);
1461         dev->tx_bandwidth = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1462                 &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_BANDWIDTH,
1463                 1750000, 28000000, 50000, 1750000);
1464         v4l2_ctrl_auto_cluster(2, &dev->tx_bandwidth_auto, 0, false);
1465         dev->tx_lna_gain = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1466                 &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_LNA_GAIN, 0, 47, 1, 0);
1467         dev->tx_rf_gain = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1468                 &hackrf_ctrl_ops_tx, V4L2_CID_RF_TUNER_RF_GAIN, 0, 15, 15, 0);
1469         if (dev->tx_ctrl_handler.error) {
1470                 ret = dev->tx_ctrl_handler.error;
1471                 dev_err(dev->dev, "Could not initialize controls\n");
1472                 goto err_v4l2_ctrl_handler_free_tx;
1473         }
1474         v4l2_ctrl_handler_setup(&dev->tx_ctrl_handler);
1475
1476         /* Register the v4l2_device structure */
1477         dev->v4l2_dev.release = hackrf_video_release;
1478         ret = v4l2_device_register(&intf->dev, &dev->v4l2_dev);
1479         if (ret) {
1480                 dev_err(dev->dev, "Failed to register v4l2-device (%d)\n", ret);
1481                 goto err_v4l2_ctrl_handler_free_tx;
1482         }
1483
1484         /* Init video_device structure for receiver */
1485         dev->rx_vdev = hackrf_template;
1486         dev->rx_vdev.queue = &dev->rx_vb2_queue;
1487         dev->rx_vdev.queue->lock = &dev->vb_queue_lock;
1488         dev->rx_vdev.v4l2_dev = &dev->v4l2_dev;
1489         dev->rx_vdev.ctrl_handler = &dev->rx_ctrl_handler;
1490         dev->rx_vdev.lock = &dev->v4l2_lock;
1491         dev->rx_vdev.vfl_dir = VFL_DIR_RX;
1492         video_set_drvdata(&dev->rx_vdev, dev);
1493         ret = video_register_device(&dev->rx_vdev, VFL_TYPE_SDR, -1);
1494         if (ret) {
1495                 dev_err(dev->dev,
1496                         "Failed to register as video device (%d)\n", ret);
1497                 goto err_v4l2_device_unregister;
1498         }
1499         dev_info(dev->dev, "Registered as %s\n",
1500                  video_device_node_name(&dev->rx_vdev));
1501
1502         /* Init video_device structure for transmitter */
1503         dev->tx_vdev = hackrf_template;
1504         dev->tx_vdev.queue = &dev->tx_vb2_queue;
1505         dev->tx_vdev.queue->lock = &dev->vb_queue_lock;
1506         dev->tx_vdev.v4l2_dev = &dev->v4l2_dev;
1507         dev->tx_vdev.ctrl_handler = &dev->tx_ctrl_handler;
1508         dev->tx_vdev.lock = &dev->v4l2_lock;
1509         dev->tx_vdev.vfl_dir = VFL_DIR_TX;
1510         video_set_drvdata(&dev->tx_vdev, dev);
1511         ret = video_register_device(&dev->tx_vdev, VFL_TYPE_SDR, -1);
1512         if (ret) {
1513                 dev_err(dev->dev,
1514                         "Failed to register as video device (%d)\n", ret);
1515                 goto err_video_unregister_device_rx;
1516         }
1517         dev_info(dev->dev, "Registered as %s\n",
1518                  video_device_node_name(&dev->tx_vdev));
1519
1520         dev_notice(dev->dev, "SDR API is still slightly experimental and functionality changes may follow\n");
1521         return 0;
1522 err_video_unregister_device_rx:
1523         video_unregister_device(&dev->rx_vdev);
1524 err_v4l2_device_unregister:
1525         v4l2_device_unregister(&dev->v4l2_dev);
1526 err_v4l2_ctrl_handler_free_tx:
1527         v4l2_ctrl_handler_free(&dev->tx_ctrl_handler);
1528 err_v4l2_ctrl_handler_free_rx:
1529         v4l2_ctrl_handler_free(&dev->rx_ctrl_handler);
1530 err_kfree:
1531         kfree(dev);
1532 err:
1533         dev_dbg(dev->dev, "failed=%d\n", ret);
1534         return ret;
1535 }
1536
1537 /* USB device ID list */
1538 static struct usb_device_id hackrf_id_table[] = {
1539         { USB_DEVICE(0x1d50, 0x6089) }, /* HackRF One */
1540         { }
1541 };
1542 MODULE_DEVICE_TABLE(usb, hackrf_id_table);
1543
1544 /* USB subsystem interface */
1545 static struct usb_driver hackrf_driver = {
1546         .name                     = KBUILD_MODNAME,
1547         .probe                    = hackrf_probe,
1548         .disconnect               = hackrf_disconnect,
1549         .id_table                 = hackrf_id_table,
1550 };
1551
1552 module_usb_driver(hackrf_driver);
1553
1554 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1555 MODULE_DESCRIPTION("HackRF");
1556 MODULE_LICENSE("GPL");