2 * Mirics MSi2500 driver
3 * Mirics MSi3101 SDR Dongle driver
5 * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * That driver is somehow based of pwc driver:
18 * (C) 1999-2004 Nemosoft Unv.
19 * (C) 2004-2006 Luc Saillard (luc@saillard.org)
20 * (C) 2011 Hans de Goede <hdegoede@redhat.com>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <asm/div64.h>
26 #include <media/v4l2-device.h>
27 #include <media/v4l2-ioctl.h>
28 #include <media/v4l2-ctrls.h>
29 #include <media/v4l2-event.h>
30 #include <linux/usb.h>
31 #include <media/videobuf2-v4l2.h>
32 #include <media/videobuf2-vmalloc.h>
33 #include <linux/spi/spi.h>
35 static bool msi2500_emulated_fmt
;
36 module_param_named(emulated_formats
, msi2500_emulated_fmt
, bool, 0644);
37 MODULE_PARM_DESC(emulated_formats
, "enable emulated formats (disappears in future)");
44 * bEndpointAddress 0x81 EP 1 IN
46 * Transfer Type Isochronous
47 * wMaxPacketSize 0x1400 3x 1024 bytes
50 #define MAX_ISO_BUFS (8)
51 #define ISO_FRAMES_PER_DESC (8)
52 #define ISO_MAX_FRAME_SIZE (3 * 1024)
53 #define ISO_BUFFER_SIZE (ISO_FRAMES_PER_DESC * ISO_MAX_FRAME_SIZE)
54 #define MAX_ISOC_ERRORS 20
57 * TODO: These formats should be moved to V4L2 API. Formats are currently
58 * disabled from formats[] table, not visible to userspace.
61 #define MSI2500_PIX_FMT_SDR_S12 v4l2_fourcc('D', 'S', '1', '2')
62 /* Mirics MSi2500 format 384 */
63 #define MSI2500_PIX_FMT_SDR_MSI2500_384 v4l2_fourcc('M', '3', '8', '4')
65 static const struct v4l2_frequency_band bands
[] = {
68 .type
= V4L2_TUNER_ADC
,
70 .capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
,
72 .rangehigh
= 15000000,
77 struct msi2500_format
{
83 /* format descriptions for capture and preview */
84 static struct msi2500_format formats
[] = {
87 .pixelformat
= V4L2_SDR_FMT_CS8
,
88 .buffersize
= 3 * 1008,
91 .name
= "10+2-bit signed",
92 .pixelformat
= MSI2500_PIX_FMT_SDR_MSI2500_384
,
94 .name
= "12-bit signed",
95 .pixelformat
= MSI2500_PIX_FMT_SDR_S12
,
98 .name
= "Complex S14LE",
99 .pixelformat
= V4L2_SDR_FMT_CS14LE
,
100 .buffersize
= 3 * 1008,
102 .name
= "Complex U8 (emulated)",
103 .pixelformat
= V4L2_SDR_FMT_CU8
,
104 .buffersize
= 3 * 1008,
106 .name
= "Complex U16LE (emulated)",
107 .pixelformat
= V4L2_SDR_FMT_CU16LE
,
108 .buffersize
= 3 * 1008,
112 static const unsigned int NUM_FORMATS
= ARRAY_SIZE(formats
);
114 /* intermediate buffers with raw data from the USB device */
115 struct msi2500_frame_buf
{
116 /* common v4l buffer stuff -- must be first */
117 struct vb2_v4l2_buffer vb
;
118 struct list_head list
;
123 struct video_device vdev
;
124 struct v4l2_device v4l2_dev
;
125 struct v4l2_subdev
*v4l2_subdev
;
126 struct spi_master
*master
;
128 /* videobuf2 queue and queued buffers list */
129 struct vb2_queue vb_queue
;
130 struct list_head queued_bufs
;
131 spinlock_t queued_bufs_lock
; /* Protects queued_bufs */
133 /* Note if taking both locks v4l2_lock must always be locked first! */
134 struct mutex v4l2_lock
; /* Protects everything else */
135 struct mutex vb_queue_lock
; /* Protects vb_queue and capt_file */
137 /* Pointer to our usb_device, will be NULL after unplug */
138 struct usb_device
*udev
; /* Both mutexes most be hold when setting! */
143 unsigned int num_formats
;
145 unsigned int isoc_errors
; /* number of contiguous ISOC errors */
146 unsigned int vb_full
; /* vb is full and packets dropped */
148 struct urb
*urbs
[MAX_ISO_BUFS
];
151 struct v4l2_ctrl_handler hdl
;
153 u32 next_sample
; /* for track lost packets */
154 u32 sample
; /* for sample rate calc */
155 unsigned long jiffies_next
;
158 /* Private functions */
159 static struct msi2500_frame_buf
*msi2500_get_next_fill_buf(
160 struct msi2500_dev
*dev
)
163 struct msi2500_frame_buf
*buf
= NULL
;
165 spin_lock_irqsave(&dev
->queued_bufs_lock
, flags
);
166 if (list_empty(&dev
->queued_bufs
))
169 buf
= list_entry(dev
->queued_bufs
.next
, struct msi2500_frame_buf
, list
);
170 list_del(&buf
->list
);
172 spin_unlock_irqrestore(&dev
->queued_bufs_lock
, flags
);
177 * +===========================================================================
178 * | 00-1023 | USB packet type '504'
179 * +===========================================================================
180 * | 00- 03 | sequence number of first sample in that USB packet
181 * +---------------------------------------------------------------------------
183 * +---------------------------------------------------------------------------
184 * | 16-1023 | samples
185 * +---------------------------------------------------------------------------
186 * signed 8-bit sample
187 * 504 * 2 = 1008 samples
190 * +===========================================================================
191 * | 00-1023 | USB packet type '384'
192 * +===========================================================================
193 * | 00- 03 | sequence number of first sample in that USB packet
194 * +---------------------------------------------------------------------------
196 * +---------------------------------------------------------------------------
197 * | 16- 175 | samples
198 * +---------------------------------------------------------------------------
199 * | 176- 179 | control bits for previous samples
200 * +---------------------------------------------------------------------------
201 * | 180- 339 | samples
202 * +---------------------------------------------------------------------------
203 * | 340- 343 | control bits for previous samples
204 * +---------------------------------------------------------------------------
205 * | 344- 503 | samples
206 * +---------------------------------------------------------------------------
207 * | 504- 507 | control bits for previous samples
208 * +---------------------------------------------------------------------------
209 * | 508- 667 | samples
210 * +---------------------------------------------------------------------------
211 * | 668- 671 | control bits for previous samples
212 * +---------------------------------------------------------------------------
213 * | 672- 831 | samples
214 * +---------------------------------------------------------------------------
215 * | 832- 835 | control bits for previous samples
216 * +---------------------------------------------------------------------------
217 * | 836- 995 | samples
218 * +---------------------------------------------------------------------------
219 * | 996- 999 | control bits for previous samples
220 * +---------------------------------------------------------------------------
221 * | 1000-1023 | garbage
222 * +---------------------------------------------------------------------------
224 * Bytes 4 - 7 could have some meaning?
226 * Control bits for previous samples is 32-bit field, containing 16 x 2-bit
227 * numbers. This results one 2-bit number for 8 samples. It is likely used for
228 * for bit shifting sample by given bits, increasing actual sampling resolution.
229 * Number 2 (0b10) was never seen.
231 * 6 * 16 * 2 * 4 = 768 samples. 768 * 4 = 3072 bytes
234 * +===========================================================================
235 * | 00-1023 | USB packet type '336'
236 * +===========================================================================
237 * | 00- 03 | sequence number of first sample in that USB packet
238 * +---------------------------------------------------------------------------
240 * +---------------------------------------------------------------------------
241 * | 16-1023 | samples
242 * +---------------------------------------------------------------------------
243 * signed 12-bit sample
246 * +===========================================================================
247 * | 00-1023 | USB packet type '252'
248 * +===========================================================================
249 * | 00- 03 | sequence number of first sample in that USB packet
250 * +---------------------------------------------------------------------------
252 * +---------------------------------------------------------------------------
253 * | 16-1023 | samples
254 * +---------------------------------------------------------------------------
255 * signed 14-bit sample
258 static int msi2500_convert_stream(struct msi2500_dev
*dev
, u8
*dst
, u8
*src
,
259 unsigned int src_len
)
261 unsigned int i
, j
, transactions
, dst_len
= 0;
264 /* There could be 1-3 1024 byte transactions per packet */
265 transactions
= src_len
/ 1024;
267 for (i
= 0; i
< transactions
; i
++) {
268 sample
[i
] = src
[3] << 24 | src
[2] << 16 | src
[1] << 8 |
270 if (i
== 0 && dev
->next_sample
!= sample
[0]) {
271 dev_dbg_ratelimited(dev
->dev
,
272 "%d samples lost, %d %08x:%08x\n",
273 sample
[0] - dev
->next_sample
,
274 src_len
, dev
->next_sample
,
279 * Dump all unknown 'garbage' data - maybe we will discover
280 * someday if there is something rational...
282 dev_dbg_ratelimited(dev
->dev
, "%*ph\n", 12, &src
[4]);
284 src
+= 16; /* skip header */
286 switch (dev
->pixelformat
) {
287 case V4L2_SDR_FMT_CU8
: /* 504 x IQ samples */
289 s8
*s8src
= (s8
*)src
;
290 u8
*u8dst
= (u8
*)dst
;
292 for (j
= 0; j
< 1008; j
++)
293 *u8dst
++ = *s8src
++ + 128;
298 dev
->next_sample
= sample
[i
] + 504;
301 case V4L2_SDR_FMT_CU16LE
: /* 252 x IQ samples */
303 s16
*s16src
= (s16
*)src
;
304 u16
*u16dst
= (u16
*)dst
;
305 struct {signed int x
:14; } se
; /* sign extension */
308 for (j
= 0; j
< 1008; j
+= 2) {
309 /* sign extension from 14-bit to signed int */
311 /* from signed int to unsigned int */
313 /* from 14-bit to 16-bit */
314 *u16dst
++ = utmp
<< 2 | utmp
>> 12;
320 dev
->next_sample
= sample
[i
] + 252;
323 case MSI2500_PIX_FMT_SDR_MSI2500_384
: /* 384 x IQ samples */
324 /* Dump unknown 'garbage' data */
325 dev_dbg_ratelimited(dev
->dev
, "%*ph\n", 24, &src
[1000]);
326 memcpy(dst
, src
, 984);
330 dev
->next_sample
= sample
[i
] + 384;
332 case V4L2_SDR_FMT_CS8
: /* 504 x IQ samples */
333 memcpy(dst
, src
, 1008);
337 dev
->next_sample
= sample
[i
] + 504;
339 case MSI2500_PIX_FMT_SDR_S12
: /* 336 x IQ samples */
340 memcpy(dst
, src
, 1008);
344 dev
->next_sample
= sample
[i
] + 336;
346 case V4L2_SDR_FMT_CS14LE
: /* 252 x IQ samples */
347 memcpy(dst
, src
, 1008);
351 dev
->next_sample
= sample
[i
] + 252;
358 /* calculate sample rate and output it in 10 seconds intervals */
359 if (unlikely(time_is_before_jiffies(dev
->jiffies_next
))) {
360 #define MSECS 10000UL
361 unsigned int msecs
= jiffies_to_msecs(jiffies
-
362 dev
->jiffies_next
+ msecs_to_jiffies(MSECS
));
363 unsigned int samples
= dev
->next_sample
- dev
->sample
;
365 dev
->jiffies_next
= jiffies
+ msecs_to_jiffies(MSECS
);
366 dev
->sample
= dev
->next_sample
;
367 dev_dbg(dev
->dev
, "size=%u samples=%u msecs=%u sample rate=%lu\n",
368 src_len
, samples
, msecs
,
369 samples
* 1000UL / msecs
);
376 * This gets called for the Isochronous pipe (stream). This is done in interrupt
377 * time, so it has to be fast, not crash, and not stall. Neat.
379 static void msi2500_isoc_handler(struct urb
*urb
)
381 struct msi2500_dev
*dev
= (struct msi2500_dev
*)urb
->context
;
382 int i
, flen
, fstatus
;
383 unsigned char *iso_buf
= NULL
;
384 struct msi2500_frame_buf
*fbuf
;
386 if (unlikely(urb
->status
== -ENOENT
||
387 urb
->status
== -ECONNRESET
||
388 urb
->status
== -ESHUTDOWN
)) {
389 dev_dbg(dev
->dev
, "URB (%p) unlinked %ssynchronuously\n",
390 urb
, urb
->status
== -ENOENT
? "" : "a");
394 if (unlikely(urb
->status
!= 0)) {
395 dev_dbg(dev
->dev
, "called with status %d\n", urb
->status
);
396 /* Give up after a number of contiguous errors */
397 if (++dev
->isoc_errors
> MAX_ISOC_ERRORS
)
398 dev_dbg(dev
->dev
, "Too many ISOC errors, bailing out\n");
401 /* Reset ISOC error counter. We did get here, after all. */
402 dev
->isoc_errors
= 0;
406 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
409 /* Check frame error */
410 fstatus
= urb
->iso_frame_desc
[i
].status
;
411 if (unlikely(fstatus
)) {
412 dev_dbg_ratelimited(dev
->dev
,
413 "frame=%d/%d has error %d skipping\n",
414 i
, urb
->number_of_packets
, fstatus
);
418 /* Check if that frame contains data */
419 flen
= urb
->iso_frame_desc
[i
].actual_length
;
420 if (unlikely(flen
== 0))
423 iso_buf
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
425 /* Get free framebuffer */
426 fbuf
= msi2500_get_next_fill_buf(dev
);
427 if (unlikely(fbuf
== NULL
)) {
429 dev_dbg_ratelimited(dev
->dev
,
430 "videobuf is full, %d packets dropped\n",
435 /* fill framebuffer */
436 ptr
= vb2_plane_vaddr(&fbuf
->vb
.vb2_buf
, 0);
437 flen
= msi2500_convert_stream(dev
, ptr
, iso_buf
, flen
);
438 vb2_set_plane_payload(&fbuf
->vb
.vb2_buf
, 0, flen
);
439 vb2_buffer_done(&fbuf
->vb
.vb2_buf
, VB2_BUF_STATE_DONE
);
443 i
= usb_submit_urb(urb
, GFP_ATOMIC
);
444 if (unlikely(i
!= 0))
445 dev_dbg(dev
->dev
, "Error (%d) re-submitting urb\n", i
);
448 static void msi2500_iso_stop(struct msi2500_dev
*dev
)
452 dev_dbg(dev
->dev
, "\n");
454 /* Unlinking ISOC buffers one by one */
455 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
457 dev_dbg(dev
->dev
, "Unlinking URB %p\n", dev
->urbs
[i
]);
458 usb_kill_urb(dev
->urbs
[i
]);
463 static void msi2500_iso_free(struct msi2500_dev
*dev
)
467 dev_dbg(dev
->dev
, "\n");
469 /* Freeing ISOC buffers one by one */
470 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
472 dev_dbg(dev
->dev
, "Freeing URB\n");
473 if (dev
->urbs
[i
]->transfer_buffer
) {
474 usb_free_coherent(dev
->udev
,
475 dev
->urbs
[i
]->transfer_buffer_length
,
476 dev
->urbs
[i
]->transfer_buffer
,
477 dev
->urbs
[i
]->transfer_dma
);
479 usb_free_urb(dev
->urbs
[i
]);
485 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
486 static void msi2500_isoc_cleanup(struct msi2500_dev
*dev
)
488 dev_dbg(dev
->dev
, "\n");
490 msi2500_iso_stop(dev
);
491 msi2500_iso_free(dev
);
494 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
495 static int msi2500_isoc_init(struct msi2500_dev
*dev
)
500 dev_dbg(dev
->dev
, "\n");
502 dev
->isoc_errors
= 0;
504 ret
= usb_set_interface(dev
->udev
, 0, 1);
508 /* Allocate and init Isochronuous urbs */
509 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
510 urb
= usb_alloc_urb(ISO_FRAMES_PER_DESC
, GFP_KERNEL
);
512 dev_err(dev
->dev
, "Failed to allocate urb %d\n", i
);
513 msi2500_isoc_cleanup(dev
);
517 dev_dbg(dev
->dev
, "Allocated URB at 0x%p\n", urb
);
520 urb
->dev
= dev
->udev
;
521 urb
->pipe
= usb_rcvisocpipe(dev
->udev
, 0x81);
522 urb
->transfer_flags
= URB_ISO_ASAP
| URB_NO_TRANSFER_DMA_MAP
;
523 urb
->transfer_buffer
= usb_alloc_coherent(dev
->udev
,
525 GFP_KERNEL
, &urb
->transfer_dma
);
526 if (urb
->transfer_buffer
== NULL
) {
528 "Failed to allocate urb buffer %d\n", i
);
529 msi2500_isoc_cleanup(dev
);
532 urb
->transfer_buffer_length
= ISO_BUFFER_SIZE
;
533 urb
->complete
= msi2500_isoc_handler
;
535 urb
->start_frame
= 0;
536 urb
->number_of_packets
= ISO_FRAMES_PER_DESC
;
537 for (j
= 0; j
< ISO_FRAMES_PER_DESC
; j
++) {
538 urb
->iso_frame_desc
[j
].offset
= j
* ISO_MAX_FRAME_SIZE
;
539 urb
->iso_frame_desc
[j
].length
= ISO_MAX_FRAME_SIZE
;
544 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
545 ret
= usb_submit_urb(dev
->urbs
[i
], GFP_KERNEL
);
548 "usb_submit_urb %d failed with error %d\n",
550 msi2500_isoc_cleanup(dev
);
553 dev_dbg(dev
->dev
, "URB 0x%p submitted.\n", dev
->urbs
[i
]);
560 /* Must be called with vb_queue_lock hold */
561 static void msi2500_cleanup_queued_bufs(struct msi2500_dev
*dev
)
565 dev_dbg(dev
->dev
, "\n");
567 spin_lock_irqsave(&dev
->queued_bufs_lock
, flags
);
568 while (!list_empty(&dev
->queued_bufs
)) {
569 struct msi2500_frame_buf
*buf
;
571 buf
= list_entry(dev
->queued_bufs
.next
,
572 struct msi2500_frame_buf
, list
);
573 list_del(&buf
->list
);
574 vb2_buffer_done(&buf
->vb
.vb2_buf
, VB2_BUF_STATE_ERROR
);
576 spin_unlock_irqrestore(&dev
->queued_bufs_lock
, flags
);
579 /* The user yanked out the cable... */
580 static void msi2500_disconnect(struct usb_interface
*intf
)
582 struct v4l2_device
*v
= usb_get_intfdata(intf
);
583 struct msi2500_dev
*dev
=
584 container_of(v
, struct msi2500_dev
, v4l2_dev
);
586 dev_dbg(dev
->dev
, "\n");
588 mutex_lock(&dev
->vb_queue_lock
);
589 mutex_lock(&dev
->v4l2_lock
);
590 /* No need to keep the urbs around after disconnection */
592 v4l2_device_disconnect(&dev
->v4l2_dev
);
593 video_unregister_device(&dev
->vdev
);
594 spi_unregister_master(dev
->master
);
595 mutex_unlock(&dev
->v4l2_lock
);
596 mutex_unlock(&dev
->vb_queue_lock
);
598 v4l2_device_put(&dev
->v4l2_dev
);
601 static int msi2500_querycap(struct file
*file
, void *fh
,
602 struct v4l2_capability
*cap
)
604 struct msi2500_dev
*dev
= video_drvdata(file
);
606 dev_dbg(dev
->dev
, "\n");
608 strlcpy(cap
->driver
, KBUILD_MODNAME
, sizeof(cap
->driver
));
609 strlcpy(cap
->card
, dev
->vdev
.name
, sizeof(cap
->card
));
610 usb_make_path(dev
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
611 cap
->device_caps
= V4L2_CAP_SDR_CAPTURE
| V4L2_CAP_STREAMING
|
612 V4L2_CAP_READWRITE
| V4L2_CAP_TUNER
;
613 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
617 /* Videobuf2 operations */
618 static int msi2500_queue_setup(struct vb2_queue
*vq
,
619 unsigned int *nbuffers
,
620 unsigned int *nplanes
, unsigned int sizes
[],
621 struct device
*alloc_devs
[])
623 struct msi2500_dev
*dev
= vb2_get_drv_priv(vq
);
625 dev_dbg(dev
->dev
, "nbuffers=%d\n", *nbuffers
);
627 /* Absolute min and max number of buffers available for mmap() */
628 *nbuffers
= clamp_t(unsigned int, *nbuffers
, 8, 32);
630 sizes
[0] = PAGE_ALIGN(dev
->buffersize
);
631 dev_dbg(dev
->dev
, "nbuffers=%d sizes[0]=%d\n", *nbuffers
, sizes
[0]);
635 static void msi2500_buf_queue(struct vb2_buffer
*vb
)
637 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
638 struct msi2500_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
639 struct msi2500_frame_buf
*buf
= container_of(vbuf
,
640 struct msi2500_frame_buf
,
644 /* Check the device has not disconnected between prep and queuing */
645 if (unlikely(!dev
->udev
)) {
646 vb2_buffer_done(&buf
->vb
.vb2_buf
, VB2_BUF_STATE_ERROR
);
650 spin_lock_irqsave(&dev
->queued_bufs_lock
, flags
);
651 list_add_tail(&buf
->list
, &dev
->queued_bufs
);
652 spin_unlock_irqrestore(&dev
->queued_bufs_lock
, flags
);
655 #define CMD_WREG 0x41
656 #define CMD_START_STREAMING 0x43
657 #define CMD_STOP_STREAMING 0x45
658 #define CMD_READ_UNKNOWN 0x48
660 #define msi2500_dbg_usb_control_msg(_dev, _r, _t, _v, _i, _b, _l) { \
662 if (_t & USB_DIR_IN) \
663 _direction = "<<<"; \
665 _direction = ">>>"; \
666 dev_dbg(_dev, "%02x %02x %02x %02x %02x %02x %02x %02x %s %*ph\n", \
667 _t, _r, _v & 0xff, _v >> 8, _i & 0xff, _i >> 8, \
668 _l & 0xff, _l >> 8, _direction, _l, _b); \
671 static int msi2500_ctrl_msg(struct msi2500_dev
*dev
, u8 cmd
, u32 data
)
675 u8 requesttype
= USB_DIR_OUT
| USB_TYPE_VENDOR
;
676 u16 value
= (data
>> 0) & 0xffff;
677 u16 index
= (data
>> 16) & 0xffff;
679 msi2500_dbg_usb_control_msg(dev
->dev
, request
, requesttype
,
680 value
, index
, NULL
, 0);
681 ret
= usb_control_msg(dev
->udev
, usb_sndctrlpipe(dev
->udev
, 0), request
,
682 requesttype
, value
, index
, NULL
, 0, 2000);
684 dev_err(dev
->dev
, "failed %d, cmd %02x, data %04x\n",
690 static int msi2500_set_usb_adc(struct msi2500_dev
*dev
)
693 unsigned int f_vco
, f_sr
, div_n
, k
, k_cw
, div_out
;
694 u32 reg3
, reg4
, reg7
;
695 struct v4l2_ctrl
*bandwidth_auto
;
696 struct v4l2_ctrl
*bandwidth
;
700 /* set tuner, subdev, filters according to sampling rate */
701 bandwidth_auto
= v4l2_ctrl_find(&dev
->hdl
,
702 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO
);
703 if (v4l2_ctrl_g_ctrl(bandwidth_auto
)) {
704 bandwidth
= v4l2_ctrl_find(&dev
->hdl
,
705 V4L2_CID_RF_TUNER_BANDWIDTH
);
706 v4l2_ctrl_s_ctrl(bandwidth
, dev
->f_adc
);
709 /* select stream format */
710 switch (dev
->pixelformat
) {
711 case V4L2_SDR_FMT_CU8
:
712 reg7
= 0x000c9407; /* 504 */
714 case V4L2_SDR_FMT_CU16LE
:
715 reg7
= 0x00009407; /* 252 */
717 case V4L2_SDR_FMT_CS8
:
718 reg7
= 0x000c9407; /* 504 */
720 case MSI2500_PIX_FMT_SDR_MSI2500_384
:
721 reg7
= 0x0000a507; /* 384 */
723 case MSI2500_PIX_FMT_SDR_S12
:
724 reg7
= 0x00008507; /* 336 */
726 case V4L2_SDR_FMT_CS14LE
:
727 reg7
= 0x00009407; /* 252 */
730 reg7
= 0x000c9407; /* 504 */
735 * Fractional-N synthesizer
737 * +----------------------------------------+
739 * Fref +----+ +-------+ +-----+ +------+ +---+
740 * ------> | PD | --> | VCO | --> | /2 | ------> | /N.F | <-- | K |
741 * +----+ +-------+ +-----+ +------+ +---+
745 * +-------+ +-----+ Fout
746 * | /Rout | --> | /12 | ------>
750 * Synthesizer config is just a educated guess...
752 * [7:0] 0x03, register address
753 * [8] 1, power control
754 * [9] ?, power control
755 * [12:10] output divider
758 * [15] fractional MSB, bit 20
774 * VCO 202000000 - 720000000++
777 #define F_REF 24000000
779 #define DIV_LO_OUT 12
783 /* XXX: Filters? AGC? VCO band? */
786 else if (f_sr
< 7000000)
788 else if (f_sr
< 8500000)
793 for (div_out
= 4; div_out
< 16; div_out
+= 2) {
794 f_vco
= f_sr
* div_out
* DIV_LO_OUT
;
795 dev_dbg(dev
->dev
, "div_out=%u f_vco=%u\n", div_out
, f_vco
);
796 if (f_vco
>= 202000000)
800 /* Calculate PLL integer and fractional control word. */
801 div_n
= div_u64_rem(f_vco
, DIV_PRE_N
* F_REF
, &k
);
802 k_cw
= div_u64((u64
) k
* 0x200000, DIV_PRE_N
* F_REF
);
805 reg3
|= (div_out
/ 2 - 1) << 10;
806 reg3
|= ((k_cw
>> 20) & 0x000001) << 15; /* [20] */
807 reg4
|= ((k_cw
>> 0) & 0x0fffff) << 8; /* [19:0] */
810 "f_sr=%u f_vco=%u div_n=%u k=%u div_out=%u reg3=%08x reg4=%08x\n",
811 f_sr
, f_vco
, div_n
, k
, div_out
, reg3
, reg4
);
813 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, 0x00608008);
817 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, 0x00000c05);
821 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, 0x00020000);
825 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, 0x00480102);
829 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, 0x00f38008);
833 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, reg7
);
837 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, reg4
);
841 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, reg3
);
846 static int msi2500_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
848 struct msi2500_dev
*dev
= vb2_get_drv_priv(vq
);
851 dev_dbg(dev
->dev
, "\n");
856 if (mutex_lock_interruptible(&dev
->v4l2_lock
))
860 v4l2_subdev_call(dev
->v4l2_subdev
, core
, s_power
, 1);
862 ret
= msi2500_set_usb_adc(dev
);
864 ret
= msi2500_isoc_init(dev
);
866 msi2500_cleanup_queued_bufs(dev
);
868 ret
= msi2500_ctrl_msg(dev
, CMD_START_STREAMING
, 0);
870 mutex_unlock(&dev
->v4l2_lock
);
875 static void msi2500_stop_streaming(struct vb2_queue
*vq
)
877 struct msi2500_dev
*dev
= vb2_get_drv_priv(vq
);
879 dev_dbg(dev
->dev
, "\n");
881 mutex_lock(&dev
->v4l2_lock
);
884 msi2500_isoc_cleanup(dev
);
886 msi2500_cleanup_queued_bufs(dev
);
888 /* according to tests, at least 700us delay is required */
890 if (!msi2500_ctrl_msg(dev
, CMD_STOP_STREAMING
, 0)) {
891 /* sleep USB IF / ADC */
892 msi2500_ctrl_msg(dev
, CMD_WREG
, 0x01000003);
896 v4l2_subdev_call(dev
->v4l2_subdev
, core
, s_power
, 0);
898 mutex_unlock(&dev
->v4l2_lock
);
901 static struct vb2_ops msi2500_vb2_ops
= {
902 .queue_setup
= msi2500_queue_setup
,
903 .buf_queue
= msi2500_buf_queue
,
904 .start_streaming
= msi2500_start_streaming
,
905 .stop_streaming
= msi2500_stop_streaming
,
906 .wait_prepare
= vb2_ops_wait_prepare
,
907 .wait_finish
= vb2_ops_wait_finish
,
910 static int msi2500_enum_fmt_sdr_cap(struct file
*file
, void *priv
,
911 struct v4l2_fmtdesc
*f
)
913 struct msi2500_dev
*dev
= video_drvdata(file
);
915 dev_dbg(dev
->dev
, "index=%d\n", f
->index
);
917 if (f
->index
>= dev
->num_formats
)
920 strlcpy(f
->description
, formats
[f
->index
].name
, sizeof(f
->description
));
921 f
->pixelformat
= formats
[f
->index
].pixelformat
;
926 static int msi2500_g_fmt_sdr_cap(struct file
*file
, void *priv
,
927 struct v4l2_format
*f
)
929 struct msi2500_dev
*dev
= video_drvdata(file
);
931 dev_dbg(dev
->dev
, "pixelformat fourcc %4.4s\n",
932 (char *)&dev
->pixelformat
);
934 f
->fmt
.sdr
.pixelformat
= dev
->pixelformat
;
935 f
->fmt
.sdr
.buffersize
= dev
->buffersize
;
936 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
941 static int msi2500_s_fmt_sdr_cap(struct file
*file
, void *priv
,
942 struct v4l2_format
*f
)
944 struct msi2500_dev
*dev
= video_drvdata(file
);
945 struct vb2_queue
*q
= &dev
->vb_queue
;
948 dev_dbg(dev
->dev
, "pixelformat fourcc %4.4s\n",
949 (char *)&f
->fmt
.sdr
.pixelformat
);
954 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
955 for (i
= 0; i
< dev
->num_formats
; i
++) {
956 if (formats
[i
].pixelformat
== f
->fmt
.sdr
.pixelformat
) {
957 dev
->pixelformat
= formats
[i
].pixelformat
;
958 dev
->buffersize
= formats
[i
].buffersize
;
959 f
->fmt
.sdr
.buffersize
= formats
[i
].buffersize
;
964 dev
->pixelformat
= formats
[0].pixelformat
;
965 dev
->buffersize
= formats
[0].buffersize
;
966 f
->fmt
.sdr
.pixelformat
= formats
[0].pixelformat
;
967 f
->fmt
.sdr
.buffersize
= formats
[0].buffersize
;
972 static int msi2500_try_fmt_sdr_cap(struct file
*file
, void *priv
,
973 struct v4l2_format
*f
)
975 struct msi2500_dev
*dev
= video_drvdata(file
);
978 dev_dbg(dev
->dev
, "pixelformat fourcc %4.4s\n",
979 (char *)&f
->fmt
.sdr
.pixelformat
);
981 memset(f
->fmt
.sdr
.reserved
, 0, sizeof(f
->fmt
.sdr
.reserved
));
982 for (i
= 0; i
< dev
->num_formats
; i
++) {
983 if (formats
[i
].pixelformat
== f
->fmt
.sdr
.pixelformat
) {
984 f
->fmt
.sdr
.buffersize
= formats
[i
].buffersize
;
989 f
->fmt
.sdr
.pixelformat
= formats
[0].pixelformat
;
990 f
->fmt
.sdr
.buffersize
= formats
[0].buffersize
;
995 static int msi2500_s_tuner(struct file
*file
, void *priv
,
996 const struct v4l2_tuner
*v
)
998 struct msi2500_dev
*dev
= video_drvdata(file
);
1001 dev_dbg(dev
->dev
, "index=%d\n", v
->index
);
1005 else if (v
->index
== 1)
1006 ret
= v4l2_subdev_call(dev
->v4l2_subdev
, tuner
, s_tuner
, v
);
1013 static int msi2500_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*v
)
1015 struct msi2500_dev
*dev
= video_drvdata(file
);
1018 dev_dbg(dev
->dev
, "index=%d\n", v
->index
);
1020 if (v
->index
== 0) {
1021 strlcpy(v
->name
, "Mirics MSi2500", sizeof(v
->name
));
1022 v
->type
= V4L2_TUNER_ADC
;
1023 v
->capability
= V4L2_TUNER_CAP_1HZ
| V4L2_TUNER_CAP_FREQ_BANDS
;
1024 v
->rangelow
= 1200000;
1025 v
->rangehigh
= 15000000;
1027 } else if (v
->index
== 1) {
1028 ret
= v4l2_subdev_call(dev
->v4l2_subdev
, tuner
, g_tuner
, v
);
1036 static int msi2500_g_frequency(struct file
*file
, void *priv
,
1037 struct v4l2_frequency
*f
)
1039 struct msi2500_dev
*dev
= video_drvdata(file
);
1042 dev_dbg(dev
->dev
, "tuner=%d type=%d\n", f
->tuner
, f
->type
);
1044 if (f
->tuner
== 0) {
1045 f
->frequency
= dev
->f_adc
;
1047 } else if (f
->tuner
== 1) {
1048 f
->type
= V4L2_TUNER_RF
;
1049 ret
= v4l2_subdev_call(dev
->v4l2_subdev
, tuner
, g_frequency
, f
);
1057 static int msi2500_s_frequency(struct file
*file
, void *priv
,
1058 const struct v4l2_frequency
*f
)
1060 struct msi2500_dev
*dev
= video_drvdata(file
);
1063 dev_dbg(dev
->dev
, "tuner=%d type=%d frequency=%u\n",
1064 f
->tuner
, f
->type
, f
->frequency
);
1066 if (f
->tuner
== 0) {
1067 dev
->f_adc
= clamp_t(unsigned int, f
->frequency
,
1069 bands
[0].rangehigh
);
1070 dev_dbg(dev
->dev
, "ADC frequency=%u Hz\n", dev
->f_adc
);
1071 ret
= msi2500_set_usb_adc(dev
);
1072 } else if (f
->tuner
== 1) {
1073 ret
= v4l2_subdev_call(dev
->v4l2_subdev
, tuner
, s_frequency
, f
);
1081 static int msi2500_enum_freq_bands(struct file
*file
, void *priv
,
1082 struct v4l2_frequency_band
*band
)
1084 struct msi2500_dev
*dev
= video_drvdata(file
);
1087 dev_dbg(dev
->dev
, "tuner=%d type=%d index=%d\n",
1088 band
->tuner
, band
->type
, band
->index
);
1090 if (band
->tuner
== 0) {
1091 if (band
->index
>= ARRAY_SIZE(bands
)) {
1094 *band
= bands
[band
->index
];
1097 } else if (band
->tuner
== 1) {
1098 ret
= v4l2_subdev_call(dev
->v4l2_subdev
, tuner
,
1099 enum_freq_bands
, band
);
1107 static const struct v4l2_ioctl_ops msi2500_ioctl_ops
= {
1108 .vidioc_querycap
= msi2500_querycap
,
1110 .vidioc_enum_fmt_sdr_cap
= msi2500_enum_fmt_sdr_cap
,
1111 .vidioc_g_fmt_sdr_cap
= msi2500_g_fmt_sdr_cap
,
1112 .vidioc_s_fmt_sdr_cap
= msi2500_s_fmt_sdr_cap
,
1113 .vidioc_try_fmt_sdr_cap
= msi2500_try_fmt_sdr_cap
,
1115 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1116 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
1117 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
1118 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1119 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1120 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1122 .vidioc_streamon
= vb2_ioctl_streamon
,
1123 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1125 .vidioc_g_tuner
= msi2500_g_tuner
,
1126 .vidioc_s_tuner
= msi2500_s_tuner
,
1128 .vidioc_g_frequency
= msi2500_g_frequency
,
1129 .vidioc_s_frequency
= msi2500_s_frequency
,
1130 .vidioc_enum_freq_bands
= msi2500_enum_freq_bands
,
1132 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1133 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1134 .vidioc_log_status
= v4l2_ctrl_log_status
,
1137 static const struct v4l2_file_operations msi2500_fops
= {
1138 .owner
= THIS_MODULE
,
1139 .open
= v4l2_fh_open
,
1140 .release
= vb2_fop_release
,
1141 .read
= vb2_fop_read
,
1142 .poll
= vb2_fop_poll
,
1143 .mmap
= vb2_fop_mmap
,
1144 .unlocked_ioctl
= video_ioctl2
,
1147 static struct video_device msi2500_template
= {
1148 .name
= "Mirics MSi3101 SDR Dongle",
1149 .release
= video_device_release_empty
,
1150 .fops
= &msi2500_fops
,
1151 .ioctl_ops
= &msi2500_ioctl_ops
,
1154 static void msi2500_video_release(struct v4l2_device
*v
)
1156 struct msi2500_dev
*dev
= container_of(v
, struct msi2500_dev
, v4l2_dev
);
1158 v4l2_ctrl_handler_free(&dev
->hdl
);
1159 v4l2_device_unregister(&dev
->v4l2_dev
);
1163 static int msi2500_transfer_one_message(struct spi_master
*master
,
1164 struct spi_message
*m
)
1166 struct msi2500_dev
*dev
= spi_master_get_devdata(master
);
1167 struct spi_transfer
*t
;
1171 list_for_each_entry(t
, &m
->transfers
, transfer_list
) {
1172 dev_dbg(dev
->dev
, "msg=%*ph\n", t
->len
, t
->tx_buf
);
1173 data
= 0x09; /* reg 9 is SPI adapter */
1174 data
|= ((u8
*)t
->tx_buf
)[0] << 8;
1175 data
|= ((u8
*)t
->tx_buf
)[1] << 16;
1176 data
|= ((u8
*)t
->tx_buf
)[2] << 24;
1177 ret
= msi2500_ctrl_msg(dev
, CMD_WREG
, data
);
1181 spi_finalize_current_message(master
);
1185 static int msi2500_probe(struct usb_interface
*intf
,
1186 const struct usb_device_id
*id
)
1188 struct msi2500_dev
*dev
;
1189 struct v4l2_subdev
*sd
;
1190 struct spi_master
*master
;
1192 static struct spi_board_info board_info
= {
1193 .modalias
= "msi001",
1196 .max_speed_hz
= 12000000,
1199 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1205 mutex_init(&dev
->v4l2_lock
);
1206 mutex_init(&dev
->vb_queue_lock
);
1207 spin_lock_init(&dev
->queued_bufs_lock
);
1208 INIT_LIST_HEAD(&dev
->queued_bufs
);
1209 dev
->dev
= &intf
->dev
;
1210 dev
->udev
= interface_to_usbdev(intf
);
1211 dev
->f_adc
= bands
[0].rangelow
;
1212 dev
->pixelformat
= formats
[0].pixelformat
;
1213 dev
->buffersize
= formats
[0].buffersize
;
1214 dev
->num_formats
= NUM_FORMATS
;
1215 if (!msi2500_emulated_fmt
)
1216 dev
->num_formats
-= 2;
1218 /* Init videobuf2 queue structure */
1219 dev
->vb_queue
.type
= V4L2_BUF_TYPE_SDR_CAPTURE
;
1220 dev
->vb_queue
.io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_READ
;
1221 dev
->vb_queue
.drv_priv
= dev
;
1222 dev
->vb_queue
.buf_struct_size
= sizeof(struct msi2500_frame_buf
);
1223 dev
->vb_queue
.ops
= &msi2500_vb2_ops
;
1224 dev
->vb_queue
.mem_ops
= &vb2_vmalloc_memops
;
1225 dev
->vb_queue
.timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1226 ret
= vb2_queue_init(&dev
->vb_queue
);
1228 dev_err(dev
->dev
, "Could not initialize vb2 queue\n");
1232 /* Init video_device structure */
1233 dev
->vdev
= msi2500_template
;
1234 dev
->vdev
.queue
= &dev
->vb_queue
;
1235 dev
->vdev
.queue
->lock
= &dev
->vb_queue_lock
;
1236 video_set_drvdata(&dev
->vdev
, dev
);
1238 /* Register the v4l2_device structure */
1239 dev
->v4l2_dev
.release
= msi2500_video_release
;
1240 ret
= v4l2_device_register(&intf
->dev
, &dev
->v4l2_dev
);
1242 dev_err(dev
->dev
, "Failed to register v4l2-device (%d)\n", ret
);
1246 /* SPI master adapter */
1247 master
= spi_alloc_master(dev
->dev
, 0);
1248 if (master
== NULL
) {
1250 goto err_unregister_v4l2_dev
;
1253 dev
->master
= master
;
1254 master
->bus_num
= 0;
1255 master
->num_chipselect
= 1;
1256 master
->transfer_one_message
= msi2500_transfer_one_message
;
1257 spi_master_set_devdata(master
, dev
);
1258 ret
= spi_register_master(master
);
1260 spi_master_put(master
);
1261 goto err_unregister_v4l2_dev
;
1264 /* load v4l2 subdevice */
1265 sd
= v4l2_spi_new_subdev(&dev
->v4l2_dev
, master
, &board_info
);
1266 dev
->v4l2_subdev
= sd
;
1268 dev_err(dev
->dev
, "cannot get v4l2 subdevice\n");
1270 goto err_unregister_master
;
1273 /* Register controls */
1274 v4l2_ctrl_handler_init(&dev
->hdl
, 0);
1275 if (dev
->hdl
.error
) {
1276 ret
= dev
->hdl
.error
;
1277 dev_err(dev
->dev
, "Could not initialize controls\n");
1278 goto err_free_controls
;
1281 /* currently all controls are from subdev */
1282 v4l2_ctrl_add_handler(&dev
->hdl
, sd
->ctrl_handler
, NULL
);
1284 dev
->v4l2_dev
.ctrl_handler
= &dev
->hdl
;
1285 dev
->vdev
.v4l2_dev
= &dev
->v4l2_dev
;
1286 dev
->vdev
.lock
= &dev
->v4l2_lock
;
1288 ret
= video_register_device(&dev
->vdev
, VFL_TYPE_SDR
, -1);
1291 "Failed to register as video device (%d)\n", ret
);
1292 goto err_unregister_v4l2_dev
;
1294 dev_info(dev
->dev
, "Registered as %s\n",
1295 video_device_node_name(&dev
->vdev
));
1296 dev_notice(dev
->dev
,
1297 "SDR API is still slightly experimental and functionality changes may follow\n");
1300 v4l2_ctrl_handler_free(&dev
->hdl
);
1301 err_unregister_master
:
1302 spi_unregister_master(dev
->master
);
1303 err_unregister_v4l2_dev
:
1304 v4l2_device_unregister(&dev
->v4l2_dev
);
1311 /* USB device ID list */
1312 static struct usb_device_id msi2500_id_table
[] = {
1313 {USB_DEVICE(0x1df7, 0x2500)}, /* Mirics MSi3101 SDR Dongle */
1314 {USB_DEVICE(0x2040, 0xd300)}, /* Hauppauge WinTV 133559 LF */
1317 MODULE_DEVICE_TABLE(usb
, msi2500_id_table
);
1319 /* USB subsystem interface */
1320 static struct usb_driver msi2500_driver
= {
1321 .name
= KBUILD_MODNAME
,
1322 .probe
= msi2500_probe
,
1323 .disconnect
= msi2500_disconnect
,
1324 .id_table
= msi2500_id_table
,
1327 module_usb_driver(msi2500_driver
);
1329 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1330 MODULE_DESCRIPTION("Mirics MSi3101 SDR Dongle");
1331 MODULE_LICENSE("GPL");