drivers/media/usb/airspy/airspy.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * AirSpy SDR 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 /* AirSpy USB API commands (from AirSpy Library) */
  19 enum {
  20         CMD_INVALID                       = 0x00,
  21         CMD_RECEIVER_MODE                 = 0x01,
  22         CMD_SI5351C_WRITE                 = 0x02,
  23         CMD_SI5351C_READ                  = 0x03,
  24         CMD_R820T_WRITE                   = 0x04,
  25         CMD_R820T_READ                    = 0x05,
  26         CMD_SPIFLASH_ERASE                = 0x06,
  27         CMD_SPIFLASH_WRITE                = 0x07,
  28         CMD_SPIFLASH_READ                 = 0x08,
  29         CMD_BOARD_ID_READ                 = 0x09,
  30         CMD_VERSION_STRING_READ           = 0x0a,
  31         CMD_BOARD_PARTID_SERIALNO_READ    = 0x0b,
  32         CMD_SET_SAMPLE_RATE               = 0x0c,
  33         CMD_SET_FREQ                      = 0x0d,
  34         CMD_SET_LNA_GAIN                  = 0x0e,
  35         CMD_SET_MIXER_GAIN                = 0x0f,
  36         CMD_SET_VGA_GAIN                  = 0x10,
  37         CMD_SET_LNA_AGC                   = 0x11,
  38         CMD_SET_MIXER_AGC                 = 0x12,
  39         CMD_SET_PACKING                   = 0x13,
  40 };
  41
  42 /*
  43  *       bEndpointAddress     0x81  EP 1 IN
  44  *         Transfer Type            Bulk
  45  *       wMaxPacketSize     0x0200  1x 512 bytes
  46  */
  47 #define MAX_BULK_BUFS            (6)
  48 #define BULK_BUFFER_SIZE         (128 * 512)
  49
  50 static const struct v4l2_frequency_band bands[] = {
  51         {
  52                 .tuner = 0,
  53                 .type = V4L2_TUNER_ADC,
  54                 .index = 0,
  55                 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
  56                 .rangelow   = 20000000,
  57                 .rangehigh  = 20000000,
  58         },
  59 };
  60
  61 static const struct v4l2_frequency_band bands_rf[] = {
  62         {
  63                 .tuner = 1,
  64                 .type = V4L2_TUNER_RF,
  65                 .index = 0,
  66                 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
  67                 .rangelow   =   24000000,
  68                 .rangehigh  = 1750000000,
  69         },
  70 };
  71
  72 /* stream formats */
  73 struct airspy_format {
  74         char    *name;
  75         u32     pixelformat;
  76         u32     buffersize;
  77 };
  78
  79 /* format descriptions for capture and preview */
  80 static struct airspy_format formats[] = {
  81         {
  82                 .name           = "Real U12LE",
  83                 .pixelformat    = V4L2_SDR_FMT_RU12LE,
  84                 .buffersize     = BULK_BUFFER_SIZE,
  85         },
  86 };
  87
  88 static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats);
  89
  90 /* intermediate buffers with raw data from the USB device */
  91 struct airspy_frame_buf {
  92         /* common v4l buffer stuff -- must be first */
  93         struct vb2_v4l2_buffer vb;
  94         struct list_head list;
  95 };
  96
  97 struct airspy {
  98 #define POWER_ON           1
  99 #define USB_STATE_URB_BUF  2
 100         unsigned long flags;
 101
 102         struct device *dev;
 103         struct usb_device *udev;
 104         struct video_device vdev;
 105         struct v4l2_device v4l2_dev;
 106
 107         /* videobuf2 queue and queued buffers list */
 108         struct vb2_queue vb_queue;
 109         struct list_head queued_bufs;
 110         spinlock_t queued_bufs_lock; /* Protects queued_bufs */
 111         unsigned sequence;           /* Buffer sequence counter */
 112         unsigned int vb_full;        /* vb is full and packets dropped */
 113
 114         /* Note if taking both locks v4l2_lock must always be locked first! */
 115         struct mutex v4l2_lock;      /* Protects everything else */
 116         struct mutex vb_queue_lock;  /* Protects vb_queue and capt_file */
 117
 118         struct urb     *urb_list[MAX_BULK_BUFS];
 119         int            buf_num;
 120         unsigned long  buf_size;
 121         u8             *buf_list[MAX_BULK_BUFS];
 122         dma_addr_t     dma_addr[MAX_BULK_BUFS];
 123         int            urbs_initialized;
 124         int            urbs_submitted;
 125
 126         /* USB control message buffer */
 127         #define BUF_SIZE 128
 128         u8 buf[BUF_SIZE];
 129
 130         /* Current configuration */
 131         unsigned int f_adc;
 132         unsigned int f_rf;
 133         u32 pixelformat;
 134         u32 buffersize;
 135
 136         /* Controls */
 137         struct v4l2_ctrl_handler hdl;
 138         struct v4l2_ctrl *lna_gain_auto;
 139         struct v4l2_ctrl *lna_gain;
 140         struct v4l2_ctrl *mixer_gain_auto;
 141         struct v4l2_ctrl *mixer_gain;
 142         struct v4l2_ctrl *if_gain;
 143
 144         /* Sample rate calc */
 145         unsigned long jiffies_next;
 146         unsigned int sample;
 147         unsigned int sample_measured;
 148 };
 149
 150 #define airspy_dbg_usb_control_msg(_dev, _r, _t, _v, _i, _b, _l) { \
 151         char *_direction; \
 152         if (_t & USB_DIR_IN) \
 153                 _direction = "<<<"; \
 154         else \
 155                 _direction = ">>>"; \
 156         dev_dbg(_dev, "%02x %02x %02x %02x %02x %02x %02x %02x %s %*ph\n", \
 157                         _t, _r, _v & 0xff, _v >> 8, _i & 0xff, _i >> 8, \
 158                         _l & 0xff, _l >> 8, _direction, _l, _b); \
 159 }
 160
 161 /* execute firmware command */
 162 static int airspy_ctrl_msg(struct airspy *s, u8 request, u16 value, u16 index,
 163                 u8 *data, u16 size)
 164 {
 165         int ret;
 166         unsigned int pipe;
 167         u8 requesttype;
 168
 169         switch (request) {
 170         case CMD_RECEIVER_MODE:
 171         case CMD_SET_FREQ:
 172                 pipe = usb_sndctrlpipe(s->udev, 0);
 173                 requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
 174                 break;
 175         case CMD_BOARD_ID_READ:
 176         case CMD_VERSION_STRING_READ:
 177         case CMD_BOARD_PARTID_SERIALNO_READ:
 178         case CMD_SET_LNA_GAIN:
 179         case CMD_SET_MIXER_GAIN:
 180         case CMD_SET_VGA_GAIN:
 181         case CMD_SET_LNA_AGC:
 182         case CMD_SET_MIXER_AGC:
 183                 pipe = usb_rcvctrlpipe(s->udev, 0);
 184                 requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
 185                 break;
 186         default:
 187                 dev_err(s->dev, "Unknown command %02x\n", request);
 188                 ret = -EINVAL;
 189                 goto err;
 190         }
 191
 192         /* write request */
 193         if (!(requesttype & USB_DIR_IN))
 194                 memcpy(s->buf, data, size);
 195
 196         ret = usb_control_msg(s->udev, pipe, request, requesttype, value,
 197                         index, s->buf, size, 1000);
 198         airspy_dbg_usb_control_msg(s->dev, request, requesttype, value,
 199                         index, s->buf, size);
 200         if (ret < 0) {
 201                 dev_err(s->dev, "usb_control_msg() failed %d request %02x\n",
 202                                 ret, request);
 203                 goto err;
 204         }
 205
 206         /* read request */
 207         if (requesttype & USB_DIR_IN)
 208                 memcpy(data, s->buf, size);
 209
 210         return 0;
 211 err:
 212         return ret;
 213 }
 214
 215 /* Private functions */
 216 static struct airspy_frame_buf *airspy_get_next_fill_buf(struct airspy *s)
 217 {
 218         unsigned long flags;
 219         struct airspy_frame_buf *buf = NULL;
 220
 221         spin_lock_irqsave(&s->queued_bufs_lock, flags);
 222         if (list_empty(&s->queued_bufs))
 223                 goto leave;
 224
 225         buf = list_entry(s->queued_bufs.next,
 226                         struct airspy_frame_buf, list);
 227         list_del(&buf->list);
 228 leave:
 229         spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
 230         return buf;
 231 }
 232
 233 static unsigned int airspy_convert_stream(struct airspy *s,
 234                 void *dst, void *src, unsigned int src_len)
 235 {
 236         unsigned int dst_len;
 237
 238         if (s->pixelformat == V4L2_SDR_FMT_RU12LE) {
 239                 memcpy(dst, src, src_len);
 240                 dst_len = src_len;
 241         } else {
 242                 dst_len = 0;
 243         }
 244
 245         /* calculate sample rate and output it in 10 seconds intervals */
 246         if (unlikely(time_is_before_jiffies(s->jiffies_next))) {
 247                 #define MSECS 10000UL
 248                 unsigned int msecs = jiffies_to_msecs(jiffies -
 249                                 s->jiffies_next + msecs_to_jiffies(MSECS));
 250                 unsigned int samples = s->sample - s->sample_measured;
 251
 252                 s->jiffies_next = jiffies + msecs_to_jiffies(MSECS);
 253                 s->sample_measured = s->sample;
 254                 dev_dbg(s->dev, "slen=%u samples=%u msecs=%u sample rate=%lu\n",
 255                                 src_len, samples, msecs,
 256                                 samples * 1000UL / msecs);
 257         }
 258
 259         /* total number of samples */
 260         s->sample += src_len / 2;
 261
 262         return dst_len;
 263 }
 264
 265 /*
 266  * This gets called for the bulk stream pipe. This is done in interrupt
 267  * time, so it has to be fast, not crash, and not stall. Neat.
 268  */
 269 static void airspy_urb_complete(struct urb *urb)
 270 {
 271         struct airspy *s = urb->context;
 272         struct airspy_frame_buf *fbuf;
 273
 274         dev_dbg_ratelimited(s->dev, "status=%d length=%d/%d errors=%d\n",
 275                         urb->status, urb->actual_length,
 276                         urb->transfer_buffer_length, urb->error_count);
 277
 278         switch (urb->status) {
 279         case 0:             /* success */
 280         case -ETIMEDOUT:    /* NAK */
 281                 break;
 282         case -ECONNRESET:   /* kill */
 283         case -ENOENT:
 284         case -ESHUTDOWN:
 285                 return;
 286         default:            /* error */
 287                 dev_err_ratelimited(s->dev, "URB failed %d\n", urb->status);
 288                 break;
 289         }
 290
 291         if (likely(urb->actual_length > 0)) {
 292                 void *ptr;
 293                 unsigned int len;
 294                 /* get free framebuffer */
 295                 fbuf = airspy_get_next_fill_buf(s);
 296                 if (unlikely(fbuf == NULL)) {
 297                         s->vb_full++;
 298                         dev_notice_ratelimited(s->dev,
 299                                         "videobuf is full, %d packets dropped\n",
 300                                         s->vb_full);
 301                         goto skip;
 302                 }
 303
 304                 /* fill framebuffer */
 305                 ptr = vb2_plane_vaddr(&fbuf->vb.vb2_buf, 0);
 306                 len = airspy_convert_stream(s, ptr, urb->transfer_buffer,
 307                                 urb->actual_length);
 308                 vb2_set_plane_payload(&fbuf->vb.vb2_buf, 0, len);
 309                 fbuf->vb.vb2_buf.timestamp = ktime_get_ns();
 310                 fbuf->vb.sequence = s->sequence++;
 311                 vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
 312         }
 313 skip:
 314         usb_submit_urb(urb, GFP_ATOMIC);
 315 }
 316
 317 static int airspy_kill_urbs(struct airspy *s)
 318 {
 319         int i;
 320
 321         for (i = s->urbs_submitted - 1; i >= 0; i--) {
 322                 dev_dbg(s->dev, "kill urb=%d\n", i);
 323                 /* stop the URB */
 324                 usb_kill_urb(s->urb_list[i]);
 325         }
 326         s->urbs_submitted = 0;
 327
 328         return 0;
 329 }
 330
 331 static int airspy_submit_urbs(struct airspy *s)
 332 {
 333         int i, ret;
 334
 335         for (i = 0; i < s->urbs_initialized; i++) {
 336                 dev_dbg(s->dev, "submit urb=%d\n", i);
 337                 ret = usb_submit_urb(s->urb_list[i], GFP_ATOMIC);
 338                 if (ret) {
 339                         dev_err(s->dev, "Could not submit URB no. %d - get them all back\n",
 340                                         i);
 341                         airspy_kill_urbs(s);
 342                         return ret;
 343                 }
 344                 s->urbs_submitted++;
 345         }
 346
 347         return 0;
 348 }
 349
 350 static int airspy_free_stream_bufs(struct airspy *s)
 351 {
 352         if (test_bit(USB_STATE_URB_BUF, &s->flags)) {
 353                 while (s->buf_num) {
 354                         s->buf_num--;
 355                         dev_dbg(s->dev, "free buf=%d\n", s->buf_num);
 356                         usb_free_coherent(s->udev, s->buf_size,
 357                                           s->buf_list[s->buf_num],
 358                                           s->dma_addr[s->buf_num]);
 359                 }
 360         }
 361         clear_bit(USB_STATE_URB_BUF, &s->flags);
 362
 363         return 0;
 364 }
 365
 366 static int airspy_alloc_stream_bufs(struct airspy *s)
 367 {
 368         s->buf_num = 0;
 369         s->buf_size = BULK_BUFFER_SIZE;
 370
 371         dev_dbg(s->dev, "all in all I will use %u bytes for streaming\n",
 372                         MAX_BULK_BUFS * BULK_BUFFER_SIZE);
 373
 374         for (s->buf_num = 0; s->buf_num < MAX_BULK_BUFS; s->buf_num++) {
 375                 s->buf_list[s->buf_num] = usb_alloc_coherent(s->udev,
 376                                 BULK_BUFFER_SIZE, GFP_ATOMIC,
 377                                 &s->dma_addr[s->buf_num]);
 378                 if (!s->buf_list[s->buf_num]) {
 379                         dev_dbg(s->dev, "alloc buf=%d failed\n", s->buf_num);
 380                         airspy_free_stream_bufs(s);
 381                         return -ENOMEM;
 382                 }
 383
 384                 dev_dbg(s->dev, "alloc buf=%d %p (dma %llu)\n", s->buf_num,
 385                                 s->buf_list[s->buf_num],
 386                                 (long long)s->dma_addr[s->buf_num]);
 387                 set_bit(USB_STATE_URB_BUF, &s->flags);
 388         }
 389
 390         return 0;
 391 }
 392
 393 static int airspy_free_urbs(struct airspy *s)
 394 {
 395         int i;
 396
 397         airspy_kill_urbs(s);
 398
 399         for (i = s->urbs_initialized - 1; i >= 0; i--) {
 400                 if (s->urb_list[i]) {
 401                         dev_dbg(s->dev, "free urb=%d\n", i);
 402                         /* free the URBs */
 403                         usb_free_urb(s->urb_list[i]);
 404                 }
 405         }
 406         s->urbs_initialized = 0;
 407
 408         return 0;
 409 }
 410
 411 static int airspy_alloc_urbs(struct airspy *s)
 412 {
 413         int i, j;
 414
 415         /* allocate the URBs */
 416         for (i = 0; i < MAX_BULK_BUFS; i++) {
 417                 dev_dbg(s->dev, "alloc urb=%d\n", i);
 418                 s->urb_list[i] = usb_alloc_urb(0, GFP_ATOMIC);
 419                 if (!s->urb_list[i]) {
 420                         for (j = 0; j < i; j++)
 421                                 usb_free_urb(s->urb_list[j]);
 422                         return -ENOMEM;
 423                 }
 424                 usb_fill_bulk_urb(s->urb_list[i],
 425                                 s->udev,
 426                                 usb_rcvbulkpipe(s->udev, 0x81),
 427                                 s->buf_list[i],
 428                                 BULK_BUFFER_SIZE,
 429                                 airspy_urb_complete, s);
 430
 431                 s->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 432                 s->urb_list[i]->transfer_dma = s->dma_addr[i];
 433                 s->urbs_initialized++;
 434         }
 435
 436         return 0;
 437 }
 438
 439 /* Must be called with vb_queue_lock hold */
 440 static void airspy_cleanup_queued_bufs(struct airspy *s)
 441 {
 442         unsigned long flags;
 443
 444         dev_dbg(s->dev, "\n");
 445
 446         spin_lock_irqsave(&s->queued_bufs_lock, flags);
 447         while (!list_empty(&s->queued_bufs)) {
 448                 struct airspy_frame_buf *buf;
 449
 450                 buf = list_entry(s->queued_bufs.next,
 451                                 struct airspy_frame_buf, list);
 452                 list_del(&buf->list);
 453                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 454         }
 455         spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
 456 }
 457
 458 /* The user yanked out the cable... */
 459 static void airspy_disconnect(struct usb_interface *intf)
 460 {
 461         struct v4l2_device *v = usb_get_intfdata(intf);
 462         struct airspy *s = container_of(v, struct airspy, v4l2_dev);
 463
 464         dev_dbg(s->dev, "\n");
 465
 466         mutex_lock(&s->vb_queue_lock);
 467         mutex_lock(&s->v4l2_lock);
 468         /* No need to keep the urbs around after disconnection */
 469         s->udev = NULL;
 470         v4l2_device_disconnect(&s->v4l2_dev);
 471         video_unregister_device(&s->vdev);
 472         mutex_unlock(&s->v4l2_lock);
 473         mutex_unlock(&s->vb_queue_lock);
 474
 475         v4l2_device_put(&s->v4l2_dev);
 476 }
 477
 478 /* Videobuf2 operations */
 479 static int airspy_queue_setup(struct vb2_queue *vq,
 480                 unsigned int *nbuffers,
 481                 unsigned int *nplanes, unsigned int sizes[], struct device *alloc_devs[])
 482 {
 483         struct airspy *s = vb2_get_drv_priv(vq);
 484
 485         dev_dbg(s->dev, "nbuffers=%d\n", *nbuffers);
 486
 487         /* Need at least 8 buffers */
 488         if (vq->num_buffers + *nbuffers < 8)
 489                 *nbuffers = 8 - vq->num_buffers;
 490         *nplanes = 1;
 491         sizes[0] = PAGE_ALIGN(s->buffersize);
 492
 493         dev_dbg(s->dev, "nbuffers=%d sizes[0]=%d\n", *nbuffers, sizes[0]);
 494         return 0;
 495 }
 496
 497 static void airspy_buf_queue(struct vb2_buffer *vb)
 498 {
 499         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 500         struct airspy *s = vb2_get_drv_priv(vb->vb2_queue);
 501         struct airspy_frame_buf *buf =
 502                         container_of(vbuf, struct airspy_frame_buf, vb);
 503         unsigned long flags;
 504
 505         /* Check the device has not disconnected between prep and queuing */
 506         if (unlikely(!s->udev)) {
 507                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 508                 return;
 509         }
 510
 511         spin_lock_irqsave(&s->queued_bufs_lock, flags);
 512         list_add_tail(&buf->list, &s->queued_bufs);
 513         spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
 514 }
 515
 516 static int airspy_start_streaming(struct vb2_queue *vq, unsigned int count)
 517 {
 518         struct airspy *s = vb2_get_drv_priv(vq);
 519         int ret;
 520
 521         dev_dbg(s->dev, "\n");
 522
 523         if (!s->udev)
 524                 return -ENODEV;
 525
 526         mutex_lock(&s->v4l2_lock);
 527
 528         s->sequence = 0;
 529
 530         set_bit(POWER_ON, &s->flags);
 531
 532         ret = airspy_alloc_stream_bufs(s);
 533         if (ret)
 534                 goto err_clear_bit;
 535
 536         ret = airspy_alloc_urbs(s);
 537         if (ret)
 538                 goto err_free_stream_bufs;
 539
 540         ret = airspy_submit_urbs(s);
 541         if (ret)
 542                 goto err_free_urbs;
 543
 544         /* start hardware streaming */
 545         ret = airspy_ctrl_msg(s, CMD_RECEIVER_MODE, 1, 0, NULL, 0);
 546         if (ret)
 547                 goto err_kill_urbs;
 548
 549         goto exit_mutex_unlock;
 550
 551 err_kill_urbs:
 552         airspy_kill_urbs(s);
 553 err_free_urbs:
 554         airspy_free_urbs(s);
 555 err_free_stream_bufs:
 556         airspy_free_stream_bufs(s);
 557 err_clear_bit:
 558         clear_bit(POWER_ON, &s->flags);
 559
 560         /* return all queued buffers to vb2 */
 561         {
 562                 struct airspy_frame_buf *buf, *tmp;
 563
 564                 list_for_each_entry_safe(buf, tmp, &s->queued_bufs, list) {
 565                         list_del(&buf->list);
 566                         vb2_buffer_done(&buf->vb.vb2_buf,
 567                                         VB2_BUF_STATE_QUEUED);
 568                 }
 569         }
 570
 571 exit_mutex_unlock:
 572         mutex_unlock(&s->v4l2_lock);
 573
 574         return ret;
 575 }
 576
 577 static void airspy_stop_streaming(struct vb2_queue *vq)
 578 {
 579         struct airspy *s = vb2_get_drv_priv(vq);
 580
 581         dev_dbg(s->dev, "\n");
 582
 583         mutex_lock(&s->v4l2_lock);
 584
 585         /* stop hardware streaming */
 586         airspy_ctrl_msg(s, CMD_RECEIVER_MODE, 0, 0, NULL, 0);
 587
 588         airspy_kill_urbs(s);
 589         airspy_free_urbs(s);
 590         airspy_free_stream_bufs(s);
 591
 592         airspy_cleanup_queued_bufs(s);
 593
 594         clear_bit(POWER_ON, &s->flags);
 595
 596         mutex_unlock(&s->v4l2_lock);
 597 }
 598
 599 static const struct vb2_ops airspy_vb2_ops = {
 600         .queue_setup            = airspy_queue_setup,
 601         .buf_queue              = airspy_buf_queue,
 602         .start_streaming        = airspy_start_streaming,
 603         .stop_streaming         = airspy_stop_streaming,
 604         .wait_prepare           = vb2_ops_wait_prepare,
 605         .wait_finish            = vb2_ops_wait_finish,
 606 };
 607
 608 static int airspy_querycap(struct file *file, void *fh,
 609                 struct v4l2_capability *cap)
 610 {
 611         struct airspy *s = video_drvdata(file);
 612
 613         strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
 614         strscpy(cap->card, s->vdev.name, sizeof(cap->card));
 615         usb_make_path(s->udev, cap->bus_info, sizeof(cap->bus_info));
 616         cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
 617                         V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
 618         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 619
 620         return 0;
 621 }
 622
 623 static int airspy_enum_fmt_sdr_cap(struct file *file, void *priv,
 624                 struct v4l2_fmtdesc *f)
 625 {
 626         if (f->index >= NUM_FORMATS)
 627                 return -EINVAL;
 628
 629         strscpy(f->description, formats[f->index].name, sizeof(f->description));
 630         f->pixelformat = formats[f->index].pixelformat;
 631
 632         return 0;
 633 }
 634
 635 static int airspy_g_fmt_sdr_cap(struct file *file, void *priv,
 636                 struct v4l2_format *f)
 637 {
 638         struct airspy *s = video_drvdata(file);
 639
 640         f->fmt.sdr.pixelformat = s->pixelformat;
 641         f->fmt.sdr.buffersize = s->buffersize;
 642         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
 643
 644         return 0;
 645 }
 646
 647 static int airspy_s_fmt_sdr_cap(struct file *file, void *priv,
 648                 struct v4l2_format *f)
 649 {
 650         struct airspy *s = video_drvdata(file);
 651         struct vb2_queue *q = &s->vb_queue;
 652         int i;
 653
 654         if (vb2_is_busy(q))
 655                 return -EBUSY;
 656
 657         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
 658         for (i = 0; i < NUM_FORMATS; i++) {
 659                 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
 660                         s->pixelformat = formats[i].pixelformat;
 661                         s->buffersize = formats[i].buffersize;
 662                         f->fmt.sdr.buffersize = formats[i].buffersize;
 663                         return 0;
 664                 }
 665         }
 666
 667         s->pixelformat = formats[0].pixelformat;
 668         s->buffersize = formats[0].buffersize;
 669         f->fmt.sdr.pixelformat = formats[0].pixelformat;
 670         f->fmt.sdr.buffersize = formats[0].buffersize;
 671
 672         return 0;
 673 }
 674
 675 static int airspy_try_fmt_sdr_cap(struct file *file, void *priv,
 676                 struct v4l2_format *f)
 677 {
 678         int i;
 679
 680         memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
 681         for (i = 0; i < NUM_FORMATS; i++) {
 682                 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
 683                         f->fmt.sdr.buffersize = formats[i].buffersize;
 684                         return 0;
 685                 }
 686         }
 687
 688         f->fmt.sdr.pixelformat = formats[0].pixelformat;
 689         f->fmt.sdr.buffersize = formats[0].buffersize;
 690
 691         return 0;
 692 }
 693
 694 static int airspy_s_tuner(struct file *file, void *priv,
 695                 const struct v4l2_tuner *v)
 696 {
 697         int ret;
 698
 699         if (v->index == 0)
 700                 ret = 0;
 701         else if (v->index == 1)
 702                 ret = 0;
 703         else
 704                 ret = -EINVAL;
 705
 706         return ret;
 707 }
 708
 709 static int airspy_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
 710 {
 711         int ret;
 712
 713         if (v->index == 0) {
 714                 strscpy(v->name, "AirSpy ADC", sizeof(v->name));
 715                 v->type = V4L2_TUNER_ADC;
 716                 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
 717                 v->rangelow  = bands[0].rangelow;
 718                 v->rangehigh = bands[0].rangehigh;
 719                 ret = 0;
 720         } else if (v->index == 1) {
 721                 strscpy(v->name, "AirSpy RF", sizeof(v->name));
 722                 v->type = V4L2_TUNER_RF;
 723                 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
 724                 v->rangelow  = bands_rf[0].rangelow;
 725                 v->rangehigh = bands_rf[0].rangehigh;
 726                 ret = 0;
 727         } else {
 728                 ret = -EINVAL;
 729         }
 730
 731         return ret;
 732 }
 733
 734 static int airspy_g_frequency(struct file *file, void *priv,
 735                 struct v4l2_frequency *f)
 736 {
 737         struct airspy *s = video_drvdata(file);
 738         int ret;
 739
 740         if (f->tuner == 0) {
 741                 f->type = V4L2_TUNER_ADC;
 742                 f->frequency = s->f_adc;
 743                 dev_dbg(s->dev, "ADC frequency=%u Hz\n", s->f_adc);
 744                 ret = 0;
 745         } else if (f->tuner == 1) {
 746                 f->type = V4L2_TUNER_RF;
 747                 f->frequency = s->f_rf;
 748                 dev_dbg(s->dev, "RF frequency=%u Hz\n", s->f_rf);
 749                 ret = 0;
 750         } else {
 751                 ret = -EINVAL;
 752         }
 753
 754         return ret;
 755 }
 756
 757 static int airspy_s_frequency(struct file *file, void *priv,
 758                 const struct v4l2_frequency *f)
 759 {
 760         struct airspy *s = video_drvdata(file);
 761         int ret;
 762         u8 buf[4];
 763
 764         if (f->tuner == 0) {
 765                 s->f_adc = clamp_t(unsigned int, f->frequency,
 766                                 bands[0].rangelow,
 767                                 bands[0].rangehigh);
 768                 dev_dbg(s->dev, "ADC frequency=%u Hz\n", s->f_adc);
 769                 ret = 0;
 770         } else if (f->tuner == 1) {
 771                 s->f_rf = clamp_t(unsigned int, f->frequency,
 772                                 bands_rf[0].rangelow,
 773                                 bands_rf[0].rangehigh);
 774                 dev_dbg(s->dev, "RF frequency=%u Hz\n", s->f_rf);
 775                 buf[0] = (s->f_rf >>  0) & 0xff;
 776                 buf[1] = (s->f_rf >>  8) & 0xff;
 777                 buf[2] = (s->f_rf >> 16) & 0xff;
 778                 buf[3] = (s->f_rf >> 24) & 0xff;
 779                 ret = airspy_ctrl_msg(s, CMD_SET_FREQ, 0, 0, buf, 4);
 780         } else {
 781                 ret = -EINVAL;
 782         }
 783
 784         return ret;
 785 }
 786
 787 static int airspy_enum_freq_bands(struct file *file, void *priv,
 788                 struct v4l2_frequency_band *band)
 789 {
 790         int ret;
 791
 792         if (band->tuner == 0) {
 793                 if (band->index >= ARRAY_SIZE(bands)) {
 794                         ret = -EINVAL;
 795                 } else {
 796                         *band = bands[band->index];
 797                         ret = 0;
 798                 }
 799         } else if (band->tuner == 1) {
 800                 if (band->index >= ARRAY_SIZE(bands_rf)) {
 801                         ret = -EINVAL;
 802                 } else {
 803                         *band = bands_rf[band->index];
 804                         ret = 0;
 805                 }
 806         } else {
 807                 ret = -EINVAL;
 808         }
 809
 810         return ret;
 811 }
 812
 813 static const struct v4l2_ioctl_ops airspy_ioctl_ops = {
 814         .vidioc_querycap          = airspy_querycap,
 815
 816         .vidioc_enum_fmt_sdr_cap  = airspy_enum_fmt_sdr_cap,
 817         .vidioc_g_fmt_sdr_cap     = airspy_g_fmt_sdr_cap,
 818         .vidioc_s_fmt_sdr_cap     = airspy_s_fmt_sdr_cap,
 819         .vidioc_try_fmt_sdr_cap   = airspy_try_fmt_sdr_cap,
 820
 821         .vidioc_reqbufs           = vb2_ioctl_reqbufs,
 822         .vidioc_create_bufs       = vb2_ioctl_create_bufs,
 823         .vidioc_prepare_buf       = vb2_ioctl_prepare_buf,
 824         .vidioc_querybuf          = vb2_ioctl_querybuf,
 825         .vidioc_qbuf              = vb2_ioctl_qbuf,
 826         .vidioc_dqbuf             = vb2_ioctl_dqbuf,
 827
 828         .vidioc_streamon          = vb2_ioctl_streamon,
 829         .vidioc_streamoff         = vb2_ioctl_streamoff,
 830
 831         .vidioc_g_tuner           = airspy_g_tuner,
 832         .vidioc_s_tuner           = airspy_s_tuner,
 833
 834         .vidioc_g_frequency       = airspy_g_frequency,
 835         .vidioc_s_frequency       = airspy_s_frequency,
 836         .vidioc_enum_freq_bands   = airspy_enum_freq_bands,
 837
 838         .vidioc_subscribe_event   = v4l2_ctrl_subscribe_event,
 839         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 840         .vidioc_log_status        = v4l2_ctrl_log_status,
 841 };
 842
 843 static const struct v4l2_file_operations airspy_fops = {
 844         .owner                    = THIS_MODULE,
 845         .open                     = v4l2_fh_open,
 846         .release                  = vb2_fop_release,
 847         .read                     = vb2_fop_read,
 848         .poll                     = vb2_fop_poll,
 849         .mmap                     = vb2_fop_mmap,
 850         .unlocked_ioctl           = video_ioctl2,
 851 };
 852
 853 static const struct video_device airspy_template = {
 854         .name                     = "AirSpy SDR",
 855         .release                  = video_device_release_empty,
 856         .fops                     = &airspy_fops,
 857         .ioctl_ops                = &airspy_ioctl_ops,
 858 };
 859
 860 static void airspy_video_release(struct v4l2_device *v)
 861 {
 862         struct airspy *s = container_of(v, struct airspy, v4l2_dev);
 863
 864         v4l2_ctrl_handler_free(&s->hdl);
 865         v4l2_device_unregister(&s->v4l2_dev);
 866         kfree(s);
 867 }
 868
 869 static int airspy_set_lna_gain(struct airspy *s)
 870 {
 871         int ret;
 872         u8 u8tmp;
 873
 874         dev_dbg(s->dev, "lna auto=%d->%d val=%d->%d\n",
 875                         s->lna_gain_auto->cur.val, s->lna_gain_auto->val,
 876                         s->lna_gain->cur.val, s->lna_gain->val);
 877
 878         ret = airspy_ctrl_msg(s, CMD_SET_LNA_AGC, 0, s->lna_gain_auto->val,
 879                         &u8tmp, 1);
 880         if (ret)
 881                 goto err;
 882
 883         if (s->lna_gain_auto->val == false) {
 884                 ret = airspy_ctrl_msg(s, CMD_SET_LNA_GAIN, 0, s->lna_gain->val,
 885                                 &u8tmp, 1);
 886                 if (ret)
 887                         goto err;
 888         }
 889 err:
 890         if (ret)
 891                 dev_dbg(s->dev, "failed=%d\n", ret);
 892
 893         return ret;
 894 }
 895
 896 static int airspy_set_mixer_gain(struct airspy *s)
 897 {
 898         int ret;
 899         u8 u8tmp;
 900
 901         dev_dbg(s->dev, "mixer auto=%d->%d val=%d->%d\n",
 902                         s->mixer_gain_auto->cur.val, s->mixer_gain_auto->val,
 903                         s->mixer_gain->cur.val, s->mixer_gain->val);
 904
 905         ret = airspy_ctrl_msg(s, CMD_SET_MIXER_AGC, 0, s->mixer_gain_auto->val,
 906                         &u8tmp, 1);
 907         if (ret)
 908                 goto err;
 909
 910         if (s->mixer_gain_auto->val == false) {
 911                 ret = airspy_ctrl_msg(s, CMD_SET_MIXER_GAIN, 0,
 912                                 s->mixer_gain->val, &u8tmp, 1);
 913                 if (ret)
 914                         goto err;
 915         }
 916 err:
 917         if (ret)
 918                 dev_dbg(s->dev, "failed=%d\n", ret);
 919
 920         return ret;
 921 }
 922
 923 static int airspy_set_if_gain(struct airspy *s)
 924 {
 925         int ret;
 926         u8 u8tmp;
 927
 928         dev_dbg(s->dev, "val=%d->%d\n", s->if_gain->cur.val, s->if_gain->val);
 929
 930         ret = airspy_ctrl_msg(s, CMD_SET_VGA_GAIN, 0, s->if_gain->val,
 931                         &u8tmp, 1);
 932         if (ret)
 933                 dev_dbg(s->dev, "failed=%d\n", ret);
 934
 935         return ret;
 936 }
 937
 938 static int airspy_s_ctrl(struct v4l2_ctrl *ctrl)
 939 {
 940         struct airspy *s = container_of(ctrl->handler, struct airspy, hdl);
 941         int ret;
 942
 943         switch (ctrl->id) {
 944         case  V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
 945         case  V4L2_CID_RF_TUNER_LNA_GAIN:
 946                 ret = airspy_set_lna_gain(s);
 947                 break;
 948         case  V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
 949         case  V4L2_CID_RF_TUNER_MIXER_GAIN:
 950                 ret = airspy_set_mixer_gain(s);
 951                 break;
 952         case  V4L2_CID_RF_TUNER_IF_GAIN:
 953                 ret = airspy_set_if_gain(s);
 954                 break;
 955         default:
 956                 dev_dbg(s->dev, "unknown ctrl: id=%d name=%s\n",
 957                                 ctrl->id, ctrl->name);
 958                 ret = -EINVAL;
 959         }
 960
 961         return ret;
 962 }
 963
 964 static const struct v4l2_ctrl_ops airspy_ctrl_ops = {
 965         .s_ctrl = airspy_s_ctrl,
 966 };
 967
 968 static int airspy_probe(struct usb_interface *intf,
 969                 const struct usb_device_id *id)
 970 {
 971         struct airspy *s;
 972         int ret;
 973         u8 u8tmp, buf[BUF_SIZE];
 974
 975         s = kzalloc(sizeof(struct airspy), GFP_KERNEL);
 976         if (s == NULL) {
 977                 dev_err(&intf->dev, "Could not allocate memory for state\n");
 978                 return -ENOMEM;
 979         }
 980
 981         mutex_init(&s->v4l2_lock);
 982         mutex_init(&s->vb_queue_lock);
 983         spin_lock_init(&s->queued_bufs_lock);
 984         INIT_LIST_HEAD(&s->queued_bufs);
 985         s->dev = &intf->dev;
 986         s->udev = interface_to_usbdev(intf);
 987         s->f_adc = bands[0].rangelow;
 988         s->f_rf = bands_rf[0].rangelow;
 989         s->pixelformat = formats[0].pixelformat;
 990         s->buffersize = formats[0].buffersize;
 991
 992         /* Detect device */
 993         ret = airspy_ctrl_msg(s, CMD_BOARD_ID_READ, 0, 0, &u8tmp, 1);
 994         if (ret == 0)
 995                 ret = airspy_ctrl_msg(s, CMD_VERSION_STRING_READ, 0, 0,
 996                                 buf, BUF_SIZE);
 997         if (ret) {
 998                 dev_err(s->dev, "Could not detect board\n");
 999                 goto err_free_mem;
1000         }
1001
1002         buf[BUF_SIZE - 1] = '\0';
1003
1004         dev_info(s->dev, "Board ID: %02x\n", u8tmp);
1005         dev_info(s->dev, "Firmware version: %s\n", buf);
1006
1007         /* Init videobuf2 queue structure */
1008         s->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1009         s->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1010         s->vb_queue.drv_priv = s;
1011         s->vb_queue.buf_struct_size = sizeof(struct airspy_frame_buf);
1012         s->vb_queue.ops = &airspy_vb2_ops;
1013         s->vb_queue.mem_ops = &vb2_vmalloc_memops;
1014         s->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1015         ret = vb2_queue_init(&s->vb_queue);
1016         if (ret) {
1017                 dev_err(s->dev, "Could not initialize vb2 queue\n");
1018                 goto err_free_mem;
1019         }
1020
1021         /* Init video_device structure */
1022         s->vdev = airspy_template;
1023         s->vdev.queue = &s->vb_queue;
1024         s->vdev.queue->lock = &s->vb_queue_lock;
1025         video_set_drvdata(&s->vdev, s);
1026
1027         /* Register the v4l2_device structure */
1028         s->v4l2_dev.release = airspy_video_release;
1029         ret = v4l2_device_register(&intf->dev, &s->v4l2_dev);
1030         if (ret) {
1031                 dev_err(s->dev, "Failed to register v4l2-device (%d)\n", ret);
1032                 goto err_free_mem;
1033         }
1034
1035         /* Register controls */
1036         v4l2_ctrl_handler_init(&s->hdl, 5);
1037         s->lna_gain_auto = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
1038                         V4L2_CID_RF_TUNER_LNA_GAIN_AUTO, 0, 1, 1, 0);
1039         s->lna_gain = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
1040                         V4L2_CID_RF_TUNER_LNA_GAIN, 0, 14, 1, 8);
1041         v4l2_ctrl_auto_cluster(2, &s->lna_gain_auto, 0, false);
1042         s->mixer_gain_auto = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
1043                         V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO, 0, 1, 1, 0);
1044         s->mixer_gain = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
1045                         V4L2_CID_RF_TUNER_MIXER_GAIN, 0, 15, 1, 8);
1046         v4l2_ctrl_auto_cluster(2, &s->mixer_gain_auto, 0, false);
1047         s->if_gain = v4l2_ctrl_new_std(&s->hdl, &airspy_ctrl_ops,
1048                         V4L2_CID_RF_TUNER_IF_GAIN, 0, 15, 1, 0);
1049         if (s->hdl.error) {
1050                 ret = s->hdl.error;
1051                 dev_err(s->dev, "Could not initialize controls\n");
1052                 goto err_free_controls;
1053         }
1054
1055         v4l2_ctrl_handler_setup(&s->hdl);
1056
1057         s->v4l2_dev.ctrl_handler = &s->hdl;
1058         s->vdev.v4l2_dev = &s->v4l2_dev;
1059         s->vdev.lock = &s->v4l2_lock;
1060
1061         ret = video_register_device(&s->vdev, VFL_TYPE_SDR, -1);
1062         if (ret) {
1063                 dev_err(s->dev, "Failed to register as video device (%d)\n",
1064                                 ret);
1065                 goto err_free_controls;
1066         }
1067         dev_info(s->dev, "Registered as %s\n",
1068                         video_device_node_name(&s->vdev));
1069         dev_notice(s->dev, "SDR API is still slightly experimental and functionality changes may follow\n");
1070         return 0;
1071
1072 err_free_controls:
1073         v4l2_ctrl_handler_free(&s->hdl);
1074         v4l2_device_unregister(&s->v4l2_dev);
1075 err_free_mem:
1076         kfree(s);
1077         return ret;
1078 }
1079
1080 /* USB device ID list */
1081 static const struct usb_device_id airspy_id_table[] = {
1082         { USB_DEVICE(0x1d50, 0x60a1) }, /* AirSpy */
1083         { }
1084 };
1085 MODULE_DEVICE_TABLE(usb, airspy_id_table);
1086
1087 /* USB subsystem interface */
1088 static struct usb_driver airspy_driver = {
1089         .name                     = KBUILD_MODNAME,
1090         .probe                    = airspy_probe,
1091         .disconnect               = airspy_disconnect,
1092         .id_table                 = airspy_id_table,
1093 };
1094
1095 module_usb_driver(airspy_driver);
1096
1097 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1098 MODULE_DESCRIPTION("AirSpy SDR");
1099 MODULE_LICENSE("GPL");