1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Mirics MSi2500 driver 4 * Mirics MSi3101 SDR Dongle driver 5 * 6 * Copyright (C) 2013 Antti Palosaari <crope@iki.fi> 7 * 8 * That driver is somehow based of pwc driver: 9 * (C) 1999-2004 Nemosoft Unv. 10 * (C) 2004-2006 Luc Saillard (luc@saillard.org) 11 * (C) 2011 Hans de Goede <hdegoede@redhat.com> 12 */ 13 14 #include <linux/module.h> 15 #include <linux/slab.h> 16 #include <asm/div64.h> 17 #include <media/v4l2-device.h> 18 #include <media/v4l2-ioctl.h> 19 #include <media/v4l2-ctrls.h> 20 #include <media/v4l2-event.h> 21 #include <linux/usb.h> 22 #include <media/videobuf2-v4l2.h> 23 #include <media/videobuf2-vmalloc.h> 24 #include <linux/spi/spi.h> 25 26 static bool msi2500_emulated_fmt; 27 module_param_named(emulated_formats, msi2500_emulated_fmt, bool, 0644); 28 MODULE_PARM_DESC(emulated_formats, "enable emulated formats (disappears in future)"); 29 30 /* 31 * iConfiguration 0 32 * bInterfaceNumber 0 33 * bAlternateSetting 1 34 * bNumEndpoints 1 35 * bEndpointAddress 0x81 EP 1 IN 36 * bmAttributes 1 37 * Transfer Type Isochronous 38 * wMaxPacketSize 0x1400 3x 1024 bytes 39 * bInterval 1 40 */ 41 #define MAX_ISO_BUFS (8) 42 #define ISO_FRAMES_PER_DESC (8) 43 #define ISO_MAX_FRAME_SIZE (3 * 1024) 44 #define ISO_BUFFER_SIZE (ISO_FRAMES_PER_DESC * ISO_MAX_FRAME_SIZE) 45 #define MAX_ISOC_ERRORS 20 46 47 /* 48 * TODO: These formats should be moved to V4L2 API. Formats are currently 49 * disabled from formats[] table, not visible to userspace. 50 */ 51 /* signed 12-bit */ 52 #define MSI2500_PIX_FMT_SDR_S12 v4l2_fourcc('D', 'S', '1', '2') 53 /* Mirics MSi2500 format 384 */ 54 #define MSI2500_PIX_FMT_SDR_MSI2500_384 v4l2_fourcc('M', '3', '8', '4') 55 56 static const struct v4l2_frequency_band bands[] = { 57 { 58 .tuner = 0, 59 .type = V4L2_TUNER_ADC, 60 .index = 0, 61 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS, 62 .rangelow = 1200000, 63 .rangehigh = 15000000, 64 }, 65 }; 66 67 /* stream formats */ 68 struct msi2500_format { 69 u32 pixelformat; 70 u32 buffersize; 71 }; 72 73 /* format descriptions for capture and preview */ 74 static struct msi2500_format formats[] = { 75 { 76 .pixelformat = V4L2_SDR_FMT_CS8, 77 .buffersize = 3 * 1008, 78 #if 0 79 }, { 80 .pixelformat = MSI2500_PIX_FMT_SDR_MSI2500_384, 81 }, { 82 .pixelformat = MSI2500_PIX_FMT_SDR_S12, 83 #endif 84 }, { 85 .pixelformat = V4L2_SDR_FMT_CS14LE, 86 .buffersize = 3 * 1008, 87 }, { 88 .pixelformat = V4L2_SDR_FMT_CU8, 89 .buffersize = 3 * 1008, 90 }, { 91 .pixelformat = V4L2_SDR_FMT_CU16LE, 92 .buffersize = 3 * 1008, 93 }, 94 }; 95 96 static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats); 97 98 /* intermediate buffers with raw data from the USB device */ 99 struct msi2500_frame_buf { 100 /* common v4l buffer stuff -- must be first */ 101 struct vb2_v4l2_buffer vb; 102 struct list_head list; 103 }; 104 105 struct msi2500_dev { 106 struct device *dev; 107 struct video_device vdev; 108 struct v4l2_device v4l2_dev; 109 struct v4l2_subdev *v4l2_subdev; 110 struct spi_master *master; 111 112 /* videobuf2 queue and queued buffers list */ 113 struct vb2_queue vb_queue; 114 struct list_head queued_bufs; 115 spinlock_t queued_bufs_lock; /* Protects queued_bufs */ 116 117 /* Note if taking both locks v4l2_lock must always be locked first! */ 118 struct mutex v4l2_lock; /* Protects everything else */ 119 struct mutex vb_queue_lock; /* Protects vb_queue and capt_file */ 120 121 /* Pointer to our usb_device, will be NULL after unplug */ 122 struct usb_device *udev; /* Both mutexes most be hold when setting! */ 123 124 unsigned int f_adc; 125 u32 pixelformat; 126 u32 buffersize; 127 unsigned int num_formats; 128 129 unsigned int isoc_errors; /* number of contiguous ISOC errors */ 130 unsigned int vb_full; /* vb is full and packets dropped */ 131 132 struct urb *urbs[MAX_ISO_BUFS]; 133 134 /* Controls */ 135 struct v4l2_ctrl_handler hdl; 136 137 u32 next_sample; /* for track lost packets */ 138 u32 sample; /* for sample rate calc */ 139 unsigned long jiffies_next; 140 }; 141 142 /* Private functions */ 143 static struct msi2500_frame_buf *msi2500_get_next_fill_buf( 144 struct msi2500_dev *dev) 145 { 146 unsigned long flags; 147 struct msi2500_frame_buf *buf = NULL; 148 149 spin_lock_irqsave(&dev->queued_bufs_lock, flags); 150 if (list_empty(&dev->queued_bufs)) 151 goto leave; 152 153 buf = list_entry(dev->queued_bufs.next, struct msi2500_frame_buf, list); 154 list_del(&buf->list); 155 leave: 156 spin_unlock_irqrestore(&dev->queued_bufs_lock, flags); 157 return buf; 158 } 159 160 /* 161 * +=========================================================================== 162 * | 00-1023 | USB packet type '504' 163 * +=========================================================================== 164 * | 00- 03 | sequence number of first sample in that USB packet 165 * +--------------------------------------------------------------------------- 166 * | 04- 15 | garbage 167 * +--------------------------------------------------------------------------- 168 * | 16-1023 | samples 169 * +--------------------------------------------------------------------------- 170 * signed 8-bit sample 171 * 504 * 2 = 1008 samples 172 * 173 * 174 * +=========================================================================== 175 * | 00-1023 | USB packet type '384' 176 * +=========================================================================== 177 * | 00- 03 | sequence number of first sample in that USB packet 178 * +--------------------------------------------------------------------------- 179 * | 04- 15 | garbage 180 * +--------------------------------------------------------------------------- 181 * | 16- 175 | samples 182 * +--------------------------------------------------------------------------- 183 * | 176- 179 | control bits for previous samples 184 * +--------------------------------------------------------------------------- 185 * | 180- 339 | samples 186 * +--------------------------------------------------------------------------- 187 * | 340- 343 | control bits for previous samples 188 * +--------------------------------------------------------------------------- 189 * | 344- 503 | samples 190 * +--------------------------------------------------------------------------- 191 * | 504- 507 | control bits for previous samples 192 * +--------------------------------------------------------------------------- 193 * | 508- 667 | samples 194 * +--------------------------------------------------------------------------- 195 * | 668- 671 | control bits for previous samples 196 * +--------------------------------------------------------------------------- 197 * | 672- 831 | samples 198 * +--------------------------------------------------------------------------- 199 * | 832- 835 | control bits for previous samples 200 * +--------------------------------------------------------------------------- 201 * | 836- 995 | samples 202 * +--------------------------------------------------------------------------- 203 * | 996- 999 | control bits for previous samples 204 * +--------------------------------------------------------------------------- 205 * | 1000-1023 | garbage 206 * +--------------------------------------------------------------------------- 207 * 208 * Bytes 4 - 7 could have some meaning? 209 * 210 * Control bits for previous samples is 32-bit field, containing 16 x 2-bit 211 * numbers. This results one 2-bit number for 8 samples. It is likely used for 212 * bit shifting sample by given bits, increasing actual sampling resolution. 213 * Number 2 (0b10) was never seen. 214 * 215 * 6 * 16 * 2 * 4 = 768 samples. 768 * 4 = 3072 bytes 216 * 217 * 218 * +=========================================================================== 219 * | 00-1023 | USB packet type '336' 220 * +=========================================================================== 221 * | 00- 03 | sequence number of first sample in that USB packet 222 * +--------------------------------------------------------------------------- 223 * | 04- 15 | garbage 224 * +--------------------------------------------------------------------------- 225 * | 16-1023 | samples 226 * +--------------------------------------------------------------------------- 227 * signed 12-bit sample 228 * 229 * 230 * +=========================================================================== 231 * | 00-1023 | USB packet type '252' 232 * +=========================================================================== 233 * | 00- 03 | sequence number of first sample in that USB packet 234 * +--------------------------------------------------------------------------- 235 * | 04- 15 | garbage 236 * +--------------------------------------------------------------------------- 237 * | 16-1023 | samples 238 * +--------------------------------------------------------------------------- 239 * signed 14-bit sample 240 */ 241 242 static int msi2500_convert_stream(struct msi2500_dev *dev, u8 *dst, u8 *src, 243 unsigned int src_len) 244 { 245 unsigned int i, j, transactions, dst_len = 0; 246 u32 sample[3]; 247 248 /* There could be 1-3 1024 byte transactions per packet */ 249 transactions = src_len / 1024; 250 251 for (i = 0; i < transactions; i++) { 252 sample[i] = src[3] << 24 | src[2] << 16 | src[1] << 8 | 253 src[0] << 0; 254 if (i == 0 && dev->next_sample != sample[0]) { 255 dev_dbg_ratelimited(dev->dev, 256 "%d samples lost, %d %08x:%08x\n", 257 sample[0] - dev->next_sample, 258 src_len, dev->next_sample, 259 sample[0]); 260 } 261 262 /* 263 * Dump all unknown 'garbage' data - maybe we will discover 264 * someday if there is something rational... 265 */ 266 dev_dbg_ratelimited(dev->dev, "%*ph\n", 12, &src[4]); 267 268 src += 16; /* skip header */ 269 270 switch (dev->pixelformat) { 271 case V4L2_SDR_FMT_CU8: /* 504 x IQ samples */ 272 { 273 s8 *s8src = (s8 *)src; 274 u8 *u8dst = (u8 *)dst; 275 276 for (j = 0; j < 1008; j++) 277 *u8dst++ = *s8src++ + 128; 278 279 src += 1008; 280 dst += 1008; 281 dst_len += 1008; 282 dev->next_sample = sample[i] + 504; 283 break; 284 } 285 case V4L2_SDR_FMT_CU16LE: /* 252 x IQ samples */ 286 { 287 s16 *s16src = (s16 *)src; 288 u16 *u16dst = (u16 *)dst; 289 struct {signed int x:14; } se; /* sign extension */ 290 unsigned int utmp; 291 292 for (j = 0; j < 1008; j += 2) { 293 /* sign extension from 14-bit to signed int */ 294 se.x = *s16src++; 295 /* from signed int to unsigned int */ 296 utmp = se.x + 8192; 297 /* from 14-bit to 16-bit */ 298 *u16dst++ = utmp << 2 | utmp >> 12; 299 } 300 301 src += 1008; 302 dst += 1008; 303 dst_len += 1008; 304 dev->next_sample = sample[i] + 252; 305 break; 306 } 307 case MSI2500_PIX_FMT_SDR_MSI2500_384: /* 384 x IQ samples */ 308 /* Dump unknown 'garbage' data */ 309 dev_dbg_ratelimited(dev->dev, "%*ph\n", 24, &src[1000]); 310 memcpy(dst, src, 984); 311 src += 984 + 24; 312 dst += 984; 313 dst_len += 984; 314 dev->next_sample = sample[i] + 384; 315 break; 316 case V4L2_SDR_FMT_CS8: /* 504 x IQ samples */ 317 memcpy(dst, src, 1008); 318 src += 1008; 319 dst += 1008; 320 dst_len += 1008; 321 dev->next_sample = sample[i] + 504; 322 break; 323 case MSI2500_PIX_FMT_SDR_S12: /* 336 x IQ samples */ 324 memcpy(dst, src, 1008); 325 src += 1008; 326 dst += 1008; 327 dst_len += 1008; 328 dev->next_sample = sample[i] + 336; 329 break; 330 case V4L2_SDR_FMT_CS14LE: /* 252 x IQ samples */ 331 memcpy(dst, src, 1008); 332 src += 1008; 333 dst += 1008; 334 dst_len += 1008; 335 dev->next_sample = sample[i] + 252; 336 break; 337 default: 338 break; 339 } 340 } 341 342 /* calculate sample rate and output it in 10 seconds intervals */ 343 if (unlikely(time_is_before_jiffies(dev->jiffies_next))) { 344 #define MSECS 10000UL 345 unsigned int msecs = jiffies_to_msecs(jiffies - 346 dev->jiffies_next + msecs_to_jiffies(MSECS)); 347 unsigned int samples = dev->next_sample - dev->sample; 348 349 dev->jiffies_next = jiffies + msecs_to_jiffies(MSECS); 350 dev->sample = dev->next_sample; 351 dev_dbg(dev->dev, "size=%u samples=%u msecs=%u sample rate=%lu\n", 352 src_len, samples, msecs, 353 samples * 1000UL / msecs); 354 } 355 356 return dst_len; 357 } 358 359 /* 360 * This gets called for the Isochronous pipe (stream). This is done in interrupt 361 * time, so it has to be fast, not crash, and not stall. Neat. 362 */ 363 static void msi2500_isoc_handler(struct urb *urb) 364 { 365 struct msi2500_dev *dev = (struct msi2500_dev *)urb->context; 366 int i, flen, fstatus; 367 unsigned char *iso_buf = NULL; 368 struct msi2500_frame_buf *fbuf; 369 370 if (unlikely(urb->status == -ENOENT || 371 urb->status == -ECONNRESET || 372 urb->status == -ESHUTDOWN)) { 373 dev_dbg(dev->dev, "URB (%p) unlinked %ssynchronously\n", 374 urb, urb->status == -ENOENT ? "" : "a"); 375 return; 376 } 377 378 if (unlikely(urb->status != 0)) { 379 dev_dbg(dev->dev, "called with status %d\n", urb->status); 380 /* Give up after a number of contiguous errors */ 381 if (++dev->isoc_errors > MAX_ISOC_ERRORS) 382 dev_dbg(dev->dev, "Too many ISOC errors, bailing out\n"); 383 goto handler_end; 384 } else { 385 /* Reset ISOC error counter. We did get here, after all. */ 386 dev->isoc_errors = 0; 387 } 388 389 /* Compact data */ 390 for (i = 0; i < urb->number_of_packets; i++) { 391 void *ptr; 392 393 /* Check frame error */ 394 fstatus = urb->iso_frame_desc[i].status; 395 if (unlikely(fstatus)) { 396 dev_dbg_ratelimited(dev->dev, 397 "frame=%d/%d has error %d skipping\n", 398 i, urb->number_of_packets, fstatus); 399 continue; 400 } 401 402 /* Check if that frame contains data */ 403 flen = urb->iso_frame_desc[i].actual_length; 404 if (unlikely(flen == 0)) 405 continue; 406 407 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset; 408 409 /* Get free framebuffer */ 410 fbuf = msi2500_get_next_fill_buf(dev); 411 if (unlikely(fbuf == NULL)) { 412 dev->vb_full++; 413 dev_dbg_ratelimited(dev->dev, 414 "video buffer is full, %d packets dropped\n", 415 dev->vb_full); 416 continue; 417 } 418 419 /* fill framebuffer */ 420 ptr = vb2_plane_vaddr(&fbuf->vb.vb2_buf, 0); 421 flen = msi2500_convert_stream(dev, ptr, iso_buf, flen); 422 vb2_set_plane_payload(&fbuf->vb.vb2_buf, 0, flen); 423 vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE); 424 } 425 426 handler_end: 427 i = usb_submit_urb(urb, GFP_ATOMIC); 428 if (unlikely(i != 0)) 429 dev_dbg(dev->dev, "Error (%d) re-submitting urb\n", i); 430 } 431 432 static void msi2500_iso_stop(struct msi2500_dev *dev) 433 { 434 int i; 435 436 dev_dbg(dev->dev, "\n"); 437 438 /* Unlinking ISOC buffers one by one */ 439 for (i = 0; i < MAX_ISO_BUFS; i++) { 440 if (dev->urbs[i]) { 441 dev_dbg(dev->dev, "Unlinking URB %p\n", dev->urbs[i]); 442 usb_kill_urb(dev->urbs[i]); 443 } 444 } 445 } 446 447 static void msi2500_iso_free(struct msi2500_dev *dev) 448 { 449 int i; 450 451 dev_dbg(dev->dev, "\n"); 452 453 /* Freeing ISOC buffers one by one */ 454 for (i = 0; i < MAX_ISO_BUFS; i++) { 455 if (dev->urbs[i]) { 456 dev_dbg(dev->dev, "Freeing URB\n"); 457 if (dev->urbs[i]->transfer_buffer) { 458 usb_free_coherent(dev->udev, 459 dev->urbs[i]->transfer_buffer_length, 460 dev->urbs[i]->transfer_buffer, 461 dev->urbs[i]->transfer_dma); 462 } 463 usb_free_urb(dev->urbs[i]); 464 dev->urbs[i] = NULL; 465 } 466 } 467 } 468 469 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */ 470 static void msi2500_isoc_cleanup(struct msi2500_dev *dev) 471 { 472 dev_dbg(dev->dev, "\n"); 473 474 msi2500_iso_stop(dev); 475 msi2500_iso_free(dev); 476 } 477 478 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */ 479 static int msi2500_isoc_init(struct msi2500_dev *dev) 480 { 481 struct urb *urb; 482 int i, j, ret; 483 484 dev_dbg(dev->dev, "\n"); 485 486 dev->isoc_errors = 0; 487 488 ret = usb_set_interface(dev->udev, 0, 1); 489 if (ret) 490 return ret; 491 492 /* Allocate and init Isochronuous urbs */ 493 for (i = 0; i < MAX_ISO_BUFS; i++) { 494 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL); 495 if (urb == NULL) { 496 msi2500_isoc_cleanup(dev); 497 return -ENOMEM; 498 } 499 dev->urbs[i] = urb; 500 dev_dbg(dev->dev, "Allocated URB at 0x%p\n", urb); 501 502 urb->interval = 1; 503 urb->dev = dev->udev; 504 urb->pipe = usb_rcvisocpipe(dev->udev, 0x81); 505 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 506 urb->transfer_buffer = usb_alloc_coherent(dev->udev, 507 ISO_BUFFER_SIZE, 508 GFP_KERNEL, &urb->transfer_dma); 509 if (urb->transfer_buffer == NULL) { 510 dev_err(dev->dev, 511 "Failed to allocate urb buffer %d\n", i); 512 msi2500_isoc_cleanup(dev); 513 return -ENOMEM; 514 } 515 urb->transfer_buffer_length = ISO_BUFFER_SIZE; 516 urb->complete = msi2500_isoc_handler; 517 urb->context = dev; 518 urb->start_frame = 0; 519 urb->number_of_packets = ISO_FRAMES_PER_DESC; 520 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) { 521 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE; 522 urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE; 523 } 524 } 525 526 /* link */ 527 for (i = 0; i < MAX_ISO_BUFS; i++) { 528 ret = usb_submit_urb(dev->urbs[i], GFP_KERNEL); 529 if (ret) { 530 dev_err(dev->dev, 531 "usb_submit_urb %d failed with error %d\n", 532 i, ret); 533 msi2500_isoc_cleanup(dev); 534 return ret; 535 } 536 dev_dbg(dev->dev, "URB 0x%p submitted.\n", dev->urbs[i]); 537 } 538 539 /* All is done... */ 540 return 0; 541 } 542 543 /* Must be called with vb_queue_lock hold */ 544 static void msi2500_cleanup_queued_bufs(struct msi2500_dev *dev) 545 { 546 unsigned long flags; 547 548 dev_dbg(dev->dev, "\n"); 549 550 spin_lock_irqsave(&dev->queued_bufs_lock, flags); 551 while (!list_empty(&dev->queued_bufs)) { 552 struct msi2500_frame_buf *buf; 553 554 buf = list_entry(dev->queued_bufs.next, 555 struct msi2500_frame_buf, list); 556 list_del(&buf->list); 557 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 558 } 559 spin_unlock_irqrestore(&dev->queued_bufs_lock, flags); 560 } 561 562 /* The user yanked out the cable... */ 563 static void msi2500_disconnect(struct usb_interface *intf) 564 { 565 struct v4l2_device *v = usb_get_intfdata(intf); 566 struct msi2500_dev *dev = 567 container_of(v, struct msi2500_dev, v4l2_dev); 568 569 dev_dbg(dev->dev, "\n"); 570 571 mutex_lock(&dev->vb_queue_lock); 572 mutex_lock(&dev->v4l2_lock); 573 /* No need to keep the urbs around after disconnection */ 574 dev->udev = NULL; 575 v4l2_device_disconnect(&dev->v4l2_dev); 576 video_unregister_device(&dev->vdev); 577 spi_unregister_master(dev->master); 578 mutex_unlock(&dev->v4l2_lock); 579 mutex_unlock(&dev->vb_queue_lock); 580 581 v4l2_device_put(&dev->v4l2_dev); 582 } 583 584 static int msi2500_querycap(struct file *file, void *fh, 585 struct v4l2_capability *cap) 586 { 587 struct msi2500_dev *dev = video_drvdata(file); 588 589 dev_dbg(dev->dev, "\n"); 590 591 strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver)); 592 strscpy(cap->card, dev->vdev.name, sizeof(cap->card)); 593 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 594 return 0; 595 } 596 597 /* Videobuf2 operations */ 598 static int msi2500_queue_setup(struct vb2_queue *vq, 599 unsigned int *nbuffers, 600 unsigned int *nplanes, unsigned int sizes[], 601 struct device *alloc_devs[]) 602 { 603 struct msi2500_dev *dev = vb2_get_drv_priv(vq); 604 605 dev_dbg(dev->dev, "nbuffers=%d\n", *nbuffers); 606 607 /* Absolute min and max number of buffers available for mmap() */ 608 *nbuffers = clamp_t(unsigned int, *nbuffers, 8, 32); 609 *nplanes = 1; 610 sizes[0] = PAGE_ALIGN(dev->buffersize); 611 dev_dbg(dev->dev, "nbuffers=%d sizes[0]=%d\n", *nbuffers, sizes[0]); 612 return 0; 613 } 614 615 static void msi2500_buf_queue(struct vb2_buffer *vb) 616 { 617 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 618 struct msi2500_dev *dev = vb2_get_drv_priv(vb->vb2_queue); 619 struct msi2500_frame_buf *buf = container_of(vbuf, 620 struct msi2500_frame_buf, 621 vb); 622 unsigned long flags; 623 624 /* Check the device has not disconnected between prep and queuing */ 625 if (unlikely(!dev->udev)) { 626 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 627 return; 628 } 629 630 spin_lock_irqsave(&dev->queued_bufs_lock, flags); 631 list_add_tail(&buf->list, &dev->queued_bufs); 632 spin_unlock_irqrestore(&dev->queued_bufs_lock, flags); 633 } 634 635 #define CMD_WREG 0x41 636 #define CMD_START_STREAMING 0x43 637 #define CMD_STOP_STREAMING 0x45 638 #define CMD_READ_UNKNOWN 0x48 639 640 #define msi2500_dbg_usb_control_msg(_dev, _r, _t, _v, _i, _b, _l) { \ 641 char *_direction; \ 642 if (_t & USB_DIR_IN) \ 643 _direction = "<<<"; \ 644 else \ 645 _direction = ">>>"; \ 646 dev_dbg(_dev, "%02x %02x %02x %02x %02x %02x %02x %02x %s %*ph\n", \ 647 _t, _r, _v & 0xff, _v >> 8, _i & 0xff, _i >> 8, \ 648 _l & 0xff, _l >> 8, _direction, _l, _b); \ 649 } 650 651 static int msi2500_ctrl_msg(struct msi2500_dev *dev, u8 cmd, u32 data) 652 { 653 int ret; 654 u8 request = cmd; 655 u8 requesttype = USB_DIR_OUT | USB_TYPE_VENDOR; 656 u16 value = (data >> 0) & 0xffff; 657 u16 index = (data >> 16) & 0xffff; 658 659 msi2500_dbg_usb_control_msg(dev->dev, request, requesttype, 660 value, index, NULL, 0); 661 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), request, 662 requesttype, value, index, NULL, 0, 2000); 663 if (ret) 664 dev_err(dev->dev, "failed %d, cmd %02x, data %04x\n", 665 ret, cmd, data); 666 667 return ret; 668 } 669 670 static int msi2500_set_usb_adc(struct msi2500_dev *dev) 671 { 672 int ret; 673 unsigned int f_vco, f_sr, div_n, k, k_cw, div_out; 674 u32 reg3, reg4, reg7; 675 struct v4l2_ctrl *bandwidth_auto; 676 struct v4l2_ctrl *bandwidth; 677 678 f_sr = dev->f_adc; 679 680 /* set tuner, subdev, filters according to sampling rate */ 681 bandwidth_auto = v4l2_ctrl_find(&dev->hdl, 682 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO); 683 if (v4l2_ctrl_g_ctrl(bandwidth_auto)) { 684 bandwidth = v4l2_ctrl_find(&dev->hdl, 685 V4L2_CID_RF_TUNER_BANDWIDTH); 686 v4l2_ctrl_s_ctrl(bandwidth, dev->f_adc); 687 } 688 689 /* select stream format */ 690 switch (dev->pixelformat) { 691 case V4L2_SDR_FMT_CU8: 692 reg7 = 0x000c9407; /* 504 */ 693 break; 694 case V4L2_SDR_FMT_CU16LE: 695 reg7 = 0x00009407; /* 252 */ 696 break; 697 case V4L2_SDR_FMT_CS8: 698 reg7 = 0x000c9407; /* 504 */ 699 break; 700 case MSI2500_PIX_FMT_SDR_MSI2500_384: 701 reg7 = 0x0000a507; /* 384 */ 702 break; 703 case MSI2500_PIX_FMT_SDR_S12: 704 reg7 = 0x00008507; /* 336 */ 705 break; 706 case V4L2_SDR_FMT_CS14LE: 707 reg7 = 0x00009407; /* 252 */ 708 break; 709 default: 710 reg7 = 0x000c9407; /* 504 */ 711 break; 712 } 713 714 /* 715 * Fractional-N synthesizer 716 * 717 * +----------------------------------------+ 718 * v | 719 * Fref +----+ +-------+ +-----+ +------+ +---+ 720 * ------> | PD | --> | VCO | --> | /2 | ------> | /N.F | <-- | K | 721 * +----+ +-------+ +-----+ +------+ +---+ 722 * | 723 * | 724 * v 725 * +-------+ +-----+ Fout 726 * | /Rout | --> | /12 | ------> 727 * +-------+ +-----+ 728 */ 729 /* 730 * Synthesizer config is just a educated guess... 731 * 732 * [7:0] 0x03, register address 733 * [8] 1, power control 734 * [9] ?, power control 735 * [12:10] output divider 736 * [13] 0 ? 737 * [14] 0 ? 738 * [15] fractional MSB, bit 20 739 * [16:19] N 740 * [23:20] ? 741 * [24:31] 0x01 742 * 743 * output divider 744 * val div 745 * 0 - (invalid) 746 * 1 4 747 * 2 6 748 * 3 8 749 * 4 10 750 * 5 12 751 * 6 14 752 * 7 16 753 * 754 * VCO 202000000 - 720000000++ 755 */ 756 757 #define F_REF 24000000 758 #define DIV_PRE_N 2 759 #define DIV_LO_OUT 12 760 reg3 = 0x01000303; 761 reg4 = 0x00000004; 762 763 /* XXX: Filters? AGC? VCO band? */ 764 if (f_sr < 6000000) 765 reg3 |= 0x1 << 20; 766 else if (f_sr < 7000000) 767 reg3 |= 0x5 << 20; 768 else if (f_sr < 8500000) 769 reg3 |= 0x9 << 20; 770 else 771 reg3 |= 0xd << 20; 772 773 for (div_out = 4; div_out < 16; div_out += 2) { 774 f_vco = f_sr * div_out * DIV_LO_OUT; 775 dev_dbg(dev->dev, "div_out=%u f_vco=%u\n", div_out, f_vco); 776 if (f_vco >= 202000000) 777 break; 778 } 779 780 /* Calculate PLL integer and fractional control word. */ 781 div_n = div_u64_rem(f_vco, DIV_PRE_N * F_REF, &k); 782 k_cw = div_u64((u64) k * 0x200000, DIV_PRE_N * F_REF); 783 784 reg3 |= div_n << 16; 785 reg3 |= (div_out / 2 - 1) << 10; 786 reg3 |= ((k_cw >> 20) & 0x000001) << 15; /* [20] */ 787 reg4 |= ((k_cw >> 0) & 0x0fffff) << 8; /* [19:0] */ 788 789 dev_dbg(dev->dev, 790 "f_sr=%u f_vco=%u div_n=%u k=%u div_out=%u reg3=%08x reg4=%08x\n", 791 f_sr, f_vco, div_n, k, div_out, reg3, reg4); 792 793 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00608008); 794 if (ret) 795 goto err; 796 797 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00000c05); 798 if (ret) 799 goto err; 800 801 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00020000); 802 if (ret) 803 goto err; 804 805 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00480102); 806 if (ret) 807 goto err; 808 809 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00f38008); 810 if (ret) 811 goto err; 812 813 ret = msi2500_ctrl_msg(dev, CMD_WREG, reg7); 814 if (ret) 815 goto err; 816 817 ret = msi2500_ctrl_msg(dev, CMD_WREG, reg4); 818 if (ret) 819 goto err; 820 821 ret = msi2500_ctrl_msg(dev, CMD_WREG, reg3); 822 err: 823 return ret; 824 } 825 826 static int msi2500_start_streaming(struct vb2_queue *vq, unsigned int count) 827 { 828 struct msi2500_dev *dev = vb2_get_drv_priv(vq); 829 int ret; 830 831 dev_dbg(dev->dev, "\n"); 832 833 if (!dev->udev) 834 return -ENODEV; 835 836 if (mutex_lock_interruptible(&dev->v4l2_lock)) 837 return -ERESTARTSYS; 838 839 /* wake-up tuner */ 840 v4l2_subdev_call(dev->v4l2_subdev, core, s_power, 1); 841 842 ret = msi2500_set_usb_adc(dev); 843 844 ret = msi2500_isoc_init(dev); 845 if (ret) 846 msi2500_cleanup_queued_bufs(dev); 847 848 ret = msi2500_ctrl_msg(dev, CMD_START_STREAMING, 0); 849 850 mutex_unlock(&dev->v4l2_lock); 851 852 return ret; 853 } 854 855 static void msi2500_stop_streaming(struct vb2_queue *vq) 856 { 857 struct msi2500_dev *dev = vb2_get_drv_priv(vq); 858 859 dev_dbg(dev->dev, "\n"); 860 861 mutex_lock(&dev->v4l2_lock); 862 863 if (dev->udev) 864 msi2500_isoc_cleanup(dev); 865 866 msi2500_cleanup_queued_bufs(dev); 867 868 /* according to tests, at least 700us delay is required */ 869 msleep(20); 870 if (dev->udev && !msi2500_ctrl_msg(dev, CMD_STOP_STREAMING, 0)) { 871 /* sleep USB IF / ADC */ 872 msi2500_ctrl_msg(dev, CMD_WREG, 0x01000003); 873 } 874 875 /* sleep tuner */ 876 v4l2_subdev_call(dev->v4l2_subdev, core, s_power, 0); 877 878 mutex_unlock(&dev->v4l2_lock); 879 } 880 881 static const struct vb2_ops msi2500_vb2_ops = { 882 .queue_setup = msi2500_queue_setup, 883 .buf_queue = msi2500_buf_queue, 884 .start_streaming = msi2500_start_streaming, 885 .stop_streaming = msi2500_stop_streaming, 886 .wait_prepare = vb2_ops_wait_prepare, 887 .wait_finish = vb2_ops_wait_finish, 888 }; 889 890 static int msi2500_enum_fmt_sdr_cap(struct file *file, void *priv, 891 struct v4l2_fmtdesc *f) 892 { 893 struct msi2500_dev *dev = video_drvdata(file); 894 895 dev_dbg(dev->dev, "index=%d\n", f->index); 896 897 if (f->index >= dev->num_formats) 898 return -EINVAL; 899 900 f->pixelformat = formats[f->index].pixelformat; 901 902 return 0; 903 } 904 905 static int msi2500_g_fmt_sdr_cap(struct file *file, void *priv, 906 struct v4l2_format *f) 907 { 908 struct msi2500_dev *dev = video_drvdata(file); 909 910 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n", 911 (char *)&dev->pixelformat); 912 913 f->fmt.sdr.pixelformat = dev->pixelformat; 914 f->fmt.sdr.buffersize = dev->buffersize; 915 916 return 0; 917 } 918 919 static int msi2500_s_fmt_sdr_cap(struct file *file, void *priv, 920 struct v4l2_format *f) 921 { 922 struct msi2500_dev *dev = video_drvdata(file); 923 struct vb2_queue *q = &dev->vb_queue; 924 int i; 925 926 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n", 927 (char *)&f->fmt.sdr.pixelformat); 928 929 if (vb2_is_busy(q)) 930 return -EBUSY; 931 932 for (i = 0; i < dev->num_formats; i++) { 933 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) { 934 dev->pixelformat = formats[i].pixelformat; 935 dev->buffersize = formats[i].buffersize; 936 f->fmt.sdr.buffersize = formats[i].buffersize; 937 return 0; 938 } 939 } 940 941 dev->pixelformat = formats[0].pixelformat; 942 dev->buffersize = formats[0].buffersize; 943 f->fmt.sdr.pixelformat = formats[0].pixelformat; 944 f->fmt.sdr.buffersize = formats[0].buffersize; 945 946 return 0; 947 } 948 949 static int msi2500_try_fmt_sdr_cap(struct file *file, void *priv, 950 struct v4l2_format *f) 951 { 952 struct msi2500_dev *dev = video_drvdata(file); 953 int i; 954 955 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n", 956 (char *)&f->fmt.sdr.pixelformat); 957 958 for (i = 0; i < dev->num_formats; i++) { 959 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) { 960 f->fmt.sdr.buffersize = formats[i].buffersize; 961 return 0; 962 } 963 } 964 965 f->fmt.sdr.pixelformat = formats[0].pixelformat; 966 f->fmt.sdr.buffersize = formats[0].buffersize; 967 968 return 0; 969 } 970 971 static int msi2500_s_tuner(struct file *file, void *priv, 972 const struct v4l2_tuner *v) 973 { 974 struct msi2500_dev *dev = video_drvdata(file); 975 int ret; 976 977 dev_dbg(dev->dev, "index=%d\n", v->index); 978 979 if (v->index == 0) 980 ret = 0; 981 else if (v->index == 1) 982 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, s_tuner, v); 983 else 984 ret = -EINVAL; 985 986 return ret; 987 } 988 989 static int msi2500_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v) 990 { 991 struct msi2500_dev *dev = video_drvdata(file); 992 int ret; 993 994 dev_dbg(dev->dev, "index=%d\n", v->index); 995 996 if (v->index == 0) { 997 strscpy(v->name, "Mirics MSi2500", sizeof(v->name)); 998 v->type = V4L2_TUNER_ADC; 999 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS; 1000 v->rangelow = 1200000; 1001 v->rangehigh = 15000000; 1002 ret = 0; 1003 } else if (v->index == 1) { 1004 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, g_tuner, v); 1005 } else { 1006 ret = -EINVAL; 1007 } 1008 1009 return ret; 1010 } 1011 1012 static int msi2500_g_frequency(struct file *file, void *priv, 1013 struct v4l2_frequency *f) 1014 { 1015 struct msi2500_dev *dev = video_drvdata(file); 1016 int ret = 0; 1017 1018 dev_dbg(dev->dev, "tuner=%d type=%d\n", f->tuner, f->type); 1019 1020 if (f->tuner == 0) { 1021 f->frequency = dev->f_adc; 1022 ret = 0; 1023 } else if (f->tuner == 1) { 1024 f->type = V4L2_TUNER_RF; 1025 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, g_frequency, f); 1026 } else { 1027 ret = -EINVAL; 1028 } 1029 1030 return ret; 1031 } 1032 1033 static int msi2500_s_frequency(struct file *file, void *priv, 1034 const struct v4l2_frequency *f) 1035 { 1036 struct msi2500_dev *dev = video_drvdata(file); 1037 int ret; 1038 1039 dev_dbg(dev->dev, "tuner=%d type=%d frequency=%u\n", 1040 f->tuner, f->type, f->frequency); 1041 1042 if (f->tuner == 0) { 1043 dev->f_adc = clamp_t(unsigned int, f->frequency, 1044 bands[0].rangelow, 1045 bands[0].rangehigh); 1046 dev_dbg(dev->dev, "ADC frequency=%u Hz\n", dev->f_adc); 1047 ret = msi2500_set_usb_adc(dev); 1048 } else if (f->tuner == 1) { 1049 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, s_frequency, f); 1050 } else { 1051 ret = -EINVAL; 1052 } 1053 1054 return ret; 1055 } 1056 1057 static int msi2500_enum_freq_bands(struct file *file, void *priv, 1058 struct v4l2_frequency_band *band) 1059 { 1060 struct msi2500_dev *dev = video_drvdata(file); 1061 int ret; 1062 1063 dev_dbg(dev->dev, "tuner=%d type=%d index=%d\n", 1064 band->tuner, band->type, band->index); 1065 1066 if (band->tuner == 0) { 1067 if (band->index >= ARRAY_SIZE(bands)) { 1068 ret = -EINVAL; 1069 } else { 1070 *band = bands[band->index]; 1071 ret = 0; 1072 } 1073 } else if (band->tuner == 1) { 1074 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, 1075 enum_freq_bands, band); 1076 } else { 1077 ret = -EINVAL; 1078 } 1079 1080 return ret; 1081 } 1082 1083 static const struct v4l2_ioctl_ops msi2500_ioctl_ops = { 1084 .vidioc_querycap = msi2500_querycap, 1085 1086 .vidioc_enum_fmt_sdr_cap = msi2500_enum_fmt_sdr_cap, 1087 .vidioc_g_fmt_sdr_cap = msi2500_g_fmt_sdr_cap, 1088 .vidioc_s_fmt_sdr_cap = msi2500_s_fmt_sdr_cap, 1089 .vidioc_try_fmt_sdr_cap = msi2500_try_fmt_sdr_cap, 1090 1091 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1092 .vidioc_create_bufs = vb2_ioctl_create_bufs, 1093 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 1094 .vidioc_querybuf = vb2_ioctl_querybuf, 1095 .vidioc_qbuf = vb2_ioctl_qbuf, 1096 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1097 1098 .vidioc_streamon = vb2_ioctl_streamon, 1099 .vidioc_streamoff = vb2_ioctl_streamoff, 1100 1101 .vidioc_g_tuner = msi2500_g_tuner, 1102 .vidioc_s_tuner = msi2500_s_tuner, 1103 1104 .vidioc_g_frequency = msi2500_g_frequency, 1105 .vidioc_s_frequency = msi2500_s_frequency, 1106 .vidioc_enum_freq_bands = msi2500_enum_freq_bands, 1107 1108 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1109 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1110 .vidioc_log_status = v4l2_ctrl_log_status, 1111 }; 1112 1113 static const struct v4l2_file_operations msi2500_fops = { 1114 .owner = THIS_MODULE, 1115 .open = v4l2_fh_open, 1116 .release = vb2_fop_release, 1117 .read = vb2_fop_read, 1118 .poll = vb2_fop_poll, 1119 .mmap = vb2_fop_mmap, 1120 .unlocked_ioctl = video_ioctl2, 1121 }; 1122 1123 static const struct video_device msi2500_template = { 1124 .name = "Mirics MSi3101 SDR Dongle", 1125 .release = video_device_release_empty, 1126 .fops = &msi2500_fops, 1127 .ioctl_ops = &msi2500_ioctl_ops, 1128 }; 1129 1130 static void msi2500_video_release(struct v4l2_device *v) 1131 { 1132 struct msi2500_dev *dev = container_of(v, struct msi2500_dev, v4l2_dev); 1133 1134 v4l2_ctrl_handler_free(&dev->hdl); 1135 v4l2_device_unregister(&dev->v4l2_dev); 1136 kfree(dev); 1137 } 1138 1139 static int msi2500_transfer_one_message(struct spi_master *master, 1140 struct spi_message *m) 1141 { 1142 struct msi2500_dev *dev = spi_master_get_devdata(master); 1143 struct spi_transfer *t; 1144 int ret = 0; 1145 u32 data; 1146 1147 list_for_each_entry(t, &m->transfers, transfer_list) { 1148 dev_dbg(dev->dev, "msg=%*ph\n", t->len, t->tx_buf); 1149 data = 0x09; /* reg 9 is SPI adapter */ 1150 data |= ((u8 *)t->tx_buf)[0] << 8; 1151 data |= ((u8 *)t->tx_buf)[1] << 16; 1152 data |= ((u8 *)t->tx_buf)[2] << 24; 1153 ret = msi2500_ctrl_msg(dev, CMD_WREG, data); 1154 } 1155 1156 m->status = ret; 1157 spi_finalize_current_message(master); 1158 return ret; 1159 } 1160 1161 static int msi2500_probe(struct usb_interface *intf, 1162 const struct usb_device_id *id) 1163 { 1164 struct msi2500_dev *dev; 1165 struct v4l2_subdev *sd; 1166 struct spi_master *master; 1167 int ret; 1168 static struct spi_board_info board_info = { 1169 .modalias = "msi001", 1170 .bus_num = 0, 1171 .chip_select = 0, 1172 .max_speed_hz = 12000000, 1173 }; 1174 1175 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1176 if (!dev) { 1177 ret = -ENOMEM; 1178 goto err; 1179 } 1180 1181 mutex_init(&dev->v4l2_lock); 1182 mutex_init(&dev->vb_queue_lock); 1183 spin_lock_init(&dev->queued_bufs_lock); 1184 INIT_LIST_HEAD(&dev->queued_bufs); 1185 dev->dev = &intf->dev; 1186 dev->udev = interface_to_usbdev(intf); 1187 dev->f_adc = bands[0].rangelow; 1188 dev->pixelformat = formats[0].pixelformat; 1189 dev->buffersize = formats[0].buffersize; 1190 dev->num_formats = NUM_FORMATS; 1191 if (!msi2500_emulated_fmt) 1192 dev->num_formats -= 2; 1193 1194 /* Init videobuf2 queue structure */ 1195 dev->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE; 1196 dev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ; 1197 dev->vb_queue.drv_priv = dev; 1198 dev->vb_queue.buf_struct_size = sizeof(struct msi2500_frame_buf); 1199 dev->vb_queue.ops = &msi2500_vb2_ops; 1200 dev->vb_queue.mem_ops = &vb2_vmalloc_memops; 1201 dev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1202 ret = vb2_queue_init(&dev->vb_queue); 1203 if (ret) { 1204 dev_err(dev->dev, "Could not initialize vb2 queue\n"); 1205 goto err_free_mem; 1206 } 1207 1208 /* Init video_device structure */ 1209 dev->vdev = msi2500_template; 1210 dev->vdev.queue = &dev->vb_queue; 1211 dev->vdev.queue->lock = &dev->vb_queue_lock; 1212 video_set_drvdata(&dev->vdev, dev); 1213 1214 /* Register the v4l2_device structure */ 1215 dev->v4l2_dev.release = msi2500_video_release; 1216 ret = v4l2_device_register(&intf->dev, &dev->v4l2_dev); 1217 if (ret) { 1218 dev_err(dev->dev, "Failed to register v4l2-device (%d)\n", ret); 1219 goto err_free_mem; 1220 } 1221 1222 /* SPI master adapter */ 1223 master = spi_alloc_master(dev->dev, 0); 1224 if (master == NULL) { 1225 ret = -ENOMEM; 1226 goto err_unregister_v4l2_dev; 1227 } 1228 1229 dev->master = master; 1230 master->bus_num = -1; 1231 master->num_chipselect = 1; 1232 master->transfer_one_message = msi2500_transfer_one_message; 1233 spi_master_set_devdata(master, dev); 1234 ret = spi_register_master(master); 1235 if (ret) { 1236 spi_master_put(master); 1237 goto err_unregister_v4l2_dev; 1238 } 1239 1240 /* load v4l2 subdevice */ 1241 sd = v4l2_spi_new_subdev(&dev->v4l2_dev, master, &board_info); 1242 dev->v4l2_subdev = sd; 1243 if (sd == NULL) { 1244 dev_err(dev->dev, "cannot get v4l2 subdevice\n"); 1245 ret = -ENODEV; 1246 goto err_unregister_master; 1247 } 1248 1249 /* Register controls */ 1250 v4l2_ctrl_handler_init(&dev->hdl, 0); 1251 if (dev->hdl.error) { 1252 ret = dev->hdl.error; 1253 dev_err(dev->dev, "Could not initialize controls\n"); 1254 goto err_free_controls; 1255 } 1256 1257 /* currently all controls are from subdev */ 1258 v4l2_ctrl_add_handler(&dev->hdl, sd->ctrl_handler, NULL, true); 1259 1260 dev->v4l2_dev.ctrl_handler = &dev->hdl; 1261 dev->vdev.v4l2_dev = &dev->v4l2_dev; 1262 dev->vdev.lock = &dev->v4l2_lock; 1263 dev->vdev.device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING | 1264 V4L2_CAP_READWRITE | V4L2_CAP_TUNER; 1265 1266 ret = video_register_device(&dev->vdev, VFL_TYPE_SDR, -1); 1267 if (ret) { 1268 dev_err(dev->dev, 1269 "Failed to register as video device (%d)\n", ret); 1270 goto err_unregister_v4l2_dev; 1271 } 1272 dev_info(dev->dev, "Registered as %s\n", 1273 video_device_node_name(&dev->vdev)); 1274 dev_notice(dev->dev, 1275 "SDR API is still slightly experimental and functionality changes may follow\n"); 1276 return 0; 1277 err_free_controls: 1278 v4l2_ctrl_handler_free(&dev->hdl); 1279 err_unregister_master: 1280 spi_unregister_master(dev->master); 1281 err_unregister_v4l2_dev: 1282 v4l2_device_unregister(&dev->v4l2_dev); 1283 err_free_mem: 1284 kfree(dev); 1285 err: 1286 return ret; 1287 } 1288 1289 /* USB device ID list */ 1290 static const struct usb_device_id msi2500_id_table[] = { 1291 {USB_DEVICE(0x1df7, 0x2500)}, /* Mirics MSi3101 SDR Dongle */ 1292 {USB_DEVICE(0x2040, 0xd300)}, /* Hauppauge WinTV 133559 LF */ 1293 {} 1294 }; 1295 MODULE_DEVICE_TABLE(usb, msi2500_id_table); 1296 1297 /* USB subsystem interface */ 1298 static struct usb_driver msi2500_driver = { 1299 .name = KBUILD_MODNAME, 1300 .probe = msi2500_probe, 1301 .disconnect = msi2500_disconnect, 1302 .id_table = msi2500_id_table, 1303 }; 1304 1305 module_usb_driver(msi2500_driver); 1306 1307 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 1308 MODULE_DESCRIPTION("Mirics MSi3101 SDR Dongle"); 1309 MODULE_LICENSE("GPL"); 1310