Lines Matching refs:dev
111 struct device *dev;
182 static int hackrf_ctrl_msg(struct hackrf_dev *dev, u8 request, u16 value,
195 pipe = usb_sndctrlpipe(dev->udev, 0);
203 pipe = usb_rcvctrlpipe(dev->udev, 0);
207 dev_err(dev->dev, "Unknown command %02x\n", request);
214 memcpy(dev->buf, data, size);
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);
221 dev_err(dev->dev, "usb_control_msg() failed %d request %02x\n",
228 memcpy(data, dev->buf, size);
235 static int hackrf_set_params(struct hackrf_dev *dev)
237 struct usb_interface *intf = dev->intf;
241 const bool rx = test_bit(RX_ON, &dev->flags);
242 const bool tx = test_bit(TX_ON, &dev->flags);
265 dev_dbg(&intf->dev, "device is sleeping\n");
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;
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;
279 set_bit(RX_ADC_FREQUENCY, &dev->flags);
292 ret = hackrf_ctrl_msg(dev, CMD_SAMPLE_RATE_SET, 0, 0, buf, 8);
298 if (rx && test_and_clear_bit(RX_BANDWIDTH, &dev->flags)) {
299 if (dev->rx_bandwidth_auto->val == true)
300 uitmp = dev->f_adc;
302 uitmp = dev->rx_bandwidth->val;
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;
318 uitmp = dev->tx_bandwidth->val;
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);
339 ret = hackrf_ctrl_msg(dev, CMD_BASEBAND_FILTER_BANDWIDTH_SET,
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);
368 ret = hackrf_ctrl_msg(dev, CMD_SET_FREQ, 0, 0, buf, 8);
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);
378 u8tmp = (dev->rx_rf_gain->val) ? 1 : 0;
379 ret = hackrf_ctrl_msg(dev, CMD_AMP_ENABLE, u8tmp, 0, NULL, 0);
382 set_bit(TX_RF_GAIN, &dev->flags);
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);
390 u8tmp = (dev->tx_rf_gain->val) ? 1 : 0;
391 ret = hackrf_ctrl_msg(dev, CMD_AMP_ENABLE, u8tmp, 0, NULL, 0);
394 set_bit(RX_RF_GAIN, &dev->flags);
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);
402 ret = hackrf_ctrl_msg(dev, CMD_SET_LNA_GAIN, 0,
403 dev->rx_lna_gain->val, &u8tmp, 1);
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);
413 ret = hackrf_ctrl_msg(dev, CMD_SET_VGA_GAIN, 0,
414 dev->rx_if_gain->val, &u8tmp, 1);
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);
424 ret = hackrf_ctrl_msg(dev, CMD_SET_TXVGA_GAIN, 0,
425 dev->tx_lna_gain->val, &u8tmp, 1);
432 dev_dbg(&intf->dev, "failed=%d\n", ret);
437 static struct hackrf_buffer *hackrf_get_next_buffer(struct hackrf_dev *dev,
443 spin_lock_irqsave(&dev->buffer_list_lock, flags);
450 spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
454 static void hackrf_copy_stream(struct hackrf_dev *dev, void *dst, void *src,
460 if (unlikely(time_is_before_jiffies(dev->jiffies_next))) {
463 dev->jiffies_next + msecs_to_jiffies(MSECS));
464 unsigned int samples = dev->sample - dev->sample_measured;
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",
474 dev->sample += src_len / 2;
483 struct hackrf_dev *dev = urb->context;
484 struct usb_interface *intf = dev->intf;
488 dev_dbg_ratelimited(&intf->dev, "status=%d length=%u/%u\n", urb->status,
500 dev_err_ratelimited(&intf->dev, "URB failed %d\n", urb->status);
505 buffer = hackrf_get_next_buffer(dev, &dev->rx_buffer_list);
507 dev->vb_full++;
508 dev_notice_ratelimited(&intf->dev,
510 dev->vb_full);
516 hackrf_copy_stream(dev, vb2_plane_vaddr(&buffer->vb.vb2_buf, 0),
519 buffer->vb.sequence = dev->sequence++;
528 struct hackrf_dev *dev = urb->context;
529 struct usb_interface *intf = dev->intf;
533 dev_dbg_ratelimited(&intf->dev, "status=%d length=%u/%u\n", urb->status,
545 dev_err_ratelimited(&intf->dev, "URB failed %d\n", urb->status);
549 buffer = hackrf_get_next_buffer(dev, &dev->tx_buffer_list);
551 dev->vb_empty++;
552 dev_notice_ratelimited(&intf->dev,
554 dev->vb_empty);
561 hackrf_copy_stream(dev, urb->transfer_buffer,
564 buffer->vb.sequence = dev->sequence++;
571 static int hackrf_kill_urbs(struct hackrf_dev *dev)
575 for (i = dev->urbs_submitted - 1; i >= 0; i--) {
576 dev_dbg(dev->dev, "kill urb=%d\n", i);
578 usb_kill_urb(dev->urb_list[i]);
580 dev->urbs_submitted = 0;
585 static int hackrf_submit_urbs(struct hackrf_dev *dev)
589 for (i = 0; i < dev->urbs_initialized; i++) {
590 dev_dbg(dev->dev, "submit urb=%d\n", i);
591 ret = usb_submit_urb(dev->urb_list[i], GFP_KERNEL);
593 dev_err(dev->dev, "Could not submit URB no. %d - get them all back\n",
595 hackrf_kill_urbs(dev);
598 dev->urbs_submitted++;
604 static int hackrf_free_stream_bufs(struct hackrf_dev *dev)
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]);
615 dev->flags &= ~USB_STATE_URB_BUF;
620 static int hackrf_alloc_stream_bufs(struct hackrf_dev *dev)
622 dev->buf_num = 0;
623 dev->buf_size = BULK_BUFFER_SIZE;
625 dev_dbg(dev->dev, "all in all I will use %u bytes for streaming\n",
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,
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);
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;
648 static int hackrf_free_urbs(struct hackrf_dev *dev)
652 hackrf_kill_urbs(dev);
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);
658 usb_free_urb(dev->urb_list[i]);
661 dev->urbs_initialized = 0;
666 static int hackrf_alloc_urbs(struct hackrf_dev *dev, bool rcv)
673 pipe = usb_rcvbulkpipe(dev->udev, 0x81);
676 pipe = usb_sndbulkpipe(dev->udev, 0x02);
682 dev_dbg(dev->dev, "alloc urb=%d\n", i);
683 dev->urb_list[i] = usb_alloc_urb(0, GFP_KERNEL);
684 if (!dev->urb_list[i]) {
686 usb_free_urb(dev->urb_list[j]);
689 usb_fill_bulk_urb(dev->urb_list[i],
690 dev->udev,
692 dev->buf_list[i],
694 complete, dev);
696 dev->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
697 dev->urb_list[i]->transfer_dma = dev->dma_addr[i];
698 dev->urbs_initialized++;
708 struct hackrf_dev *dev = container_of(v, struct hackrf_dev, v4l2_dev);
710 dev_dbg(dev->dev, "\n");
712 mutex_lock(&dev->vb_queue_lock);
713 mutex_lock(&dev->v4l2_lock);
715 dev->udev = NULL;
716 v4l2_device_disconnect(&dev->v4l2_dev);
717 video_unregister_device(&dev->tx_vdev);
718 video_unregister_device(&dev->rx_vdev);
719 mutex_unlock(&dev->v4l2_lock);
720 mutex_unlock(&dev->vb_queue_lock);
722 v4l2_device_put(&dev->v4l2_dev);
729 struct hackrf_dev *dev = vb2_get_drv_priv(vq);
730 struct usb_interface *intf = dev->intf;
735 dev_dbg(&intf->dev, "\n");
738 buffer_list = &dev->rx_buffer_list;
740 buffer_list = &dev->tx_buffer_list;
742 spin_lock_irqsave(&dev->buffer_list_lock, flags);
744 dev_dbg(&intf->dev, "list_for_each_entry_safe\n");
748 spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
755 struct hackrf_dev *dev = vb2_get_drv_priv(vq);
757 dev_dbg(dev->dev, "nbuffers=%d\n", *nbuffers);
763 sizes[0] = PAGE_ALIGN(dev->buffersize);
765 dev_dbg(dev->dev, "nbuffers=%d sizes[0]=%d\n", *nbuffers, sizes[0]);
773 struct hackrf_dev *dev = vb2_get_drv_priv(vq);
778 dev_dbg_ratelimited(&dev->intf->dev, "\n");
781 buffer_list = &dev->rx_buffer_list;
783 buffer_list = &dev->tx_buffer_list;
785 spin_lock_irqsave(&dev->buffer_list_lock, flags);
787 spin_unlock_irqrestore(&dev->buffer_list_lock, flags);
792 struct hackrf_dev *dev = vb2_get_drv_priv(vq);
793 struct usb_interface *intf = dev->intf;
797 dev_dbg(&intf->dev, "count=%i\n", count);
799 mutex_lock(&dev->v4l2_lock);
803 if (test_bit(TX_ON, &dev->flags)) {
809 set_bit(RX_ON, &dev->flags);
811 if (test_bit(RX_ON, &dev->flags)) {
817 set_bit(TX_ON, &dev->flags);
820 dev->sequence = 0;
822 ret = hackrf_alloc_stream_bufs(dev);
826 ret = hackrf_alloc_urbs(dev, (mode == 1));
830 ret = hackrf_submit_urbs(dev);
834 ret = hackrf_set_params(dev);
839 ret = hackrf_ctrl_msg(dev, CMD_SET_TRANSCEIVER_MODE, mode, 0, NULL, 0);
843 mutex_unlock(&dev->v4l2_lock);
847 hackrf_kill_urbs(dev);
848 hackrf_free_urbs(dev);
849 hackrf_free_stream_bufs(dev);
850 clear_bit(RX_ON, &dev->flags);
851 clear_bit(TX_ON, &dev->flags);
854 mutex_unlock(&dev->v4l2_lock);
855 dev_dbg(&intf->dev, "failed=%d\n", ret);
861 struct hackrf_dev *dev = vb2_get_drv_priv(vq);
862 struct usb_interface *intf = dev->intf;
864 dev_dbg(&intf->dev, "\n");
866 mutex_lock(&dev->v4l2_lock);
869 hackrf_ctrl_msg(dev, CMD_SET_TRANSCEIVER_MODE, 0, 0, NULL, 0);
871 hackrf_kill_urbs(dev);
872 hackrf_free_urbs(dev);
873 hackrf_free_stream_bufs(dev);
878 clear_bit(RX_ON, &dev->flags);
880 clear_bit(TX_ON, &dev->flags);
882 mutex_unlock(&dev->v4l2_lock);
897 struct hackrf_dev *dev = video_drvdata(file);
898 struct usb_interface *intf = dev->intf;
900 dev_dbg(&intf->dev, "\n");
907 strscpy(cap->card, dev->rx_vdev.name, sizeof(cap->card));
908 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
916 struct hackrf_dev *dev = video_drvdata(file);
921 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
925 q = &dev->rx_vb2_queue;
927 q = &dev->tx_vb2_queue;
934 dev->pixelformat = formats[i].pixelformat;
935 dev->buffersize = formats[i].buffersize;
941 dev->pixelformat = formats[0].pixelformat;
942 dev->buffersize = formats[0].buffersize;
952 struct hackrf_dev *dev = video_drvdata(file);
954 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
955 (char *)&dev->pixelformat);
957 f->fmt.sdr.pixelformat = dev->pixelformat;
958 f->fmt.sdr.buffersize = dev->buffersize;
966 struct hackrf_dev *dev = video_drvdata(file);
969 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
988 struct hackrf_dev *dev = video_drvdata(file);
990 dev_dbg(dev->dev, "index=%d\n", f->index);
1003 struct hackrf_dev *dev = video_drvdata(file);
1006 dev_dbg(dev->dev, "index=%d\n", v->index);
1020 struct hackrf_dev *dev = video_drvdata(file);
1023 dev_dbg(dev->dev, "index=%d\n", v->index);
1049 struct hackrf_dev *dev = video_drvdata(file);
1051 dev_dbg(dev->dev, "index=%d\n", a->index);
1059 struct hackrf_dev *dev = video_drvdata(file);
1062 dev_dbg(dev->dev, "index=%d\n", a->index);
1088 struct hackrf_dev *dev = video_drvdata(file);
1089 struct usb_interface *intf = dev->intf;
1094 dev_dbg(&intf->dev, "tuner=%d type=%d frequency=%u\n",
1101 dev->f_adc = uitmp;
1102 set_bit(RX_ADC_FREQUENCY, &dev->flags);
1104 dev->f_dac = uitmp;
1105 set_bit(TX_DAC_FREQUENCY, &dev->flags);
1111 dev->f_rx = uitmp;
1112 set_bit(RX_RF_FREQUENCY, &dev->flags);
1114 dev->f_tx = uitmp;
1115 set_bit(TX_RF_FREQUENCY, &dev->flags);
1122 ret = hackrf_set_params(dev);
1128 dev_dbg(&intf->dev, "failed=%d\n", ret);
1135 struct hackrf_dev *dev = video_drvdata(file);
1136 struct usb_interface *intf = dev->intf;
1140 dev_dbg(dev->dev, "tuner=%d type=%d\n", f->tuner, f->type);
1145 f->frequency = dev->f_adc;
1147 f->frequency = dev->f_dac;
1151 f->frequency = dev->f_rx;
1153 f->frequency = dev->f_tx;
1161 dev_dbg(&intf->dev, "failed=%d\n", ret);
1168 struct hackrf_dev *dev = video_drvdata(file);
1171 dev_dbg(dev->dev, "tuner=%d type=%d index=%d\n",
1254 struct hackrf_dev *dev = container_of(v, struct hackrf_dev, v4l2_dev);
1256 dev_dbg(dev->dev, "\n");
1258 v4l2_ctrl_handler_free(&dev->rx_ctrl_handler);
1259 v4l2_ctrl_handler_free(&dev->tx_ctrl_handler);
1260 v4l2_device_unregister(&dev->v4l2_dev);
1261 kfree(dev);
1266 struct hackrf_dev *dev = container_of(ctrl->handler,
1268 struct usb_interface *intf = dev->intf;
1274 set_bit(RX_BANDWIDTH, &dev->flags);
1277 set_bit(RX_RF_GAIN, &dev->flags);
1280 set_bit(RX_LNA_GAIN, &dev->flags);
1283 set_bit(RX_IF_GAIN, &dev->flags);
1286 dev_dbg(&intf->dev, "unknown ctrl: id=%d name=%s\n",
1292 ret = hackrf_set_params(dev);
1298 dev_dbg(&intf->dev, "failed=%d\n", ret);
1304 struct hackrf_dev *dev = container_of(ctrl->handler,
1306 struct usb_interface *intf = dev->intf;
1312 set_bit(TX_BANDWIDTH, &dev->flags);
1315 set_bit(TX_LNA_GAIN, &dev->flags);
1318 set_bit(TX_RF_GAIN, &dev->flags);
1321 dev_dbg(&intf->dev, "unknown ctrl: id=%d name=%s\n",
1327 ret = hackrf_set_params(dev);
1333 dev_dbg(&intf->dev, "failed=%d\n", ret);
1348 struct hackrf_dev *dev;
1352 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1353 if (!dev) {
1358 mutex_init(&dev->v4l2_lock);
1359 mutex_init(&dev->vb_queue_lock);
1360 spin_lock_init(&dev->buffer_list_lock);
1361 INIT_LIST_HEAD(&dev->rx_buffer_list);
1362 INIT_LIST_HEAD(&dev->tx_buffer_list);
1363 dev->intf = intf;
1364 dev->dev = &intf->dev;
1365 dev->udev = interface_to_usbdev(intf);
1366 dev->pixelformat = formats[0].pixelformat;
1367 dev->buffersize = formats[0].buffersize;
1368 dev->f_adc = bands_adc_dac[0].rangelow;
1369 dev->f_dac = bands_adc_dac[0].rangelow;
1370 dev->f_rx = bands_rx_tx[0].rangelow;
1371 dev->f_tx = bands_rx_tx[0].rangelow;
1372 set_bit(RX_ADC_FREQUENCY, &dev->flags);
1373 set_bit(TX_DAC_FREQUENCY, &dev->flags);
1374 set_bit(RX_RF_FREQUENCY, &dev->flags);
1375 set_bit(TX_RF_FREQUENCY, &dev->flags);
1378 ret = hackrf_ctrl_msg(dev, CMD_BOARD_ID_READ, 0, 0, &u8tmp, 1);
1380 ret = hackrf_ctrl_msg(dev, CMD_VERSION_STRING_READ, 0, 0,
1383 dev_err(dev->dev, "Could not detect board\n");
1388 dev_info(dev->dev, "Board ID: %02x\n", u8tmp);
1389 dev_info(dev->dev, "Firmware version: %s\n", buf);
1392 dev->rx_vb2_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1393 dev->rx_vb2_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF |
1395 dev->rx_vb2_queue.ops = &hackrf_vb2_ops;
1396 dev->rx_vb2_queue.mem_ops = &vb2_vmalloc_memops;
1397 dev->rx_vb2_queue.drv_priv = dev;
1398 dev->rx_vb2_queue.buf_struct_size = sizeof(struct hackrf_buffer);
1399 dev->rx_vb2_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1400 ret = vb2_queue_init(&dev->rx_vb2_queue);
1402 dev_err(dev->dev, "Could not initialize rx vb2 queue\n");
1407 dev->tx_vb2_queue.type = V4L2_BUF_TYPE_SDR_OUTPUT;
1408 dev->tx_vb2_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF |
1410 dev->tx_vb2_queue.ops = &hackrf_vb2_ops;
1411 dev->tx_vb2_queue.mem_ops = &vb2_vmalloc_memops;
1412 dev->tx_vb2_queue.drv_priv = dev;
1413 dev->tx_vb2_queue.buf_struct_size = sizeof(struct hackrf_buffer);
1414 dev->tx_vb2_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1415 ret = vb2_queue_init(&dev->tx_vb2_queue);
1417 dev_err(dev->dev, "Could not initialize tx vb2 queue\n");
1422 v4l2_ctrl_handler_init(&dev->rx_ctrl_handler, 5);
1423 dev->rx_bandwidth_auto = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1426 dev->rx_bandwidth = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1429 v4l2_ctrl_auto_cluster(2, &dev->rx_bandwidth_auto, 0, false);
1430 dev->rx_rf_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1432 dev->rx_lna_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1434 dev->rx_if_gain = v4l2_ctrl_new_std(&dev->rx_ctrl_handler,
1436 if (dev->rx_ctrl_handler.error) {
1437 ret = dev->rx_ctrl_handler.error;
1438 dev_err(dev->dev, "Could not initialize controls\n");
1441 v4l2_ctrl_grab(dev->rx_rf_gain, !hackrf_enable_rf_gain_ctrl);
1442 v4l2_ctrl_handler_setup(&dev->rx_ctrl_handler);
1445 v4l2_ctrl_handler_init(&dev->tx_ctrl_handler, 4);
1446 dev->tx_bandwidth_auto = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1449 dev->tx_bandwidth = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1452 v4l2_ctrl_auto_cluster(2, &dev->tx_bandwidth_auto, 0, false);
1453 dev->tx_lna_gain = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1455 dev->tx_rf_gain = v4l2_ctrl_new_std(&dev->tx_ctrl_handler,
1457 if (dev->tx_ctrl_handler.error) {
1458 ret = dev->tx_ctrl_handler.error;
1459 dev_err(dev->dev, "Could not initialize controls\n");
1462 v4l2_ctrl_grab(dev->tx_rf_gain, !hackrf_enable_rf_gain_ctrl);
1463 v4l2_ctrl_handler_setup(&dev->tx_ctrl_handler);
1466 dev->v4l2_dev.release = hackrf_video_release;
1467 ret = v4l2_device_register(&intf->dev, &dev->v4l2_dev);
1469 dev_err(dev->dev, "Failed to register v4l2-device (%d)\n", ret);
1474 dev->rx_vdev = hackrf_template;
1475 dev->rx_vdev.queue = &dev->rx_vb2_queue;
1476 dev->rx_vdev.queue->lock = &dev->vb_queue_lock;
1477 dev->rx_vdev.v4l2_dev = &dev->v4l2_dev;
1478 dev->rx_vdev.ctrl_handler = &dev->rx_ctrl_handler;
1479 dev->rx_vdev.lock = &dev->v4l2_lock;
1480 dev->rx_vdev.vfl_dir = VFL_DIR_RX;
1481 dev->rx_vdev.device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
1483 video_set_drvdata(&dev->rx_vdev, dev);
1484 ret = video_register_device(&dev->rx_vdev, VFL_TYPE_SDR, -1);
1486 dev_err(dev->dev,
1490 dev_info(dev->dev, "Registered as %s\n",
1491 video_device_node_name(&dev->rx_vdev));
1494 dev->tx_vdev = hackrf_template;
1495 dev->tx_vdev.queue = &dev->tx_vb2_queue;
1496 dev->tx_vdev.queue->lock = &dev->vb_queue_lock;
1497 dev->tx_vdev.v4l2_dev = &dev->v4l2_dev;
1498 dev->tx_vdev.ctrl_handler = &dev->tx_ctrl_handler;
1499 dev->tx_vdev.lock = &dev->v4l2_lock;
1500 dev->tx_vdev.vfl_dir = VFL_DIR_TX;
1501 dev->tx_vdev.device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE |
1503 video_set_drvdata(&dev->tx_vdev, dev);
1504 ret = video_register_device(&dev->tx_vdev, VFL_TYPE_SDR, -1);
1506 dev_err(dev->dev,
1510 dev_info(dev->dev, "Registered as %s\n",
1511 video_device_node_name(&dev->tx_vdev));
1513 dev_notice(dev->dev, "SDR API is still slightly experimental and functionality changes may follow\n");
1516 video_unregister_device(&dev->rx_vdev);
1518 v4l2_device_unregister(&dev->v4l2_dev);
1520 v4l2_ctrl_handler_free(&dev->tx_ctrl_handler);
1522 v4l2_ctrl_handler_free(&dev->rx_ctrl_handler);
1524 kfree(dev);
1526 dev_dbg(&intf->dev, "failed=%d\n", ret);