?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[media] msi3101: a lot of small cleanups
[linux-2.6/btrfs-unstable.git] / drivers / staging / media / msi3101 / sdr-msi3101.c
bloba3cc4c6ebbc86a24c69e52e826b3c533b0c1f605
1 /*
2 * Mirics MSi3101 SDR Dongle driver
3 *
4 * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * That driver is somehow based of pwc driver:
21 * (C) 1999-2004 Nemosoft Unv.
22 * (C) 2004-2006 Luc Saillard (luc@saillard.org)
23 * (C) 2011 Hans de Goede <hdegoede@redhat.com>
24 *
25 * Development tree of that driver will be on:
26 * http://git.linuxtv.org/anttip/media_tree.git/shortlog/refs/heads/mirics
27 *
28 * GNU Radio plugin "gr-kernel" for device usage will be on:
29 * http://git.linuxtv.org/anttip/gr-kernel.git
30 *
31 * TODO:
32 * I will look these:
33 * - split RF tuner and USB ADC interface to own drivers (msi2500 and msi001)
34 * - move controls to V4L2 API
35 *
36 * Help is very highly welcome for these + all the others you could imagine:
37 * - use libv4l2 for stream format conversions
38 * - gr-kernel: switch to v4l2_mmap (current read eats a lot of cpu)
39 * - SDRSharp support
40 */
41
42 #include <linux/module.h>
43 #include <linux/slab.h>
44 #include <media/v4l2-device.h>
45 #include <media/v4l2-ioctl.h>
46 #include <media/v4l2-ctrls.h>
47 #include <media/v4l2-event.h>
48 #include <linux/usb.h>
49 #include <media/videobuf2-vmalloc.h>
50
51 struct msi3101_gain {
52 u8 tot:7;
53 u8 baseband:6;
54 bool lna:1;
55 bool mixer:1;
56 };
57
58 /* 60 – 120 MHz band, lna 24dB, mixer 19dB */
59 static const struct msi3101_gain msi3101_gain_lut_120[] = {
60 { 0, 0, 0, 0},
61 { 1, 1, 0, 0},
62 { 2, 2, 0, 0},
63 { 3, 3, 0, 0},
64 { 4, 4, 0, 0},
65 { 5, 5, 0, 0},
66 { 6, 6, 0, 0},
67 { 7, 7, 0, 0},
68 { 8, 8, 0, 0},
69 { 9, 9, 0, 0},
70 { 10, 10, 0, 0},
71 { 11, 11, 0, 0},
72 { 12, 12, 0, 0},
73 { 13, 13, 0, 0},
74 { 14, 14, 0, 0},
75 { 15, 15, 0, 0},
76 { 16, 16, 0, 0},
77 { 17, 17, 0, 0},
78 { 18, 18, 0, 0},
79 { 19, 19, 0, 0},
80 { 20, 20, 0, 0},
81 { 21, 21, 0, 0},
82 { 22, 22, 0, 0},
83 { 23, 23, 0, 0},
84 { 24, 24, 0, 0},
85 { 25, 25, 0, 0},
86 { 26, 26, 0, 0},
87 { 27, 27, 0, 0},
88 { 28, 28, 0, 0},
89 { 29, 5, 1, 0},
90 { 30, 6, 1, 0},
91 { 31, 7, 1, 0},
92 { 32, 8, 1, 0},
93 { 33, 9, 1, 0},
94 { 34, 10, 1, 0},
95 { 35, 11, 1, 0},
96 { 36, 12, 1, 0},
97 { 37, 13, 1, 0},
98 { 38, 14, 1, 0},
99 { 39, 15, 1, 0},
100 { 40, 16, 1, 0},
101 { 41, 17, 1, 0},
102 { 42, 18, 1, 0},
103 { 43, 19, 1, 0},
104 { 44, 20, 1, 0},
105 { 45, 21, 1, 0},
106 { 46, 22, 1, 0},
107 { 47, 23, 1, 0},
108 { 48, 24, 1, 0},
109 { 49, 25, 1, 0},
110 { 50, 26, 1, 0},
111 { 51, 27, 1, 0},
112 { 52, 28, 1, 0},
113 { 53, 29, 1, 0},
114 { 54, 30, 1, 0},
115 { 55, 31, 1, 0},
116 { 56, 32, 1, 0},
117 { 57, 33, 1, 0},
118 { 58, 34, 1, 0},
119 { 59, 35, 1, 0},
120 { 60, 36, 1, 0},
121 { 61, 37, 1, 0},
122 { 62, 38, 1, 0},
123 { 63, 39, 1, 0},
124 { 64, 40, 1, 0},
125 { 65, 41, 1, 0},
126 { 66, 42, 1, 0},
127 { 67, 43, 1, 0},
128 { 68, 44, 1, 0},
129 { 69, 45, 1, 0},
130 { 70, 46, 1, 0},
131 { 71, 47, 1, 0},
132 { 72, 48, 1, 0},
133 { 73, 49, 1, 0},
134 { 74, 50, 1, 0},
135 { 75, 51, 1, 0},
136 { 76, 52, 1, 0},
137 { 77, 53, 1, 0},
138 { 78, 54, 1, 0},
139 { 79, 55, 1, 0},
140 { 80, 56, 1, 0},
141 { 81, 57, 1, 0},
142 { 82, 58, 1, 0},
143 { 83, 40, 1, 1},
144 { 84, 41, 1, 1},
145 { 85, 42, 1, 1},
146 { 86, 43, 1, 1},
147 { 87, 44, 1, 1},
148 { 88, 45, 1, 1},
149 { 89, 46, 1, 1},
150 { 90, 47, 1, 1},
151 { 91, 48, 1, 1},
152 { 92, 49, 1, 1},
153 { 93, 50, 1, 1},
154 { 94, 51, 1, 1},
155 { 95, 52, 1, 1},
156 { 96, 53, 1, 1},
157 { 97, 54, 1, 1},
158 { 98, 55, 1, 1},
159 { 99, 56, 1, 1},
160 {100, 57, 1, 1},
161 {101, 58, 1, 1},
162 {102, 59, 1, 1},
163 };
164
165 /* 120 – 245 MHz band, lna 24dB, mixer 19dB */
166 static const struct msi3101_gain msi3101_gain_lut_245[] = {
167 { 0, 0, 0, 0},
168 { 1, 1, 0, 0},
169 { 2, 2, 0, 0},
170 { 3, 3, 0, 0},
171 { 4, 4, 0, 0},
172 { 5, 5, 0, 0},
173 { 6, 6, 0, 0},
174 { 7, 7, 0, 0},
175 { 8, 8, 0, 0},
176 { 9, 9, 0, 0},
177 { 10, 10, 0, 0},
178 { 11, 11, 0, 0},
179 { 12, 12, 0, 0},
180 { 13, 13, 0, 0},
181 { 14, 14, 0, 0},
182 { 15, 15, 0, 0},
183 { 16, 16, 0, 0},
184 { 17, 17, 0, 0},
185 { 18, 18, 0, 0},
186 { 19, 19, 0, 0},
187 { 20, 20, 0, 0},
188 { 21, 21, 0, 0},
189 { 22, 22, 0, 0},
190 { 23, 23, 0, 0},
191 { 24, 24, 0, 0},
192 { 25, 25, 0, 0},
193 { 26, 26, 0, 0},
194 { 27, 27, 0, 0},
195 { 28, 28, 0, 0},
196 { 29, 5, 1, 0},
197 { 30, 6, 1, 0},
198 { 31, 7, 1, 0},
199 { 32, 8, 1, 0},
200 { 33, 9, 1, 0},
201 { 34, 10, 1, 0},
202 { 35, 11, 1, 0},
203 { 36, 12, 1, 0},
204 { 37, 13, 1, 0},
205 { 38, 14, 1, 0},
206 { 39, 15, 1, 0},
207 { 40, 16, 1, 0},
208 { 41, 17, 1, 0},
209 { 42, 18, 1, 0},
210 { 43, 19, 1, 0},
211 { 44, 20, 1, 0},
212 { 45, 21, 1, 0},
213 { 46, 22, 1, 0},
214 { 47, 23, 1, 0},
215 { 48, 24, 1, 0},
216 { 49, 25, 1, 0},
217 { 50, 26, 1, 0},
218 { 51, 27, 1, 0},
219 { 52, 28, 1, 0},
220 { 53, 29, 1, 0},
221 { 54, 30, 1, 0},
222 { 55, 31, 1, 0},
223 { 56, 32, 1, 0},
224 { 57, 33, 1, 0},
225 { 58, 34, 1, 0},
226 { 59, 35, 1, 0},
227 { 60, 36, 1, 0},
228 { 61, 37, 1, 0},
229 { 62, 38, 1, 0},
230 { 63, 39, 1, 0},
231 { 64, 40, 1, 0},
232 { 65, 41, 1, 0},
233 { 66, 42, 1, 0},
234 { 67, 43, 1, 0},
235 { 68, 44, 1, 0},
236 { 69, 45, 1, 0},
237 { 70, 46, 1, 0},
238 { 71, 47, 1, 0},
239 { 72, 48, 1, 0},
240 { 73, 49, 1, 0},
241 { 74, 50, 1, 0},
242 { 75, 51, 1, 0},
243 { 76, 52, 1, 0},
244 { 77, 53, 1, 0},
245 { 78, 54, 1, 0},
246 { 79, 55, 1, 0},
247 { 80, 56, 1, 0},
248 { 81, 57, 1, 0},
249 { 82, 58, 1, 0},
250 { 83, 40, 1, 1},
251 { 84, 41, 1, 1},
252 { 85, 42, 1, 1},
253 { 86, 43, 1, 1},
254 { 87, 44, 1, 1},
255 { 88, 45, 1, 1},
256 { 89, 46, 1, 1},
257 { 90, 47, 1, 1},
258 { 91, 48, 1, 1},
259 { 92, 49, 1, 1},
260 { 93, 50, 1, 1},
261 { 94, 51, 1, 1},
262 { 95, 52, 1, 1},
263 { 96, 53, 1, 1},
264 { 97, 54, 1, 1},
265 { 98, 55, 1, 1},
266 { 99, 56, 1, 1},
267 {100, 57, 1, 1},
268 {101, 58, 1, 1},
269 {102, 59, 1, 1},
270 };
271
272 /* 420 – 1000 MHz band, lna 7dB, mixer 19dB */
273 static const struct msi3101_gain msi3101_gain_lut_1000[] = {
274 { 0, 0, 0, 0},
275 { 1, 1, 0, 0},
276 { 2, 2, 0, 0},
277 { 3, 3, 0, 0},
278 { 4, 4, 0, 0},
279 { 5, 5, 0, 0},
280 { 6, 6, 0, 0},
281 { 7, 7, 0, 0},
282 { 8, 8, 0, 0},
283 { 9, 9, 0, 0},
284 { 10, 10, 0, 0},
285 { 11, 11, 0, 0},
286 { 12, 5, 1, 0},
287 { 13, 6, 1, 0},
288 { 14, 7, 1, 0},
289 { 15, 8, 1, 0},
290 { 16, 9, 1, 0},
291 { 17, 10, 1, 0},
292 { 18, 11, 1, 0},
293 { 19, 12, 1, 0},
294 { 20, 13, 1, 0},
295 { 21, 14, 1, 0},
296 { 22, 15, 1, 0},
297 { 23, 16, 1, 0},
298 { 24, 17, 1, 0},
299 { 25, 18, 1, 0},
300 { 26, 19, 1, 0},
301 { 27, 20, 1, 0},
302 { 28, 21, 1, 0},
303 { 29, 22, 1, 0},
304 { 30, 23, 1, 0},
305 { 31, 24, 1, 0},
306 { 32, 25, 1, 0},
307 { 33, 26, 1, 0},
308 { 34, 27, 1, 0},
309 { 35, 28, 1, 0},
310 { 36, 29, 1, 0},
311 { 37, 30, 1, 0},
312 { 38, 31, 1, 0},
313 { 39, 32, 1, 0},
314 { 40, 33, 1, 0},
315 { 41, 34, 1, 0},
316 { 42, 35, 1, 0},
317 { 43, 36, 1, 0},
318 { 44, 37, 1, 0},
319 { 45, 38, 1, 0},
320 { 46, 39, 1, 0},
321 { 47, 40, 1, 0},
322 { 48, 41, 1, 0},
323 { 49, 42, 1, 0},
324 { 50, 43, 1, 0},
325 { 51, 44, 1, 0},
326 { 52, 45, 1, 0},
327 { 53, 46, 1, 0},
328 { 54, 47, 1, 0},
329 { 55, 48, 1, 0},
330 { 56, 49, 1, 0},
331 { 57, 50, 1, 0},
332 { 58, 51, 1, 0},
333 { 59, 52, 1, 0},
334 { 60, 53, 1, 0},
335 { 61, 54, 1, 0},
336 { 62, 55, 1, 0},
337 { 63, 56, 1, 0},
338 { 64, 57, 1, 0},
339 { 65, 58, 1, 0},
340 { 66, 40, 1, 1},
341 { 67, 41, 1, 1},
342 { 68, 42, 1, 1},
343 { 69, 43, 1, 1},
344 { 70, 44, 1, 1},
345 { 71, 45, 1, 1},
346 { 72, 46, 1, 1},
347 { 73, 47, 1, 1},
348 { 74, 48, 1, 1},
349 { 75, 49, 1, 1},
350 { 76, 50, 1, 1},
351 { 77, 51, 1, 1},
352 { 78, 52, 1, 1},
353 { 79, 53, 1, 1},
354 { 80, 54, 1, 1},
355 { 81, 55, 1, 1},
356 { 82, 56, 1, 1},
357 { 83, 57, 1, 1},
358 { 84, 58, 1, 1},
359 { 85, 59, 1, 1},
360 };
361
362 /*
363 * iConfiguration 0
364 * bInterfaceNumber 0
365 * bAlternateSetting 1
366 * bNumEndpoints 1
367 * bEndpointAddress 0x81 EP 1 IN
368 * bmAttributes 1
369 * Transfer Type Isochronous
370 * wMaxPacketSize 0x1400 3x 1024 bytes
371 * bInterval 1
372 */
373 #define MAX_ISO_BUFS (8)
374 #define ISO_FRAMES_PER_DESC (8)
375 #define ISO_MAX_FRAME_SIZE (3 * 1024)
376 #define ISO_BUFFER_SIZE (ISO_FRAMES_PER_DESC * ISO_MAX_FRAME_SIZE)
377 #define MAX_ISOC_ERRORS 20
378
379 /* TODO: These should be moved to V4L2 API */
380 #define MSI3101_CID_SAMPLING_MODE ((V4L2_CID_USER_BASE | 0xf000) + 0)
381 #define MSI3101_CID_SAMPLING_RATE ((V4L2_CID_USER_BASE | 0xf000) + 1)
382 #define MSI3101_CID_SAMPLING_RESOLUTION ((V4L2_CID_USER_BASE | 0xf000) + 2)
383 #define MSI3101_CID_TUNER_RF ((V4L2_CID_USER_BASE | 0xf000) + 10)
384 #define MSI3101_CID_TUNER_BW ((V4L2_CID_USER_BASE | 0xf000) + 11)
385 #define MSI3101_CID_TUNER_IF ((V4L2_CID_USER_BASE | 0xf000) + 12)
386 #define MSI3101_CID_TUNER_GAIN ((V4L2_CID_USER_BASE | 0xf000) + 13)
387
388 /* intermediate buffers with raw data from the USB device */
389 struct msi3101_frame_buf {
390 struct vb2_buffer vb; /* common v4l buffer stuff -- must be first */
391 struct list_head list;
392 };
393
394 struct msi3101_state {
395 struct video_device vdev;
396 struct v4l2_device v4l2_dev;
397
398 /* videobuf2 queue and queued buffers list */
399 struct vb2_queue vb_queue;
400 struct list_head queued_bufs;
401 spinlock_t queued_bufs_lock; /* Protects queued_bufs */
402
403 /* Note if taking both locks v4l2_lock must always be locked first! */
404 struct mutex v4l2_lock; /* Protects everything else */
405 struct mutex vb_queue_lock; /* Protects vb_queue and capt_file */
406
407 /* Pointer to our usb_device, will be NULL after unplug */
408 struct usb_device *udev; /* Both mutexes most be hold when setting! */
409
410 unsigned int isoc_errors; /* number of contiguous ISOC errors */
411 unsigned int vb_full; /* vb is full and packets dropped */
412
413 struct urb *urbs[MAX_ISO_BUFS];
414 int (*convert_stream) (struct msi3101_state *s, u32 *dst, u8 *src,
415 unsigned int src_len);
416
417 /* Controls */
418 struct v4l2_ctrl_handler ctrl_handler;
419 struct v4l2_ctrl *ctrl_sampling_rate;
420 struct v4l2_ctrl *ctrl_tuner_rf;
421 struct v4l2_ctrl *ctrl_tuner_bw;
422 struct v4l2_ctrl *ctrl_tuner_if;
423 struct v4l2_ctrl *ctrl_tuner_gain;
424
425 u32 next_sample; /* for track lost packets */
426 u32 sample; /* for sample rate calc */
427 unsigned long jiffies;
428 unsigned int sample_ctrl_bit[4];
429 };
430
431 /* Private functions */
432 static struct msi3101_frame_buf *msi3101_get_next_fill_buf(
433 struct msi3101_state *s)
434 {
435 unsigned long flags = 0;
436 struct msi3101_frame_buf *buf = NULL;
437
438 spin_lock_irqsave(&s->queued_bufs_lock, flags);
439 if (list_empty(&s->queued_bufs))
440 goto leave;
441
442 buf = list_entry(s->queued_bufs.next, struct msi3101_frame_buf, list);
443 list_del(&buf->list);
444 leave:
445 spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
446 return buf;
447 }
448
449 /*
450 * +===========================================================================
451 * | 00-1023 | USB packet
452 * +===========================================================================
453 * | 00- 03 | sequence number of first sample in that USB packet
454 * +---------------------------------------------------------------------------
455 * | 04- 15 | garbage
456 * +---------------------------------------------------------------------------
457 * | 16- 175 | samples
458 * +---------------------------------------------------------------------------
459 * | 176- 179 | control bits for previous samples
460 * +---------------------------------------------------------------------------
461 * | 180- 339 | samples
462 * +---------------------------------------------------------------------------
463 * | 340- 343 | control bits for previous samples
464 * +---------------------------------------------------------------------------
465 * | 344- 503 | samples
466 * +---------------------------------------------------------------------------
467 * | 504- 507 | control bits for previous samples
468 * +---------------------------------------------------------------------------
469 * | 508- 667 | samples
470 * +---------------------------------------------------------------------------
471 * | 668- 671 | control bits for previous samples
472 * +---------------------------------------------------------------------------
473 * | 672- 831 | samples
474 * +---------------------------------------------------------------------------
475 * | 832- 835 | control bits for previous samples
476 * +---------------------------------------------------------------------------
477 * | 836- 995 | samples
478 * +---------------------------------------------------------------------------
479 * | 996- 999 | control bits for previous samples
480 * +---------------------------------------------------------------------------
481 * | 1000-1023 | garbage
482 * +---------------------------------------------------------------------------
483 *
484 * Bytes 4 - 7 could have some meaning?
485 *
486 * Control bits for previous samples is 32-bit field, containing 16 x 2-bit
487 * numbers. This results one 2-bit number for 8 samples. It is likely used for
488 * for bit shifting sample by given bits, increasing actual sampling resolution.
489 * Number 2 (0b10) was never seen.
490 *
491 * 6 * 16 * 2 * 4 = 768 samples. 768 * 4 = 3072 bytes
492 */
493
494 /*
495 * Integer to 32-bit IEEE floating point representation routine is taken
496 * from Radeon R600 driver (drivers/gpu/drm/radeon/r600_blit_kms.c).
497 *
498 * TODO: Currently we do conversion here in Kernel, but in future that will
499 * be moved to the libv4l2 library as video format conversions are.
500 */
501 #define I2F_FRAC_BITS 23
502 #define I2F_MASK ((1 << I2F_FRAC_BITS) - 1)
503
504 /*
505 * Converts signed ~10+3-bit integer into 32-bit IEEE floating point
506 * representation.
507 */
508 static u32 msi3101_convert_sample_384(struct msi3101_state *s, u16 x, int shift)
509 {
510 u32 msb, exponent, fraction, sign;
511 s->sample_ctrl_bit[shift]++;
512
513 /* Zero is special */
514 if (!x)
515 return 0;
516
517 /* Convert 10-bit two's complement to 13-bit */
518 if (x & (1 << 9)) {
519 x |= ~0U << 10; /* set all the rest bits to one */
520 x <<= shift;
521 x = -x;
522 x &= 0xfff; /* result is 12 bit ... + sign */
523 sign = 1 << 31;
524 } else {
525 x <<= shift;
526 sign = 0 << 31;
527 }
528
529 /* Get location of the most significant bit */
530 msb = __fls(x);
531
532 fraction = ror32(x, (msb - I2F_FRAC_BITS) & 0x1f) & I2F_MASK;
533 exponent = (127 + msb) << I2F_FRAC_BITS;
534
535 return (fraction + exponent) | sign;
536 }
537
538 static int msi3101_convert_stream_384(struct msi3101_state *s, u32 *dst,
539 u8 *src, unsigned int src_len)
540 {
541 int i, j, k, l, i_max, dst_len = 0;
542 u16 sample[4];
543 u32 bits;
544 u32 sample_num[3];
545
546 /* There could be 1-3 1024 bytes URB frames */
547 i_max = src_len / 1024;
548 for (i = 0; i < i_max; i++) {
549 sample_num[i] = src[3] << 24 | src[2] << 16 | src[1] << 8 | src[0] << 0;
550 if (i == 0 && s->next_sample != sample_num[0]) {
551 dev_dbg_ratelimited(&s->udev->dev,
552 "%d samples lost, %d %08x:%08x\n",
553 sample_num[0] - s->next_sample,
554 src_len, s->next_sample, sample_num[0]);
555 }
556
557 /*
558 * Dump all unknown 'garbage' data - maybe we will discover
559 * someday if there is something rational...
560 */
561 dev_dbg_ratelimited(&s->udev->dev,
562 "%*ph %*ph\n", 12, &src[4], 24, &src[1000]);
563
564 src += 16;
565 for (j = 0; j < 6; j++) {
566 bits = src[160 + 3] << 24 | src[160 + 2] << 16 | src[160 + 1] << 8 | src[160 + 0] << 0;
567 for (k = 0; k < 16; k++) {
568 for (l = 0; l < 10; l += 5) {
569 sample[0] = (src[l + 0] & 0xff) >> 0 | (src[l + 1] & 0x03) << 8;
570 sample[1] = (src[l + 1] & 0xfc) >> 2 | (src[l + 2] & 0x0f) << 6;
571 sample[2] = (src[l + 2] & 0xf0) >> 4 | (src[l + 3] & 0x3f) << 4;
572 sample[3] = (src[l + 3] & 0xc0) >> 6 | (src[l + 4] & 0xff) << 2;
573
574 *dst++ = msi3101_convert_sample_384(s, sample[0], (bits >> (2 * k)) & 0x3);
575 *dst++ = msi3101_convert_sample_384(s, sample[1], (bits >> (2 * k)) & 0x3);
576 *dst++ = msi3101_convert_sample_384(s, sample[2], (bits >> (2 * k)) & 0x3);
577 *dst++ = msi3101_convert_sample_384(s, sample[3], (bits >> (2 * k)) & 0x3);
578 }
579 src += 10;
580 }
581 dev_dbg_ratelimited(&s->udev->dev,
582 "sample control bits %08x\n", bits);
583 src += 4;
584 }
585 /* 384 x I+Q 32bit float samples */
586 dst_len += 384 * 2 * 4;
587 src += 24;
588 }
589
590 /* calculate samping rate and output it in 10 seconds intervals */
591 if ((s->jiffies + msecs_to_jiffies(10000)) <= jiffies) {
592 unsigned long jiffies_now = jiffies;
593 unsigned long msecs = jiffies_to_msecs(jiffies_now) - jiffies_to_msecs(s->jiffies);
594 unsigned int samples = sample_num[i_max - 1] - s->sample;
595 s->jiffies = jiffies_now;
596 s->sample = sample_num[i_max - 1];
597 dev_dbg(&s->udev->dev,
598 "slen=%d samples=%u msecs=%lu sampling rate=%lu bits=%d.%d.%d.%d\n",
599 src_len, samples, msecs,
600 samples * 1000UL / msecs,
601 s->sample_ctrl_bit[0], s->sample_ctrl_bit[1],
602 s->sample_ctrl_bit[2], s->sample_ctrl_bit[3]);
603 }
604
605 /* next sample (sample = sample + i * 384) */
606 s->next_sample = sample_num[i_max - 1] + 384;
607
608 return dst_len;
609 }
610
611 /*
612 * Converts signed 12-bit integer into 32-bit IEEE floating point
613 * representation.
614 */
615 static u32 msi3101_convert_sample_336(struct msi3101_state *s, u16 x)
616 {
617 u32 msb, exponent, fraction, sign;
618
619 /* Zero is special */
620 if (!x)
621 return 0;
622
623 /* Negative / positive value */
624 if (x & (1 << 11)) {
625 x = -x;
626 x &= 0x7ff; /* result is 11 bit ... + sign */
627 sign = 1 << 31;
628 } else {
629 sign = 0 << 31;
630 }
631
632 /* Get location of the most significant bit */
633 msb = __fls(x);
634
635 fraction = ror32(x, (msb - I2F_FRAC_BITS) & 0x1f) & I2F_MASK;
636 exponent = (127 + msb) << I2F_FRAC_BITS;
637
638 return (fraction + exponent) | sign;
639 }
640
641 static int msi3101_convert_stream_336(struct msi3101_state *s, u32 *dst,
642 u8 *src, unsigned int src_len)
643 {
644 int i, j, i_max, dst_len = 0;
645 u16 sample[2];
646 u32 sample_num[3];
647
648 /* There could be 1-3 1024 bytes URB frames */
649 i_max = src_len / 1024;
650
651 for (i = 0; i < i_max; i++) {
652 sample_num[i] = src[3] << 24 | src[2] << 16 | src[1] << 8 | src[0] << 0;
653 if (i == 0 && s->next_sample != sample_num[0]) {
654 dev_dbg_ratelimited(&s->udev->dev,
655 "%d samples lost, %d %08x:%08x\n",
656 sample_num[0] - s->next_sample,
657 src_len, s->next_sample, sample_num[0]);
658 }
659
660 /*
661 * Dump all unknown 'garbage' data - maybe we will discover
662 * someday if there is something rational...
663 */
664 dev_dbg_ratelimited(&s->udev->dev, "%*ph\n", 12, &src[4]);
665
666 src += 16;
667 for (j = 0; j < 1008; j += 3) {
668 sample[0] = (src[j + 0] & 0xff) >> 0 | (src[j + 1] & 0x0f) << 8;
669 sample[1] = (src[j + 1] & 0xf0) >> 4 | (src[j + 2] & 0xff) << 4;
670
671 *dst++ = msi3101_convert_sample_336(s, sample[0]);
672 *dst++ = msi3101_convert_sample_336(s, sample[1]);
673 }
674 /* 336 x I+Q 32bit float samples */
675 dst_len += 336 * 2 * 4;
676 src += 1008;
677 }
678
679 /* calculate samping rate and output it in 10 seconds intervals */
680 if ((s->jiffies + msecs_to_jiffies(10000)) <= jiffies) {
681 unsigned long jiffies_now = jiffies;
682 unsigned long msecs = jiffies_to_msecs(jiffies_now) - jiffies_to_msecs(s->jiffies);
683 unsigned int samples = sample_num[i_max - 1] - s->sample;
684 s->jiffies = jiffies_now;
685 s->sample = sample_num[i_max - 1];
686 dev_dbg(&s->udev->dev,
687 "slen=%d samples=%u msecs=%lu sampling rate=%lu\n",
688 src_len, samples, msecs,
689 samples * 1000UL / msecs);
690 }
691
692 /* next sample (sample = sample + i * 336) */
693 s->next_sample = sample_num[i_max - 1] + 336;
694
695 return dst_len;
696 }
697
698 /*
699 * Converts signed 14-bit integer into 32-bit IEEE floating point
700 * representation.
701 */
702 static u32 msi3101_convert_sample_252(struct msi3101_state *s, u16 x)
703 {
704 u32 msb, exponent, fraction, sign;
705
706 /* Zero is special */
707 if (!x)
708 return 0;
709
710 /* Negative / positive value */
711 if (x & (1 << 13)) {
712 x = -x;
713 x &= 0x1fff; /* result is 13 bit ... + sign */
714 sign = 1 << 31;
715 } else {
716 sign = 0 << 31;
717 }
718
719 /* Get location of the most significant bit */
720 msb = __fls(x);
721
722 fraction = ror32(x, (msb - I2F_FRAC_BITS) & 0x1f) & I2F_MASK;
723 exponent = (127 + msb) << I2F_FRAC_BITS;
724
725 return (fraction + exponent) | sign;
726 }
727
728 static int msi3101_convert_stream_252(struct msi3101_state *s, u32 *dst,
729 u8 *src, unsigned int src_len)
730 {
731 int i, j, i_max, dst_len = 0;
732 u16 sample[2];
733 u32 sample_num[3];
734
735 /* There could be 1-3 1024 bytes URB frames */
736 i_max = src_len / 1024;
737
738 for (i = 0; i < i_max; i++) {
739 sample_num[i] = src[3] << 24 | src[2] << 16 | src[1] << 8 | src[0] << 0;
740 if (i == 0 && s->next_sample != sample_num[0]) {
741 dev_dbg_ratelimited(&s->udev->dev,
742 "%d samples lost, %d %08x:%08x\n",
743 sample_num[0] - s->next_sample,
744 src_len, s->next_sample, sample_num[0]);
745 }
746
747 /*
748 * Dump all unknown 'garbage' data - maybe we will discover
749 * someday if there is something rational...
750 */
751 dev_dbg_ratelimited(&s->udev->dev, "%*ph\n", 12, &src[4]);
752
753 src += 16;
754 for (j = 0; j < 1008; j += 4) {
755 sample[0] = src[j + 0] >> 0 | src[j + 1] << 8;
756 sample[1] = src[j + 2] >> 0 | src[j + 3] << 8;
757
758 *dst++ = msi3101_convert_sample_252(s, sample[0]);
759 *dst++ = msi3101_convert_sample_252(s, sample[1]);
760 }
761 /* 252 x I+Q 32bit float samples */
762 dst_len += 252 * 2 * 4;
763 src += 1008;
764 }
765
766 /* calculate samping rate and output it in 10 seconds intervals */
767 if ((s->jiffies + msecs_to_jiffies(10000)) <= jiffies) {
768 unsigned long jiffies_now = jiffies;
769 unsigned long msecs = jiffies_to_msecs(jiffies_now) - jiffies_to_msecs(s->jiffies);
770 unsigned int samples = sample_num[i_max - 1] - s->sample;
771 s->jiffies = jiffies_now;
772 s->sample = sample_num[i_max - 1];
773 dev_dbg(&s->udev->dev,
774 "slen=%d samples=%u msecs=%lu sampling rate=%lu\n",
775 src_len, samples, msecs,
776 samples * 1000UL / msecs);
777 }
778
779 /* next sample (sample = sample + i * 252) */
780 s->next_sample = sample_num[i_max - 1] + 252;
781
782 return dst_len;
783 }
784
785 /*
786 * This gets called for the Isochronous pipe (stream). This is done in interrupt
787 * time, so it has to be fast, not crash, and not stall. Neat.
788 */
789 static void msi3101_isoc_handler(struct urb *urb)
790 {
791 struct msi3101_state *s = (struct msi3101_state *)urb->context;
792 int i, flen, fstatus;
793 unsigned char *iso_buf = NULL;
794 struct msi3101_frame_buf *fbuf;
795
796 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
797 urb->status == -ESHUTDOWN) {
798 dev_dbg(&s->udev->dev, "URB (%p) unlinked %ssynchronuously\n",
799 urb, urb->status == -ENOENT ? "" : "a");
800 return;
801 }
802
803 if (urb->status != 0) {
804 dev_dbg(&s->udev->dev,
805 "msi3101_isoc_handler() called with status %d\n",
806 urb->status);
807 /* Give up after a number of contiguous errors */
808 if (++s->isoc_errors > MAX_ISOC_ERRORS)
809 dev_dbg(&s->udev->dev,
810 "Too many ISOC errors, bailing out\n");
811 goto handler_end;
812 } else {
813 /* Reset ISOC error counter. We did get here, after all. */
814 s->isoc_errors = 0;
815 }
816
817 /* Compact data */
818 for (i = 0; i < urb->number_of_packets; i++) {
819 void *ptr;
820
821 /* Check frame error */
822 fstatus = urb->iso_frame_desc[i].status;
823 if (fstatus) {
824 dev_dbg_ratelimited(&s->udev->dev,
825 "frame=%d/%d has error %d skipping\n",
826 i, urb->number_of_packets, fstatus);
827 goto skip;
828 }
829
830 /* Check if that frame contains data */
831 flen = urb->iso_frame_desc[i].actual_length;
832 if (flen == 0)
833 goto skip;
834
835 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
836
837 /* Get free framebuffer */
838 fbuf = msi3101_get_next_fill_buf(s);
839 if (fbuf == NULL) {
840 s->vb_full++;
841 dev_dbg_ratelimited(&s->udev->dev,
842 "videobuf is full, %d packets dropped\n",
843 s->vb_full);
844 goto skip;
845 }
846
847 /* fill framebuffer */
848 ptr = vb2_plane_vaddr(&fbuf->vb, 0);
849 flen = s->convert_stream(s, ptr, iso_buf, flen);
850 vb2_set_plane_payload(&fbuf->vb, 0, flen);
851 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
852 skip:
853 ;
854 }
855
856 handler_end:
857 i = usb_submit_urb(urb, GFP_ATOMIC);
858 if (i != 0)
859 dev_dbg(&s->udev->dev,
860 "Error (%d) re-submitting urb in msi3101_isoc_handler\n",
861 i);
862 }
863
864 static void msi3101_iso_stop(struct msi3101_state *s)
865 {
866 int i;
867 dev_dbg(&s->udev->dev, "%s:\n", __func__);
868
869 /* Unlinking ISOC buffers one by one */
870 for (i = 0; i < MAX_ISO_BUFS; i++) {
871 if (s->urbs[i]) {
872 dev_dbg(&s->udev->dev, "Unlinking URB %p\n",
873 s->urbs[i]);
874 usb_kill_urb(s->urbs[i]);
875 }
876 }
877 }
878
879 static void msi3101_iso_free(struct msi3101_state *s)
880 {
881 int i;
882 dev_dbg(&s->udev->dev, "%s:\n", __func__);
883
884 /* Freeing ISOC buffers one by one */
885 for (i = 0; i < MAX_ISO_BUFS; i++) {
886 if (s->urbs[i]) {
887 dev_dbg(&s->udev->dev, "Freeing URB\n");
888 if (s->urbs[i]->transfer_buffer) {
889 usb_free_coherent(s->udev,
890 s->urbs[i]->transfer_buffer_length,
891 s->urbs[i]->transfer_buffer,
892 s->urbs[i]->transfer_dma);
893 }
894 usb_free_urb(s->urbs[i]);
895 s->urbs[i] = NULL;
896 }
897 }
898 }
899
900 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
901 static void msi3101_isoc_cleanup(struct msi3101_state *s)
902 {
903 dev_dbg(&s->udev->dev, "%s:\n", __func__);
904
905 msi3101_iso_stop(s);
906 msi3101_iso_free(s);
907 }
908
909 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
910 static int msi3101_isoc_init(struct msi3101_state *s)
911 {
912 struct usb_device *udev;
913 struct urb *urb;
914 int i, j, ret;
915 dev_dbg(&s->udev->dev, "%s:\n", __func__);
916
917 s->isoc_errors = 0;
918 udev = s->udev;
919
920 ret = usb_set_interface(s->udev, 0, 1);
921 if (ret < 0)
922 return ret;
923
924 /* Allocate and init Isochronuous urbs */
925 for (i = 0; i < MAX_ISO_BUFS; i++) {
926 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
927 if (urb == NULL) {
928 dev_err(&s->udev->dev,
929 "Failed to allocate urb %d\n", i);
930 msi3101_isoc_cleanup(s);
931 return -ENOMEM;
932 }
933 s->urbs[i] = urb;
934 dev_dbg(&s->udev->dev, "Allocated URB at 0x%p\n", urb);
935
936 urb->interval = 1;
937 urb->dev = udev;
938 urb->pipe = usb_rcvisocpipe(udev, 0x81);
939 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
940 urb->transfer_buffer = usb_alloc_coherent(udev, ISO_BUFFER_SIZE,
941 GFP_KERNEL, &urb->transfer_dma);
942 if (urb->transfer_buffer == NULL) {
943 dev_err(&s->udev->dev,
944 "Failed to allocate urb buffer %d\n",
945 i);
946 msi3101_isoc_cleanup(s);
947 return -ENOMEM;
948 }
949 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
950 urb->complete = msi3101_isoc_handler;
951 urb->context = s;
952 urb->start_frame = 0;
953 urb->number_of_packets = ISO_FRAMES_PER_DESC;
954 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
955 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
956 urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
957 }
958 }
959
960 /* link */
961 for (i = 0; i < MAX_ISO_BUFS; i++) {
962 ret = usb_submit_urb(s->urbs[i], GFP_KERNEL);
963 if (ret) {
964 dev_err(&s->udev->dev,
965 "isoc_init() submit_urb %d failed with error %d\n",
966 i, ret);
967 msi3101_isoc_cleanup(s);
968 return ret;
969 }
970 dev_dbg(&s->udev->dev, "URB 0x%p submitted.\n", s->urbs[i]);
971 }
972
973 /* All is done... */
974 return 0;
975 }
976
977 /* Must be called with vb_queue_lock hold */
978 static void msi3101_cleanup_queued_bufs(struct msi3101_state *s)
979 {
980 unsigned long flags = 0;
981 dev_dbg(&s->udev->dev, "%s:\n", __func__);
982
983 spin_lock_irqsave(&s->queued_bufs_lock, flags);
984 while (!list_empty(&s->queued_bufs)) {
985 struct msi3101_frame_buf *buf;
986
987 buf = list_entry(s->queued_bufs.next, struct msi3101_frame_buf,
988 list);
989 list_del(&buf->list);
990 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
991 }
992 spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
993 }
994
995 /* The user yanked out the cable... */
996 static void msi3101_disconnect(struct usb_interface *intf)
997 {
998 struct v4l2_device *v = usb_get_intfdata(intf);
999 struct msi3101_state *s =
1000 container_of(v, struct msi3101_state, v4l2_dev);
1001 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1002
1003 mutex_lock(&s->vb_queue_lock);
1004 mutex_lock(&s->v4l2_lock);
1005 /* No need to keep the urbs around after disconnection */
1006 s->udev = NULL;
1007
1008 v4l2_device_disconnect(&s->v4l2_dev);
1009 video_unregister_device(&s->vdev);
1010 mutex_unlock(&s->v4l2_lock);
1011 mutex_unlock(&s->vb_queue_lock);
1012
1013 v4l2_device_put(&s->v4l2_dev);
1014 }
1015
1016 static int msi3101_querycap(struct file *file, void *fh,
1017 struct v4l2_capability *cap)
1018 {
1019 struct msi3101_state *s = video_drvdata(file);
1020 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1021
1022 strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
1023 strlcpy(cap->card, s->vdev.name, sizeof(cap->card));
1024 usb_make_path(s->udev, cap->bus_info, sizeof(cap->bus_info));
1025 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1026 V4L2_CAP_READWRITE;
1027 cap->device_caps = V4L2_CAP_TUNER;
1028 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1029 return 0;
1030 }
1031
1032
1033 /* Videobuf2 operations */
1034 static int msi3101_queue_setup(struct vb2_queue *vq,
1035 const struct v4l2_format *fmt, unsigned int *nbuffers,
1036 unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
1037 {
1038 struct msi3101_state *s = vb2_get_drv_priv(vq);
1039 dev_dbg(&s->udev->dev, "%s: *nbuffers=%d\n", __func__, *nbuffers);
1040
1041 /* Absolute min and max number of buffers available for mmap() */
1042 *nbuffers = 32;
1043 *nplanes = 1;
1044 sizes[0] = PAGE_ALIGN(3 * 3072); /* 3 * 768 * 4 */
1045 dev_dbg(&s->udev->dev, "%s: nbuffers=%d sizes[0]=%d\n",
1046 __func__, *nbuffers, sizes[0]);
1047 return 0;
1048 }
1049
1050 static int msi3101_buf_prepare(struct vb2_buffer *vb)
1051 {
1052 struct msi3101_state *s = vb2_get_drv_priv(vb->vb2_queue);
1053
1054 /* Don't allow queing new buffers after device disconnection */
1055 if (!s->udev)
1056 return -ENODEV;
1057
1058 return 0;
1059 }
1060
1061 static void msi3101_buf_queue(struct vb2_buffer *vb)
1062 {
1063 struct msi3101_state *s = vb2_get_drv_priv(vb->vb2_queue);
1064 struct msi3101_frame_buf *buf =
1065 container_of(vb, struct msi3101_frame_buf, vb);
1066 unsigned long flags = 0;
1067
1068 /* Check the device has not disconnected between prep and queuing */
1069 if (!s->udev) {
1070 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
1071 return;
1072 }
1073
1074 spin_lock_irqsave(&s->queued_bufs_lock, flags);
1075 list_add_tail(&buf->list, &s->queued_bufs);
1076 spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
1077 }
1078
1079 #define CMD_WREG 0x41
1080 #define CMD_START_STREAMING 0x43
1081 #define CMD_STOP_STREAMING 0x45
1082 #define CMD_READ_UNKNOW 0x48
1083
1084 #define msi3101_dbg_usb_control_msg(udev, r, t, v, _i, b, l) { \
1085 char *direction; \
1086 if (t == (USB_TYPE_VENDOR | USB_DIR_OUT)) \
1087 direction = ">>>"; \
1088 else \
1089 direction = "<<<"; \
1090 dev_dbg(&udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \
1091 "%s %*ph\n", __func__, t, r, v & 0xff, v >> 8, \
1092 _i & 0xff, _i >> 8, l & 0xff, l >> 8, direction, l, b); \
1093 }
1094
1095 static int msi3101_ctrl_msg(struct msi3101_state *s, u8 cmd, u32 data)
1096 {
1097 int ret;
1098 u8 request = cmd;
1099 u8 requesttype = USB_DIR_OUT | USB_TYPE_VENDOR;
1100 u16 value = (data >> 0) & 0xffff;
1101 u16 index = (data >> 16) & 0xffff;
1102
1103 msi3101_dbg_usb_control_msg(s->udev,
1104 request, requesttype, value, index, NULL, 0);
1105
1106 ret = usb_control_msg(s->udev, usb_sndctrlpipe(s->udev, 0),
1107 request, requesttype, value, index, NULL, 0, 2000);
1108
1109 if (ret)
1110 dev_err(&s->udev->dev, "%s: failed %d, cmd %02x, data %04x\n",
1111 __func__, ret, cmd, data);
1112
1113 return ret;
1114 };
1115
1116 static int msi3101_tuner_write(struct msi3101_state *s, u32 data)
1117 {
1118 return msi3101_ctrl_msg(s, CMD_WREG, data << 8 | 0x09);
1119 };
1120
1121 #define F_REF 24000000
1122 #define DIV_R_IN 2
1123 static int msi3101_set_usb_adc(struct msi3101_state *s)
1124 {
1125 int ret, div_n, div_m, div_r_out, f_sr, f_vco, fract;
1126 u32 reg3, reg4, reg7;
1127
1128 f_sr = s->ctrl_sampling_rate->val64;
1129
1130 /* select stream format */
1131 if (f_sr < 6000000) {
1132 s->convert_stream = msi3101_convert_stream_252;
1133 reg7 = 0x00009407;
1134 } else if (f_sr < 8000000) {
1135 s->convert_stream = msi3101_convert_stream_336;
1136 reg7 = 0x00008507;
1137 } else {
1138 s->convert_stream = msi3101_convert_stream_384;
1139 reg7 = 0x0000a507;
1140 }
1141
1142 /*
1143 * Synthesizer config is just a educated guess...
1144 *
1145 * [7:0] 0x03, register address
1146 * [8] 1, always
1147 * [9] ?
1148 * [12:10] output divider
1149 * [13] 0 ?
1150 * [14] 0 ?
1151 * [15] fractional MSB, bit 20
1152 * [16:19] N
1153 * [23:20] ?
1154 * [24:31] 0x01
1155 *
1156 * output divider
1157 * val div
1158 * 0 - (invalid)
1159 * 1 4
1160 * 2 6
1161 * 3 8
1162 * 4 10
1163 * 5 12
1164 * 6 14
1165 * 7 16
1166 *
1167 * VCO 202000000 - 720000000++
1168 */
1169 reg3 = 0x01000303;
1170 reg4 = 0x00000004;
1171
1172 /* XXX: Filters? AGC? */
1173 if (f_sr < 6000000)
1174 reg3 |= 0x1 << 20;
1175 else if (f_sr < 7000000)
1176 reg3 |= 0x5 << 20;
1177 else if (f_sr < 8500000)
1178 reg3 |= 0x9 << 20;
1179 else
1180 reg3 |= 0xd << 20;
1181
1182 for (div_r_out = 4; div_r_out < 16; div_r_out += 2) {
1183 f_vco = f_sr * div_r_out * 12;
1184 dev_dbg(&s->udev->dev, "%s: div_r_out=%d f_vco=%d\n",
1185 __func__, div_r_out, f_vco);
1186 if (f_vco >= 202000000)
1187 break;
1188 }
1189
1190 div_n = f_vco / (F_REF * DIV_R_IN);
1191 div_m = f_vco % (F_REF * DIV_R_IN);
1192 fract = 0x200000ul * div_m / (F_REF * DIV_R_IN);
1193
1194 reg3 |= div_n << 16;
1195 reg3 |= (div_r_out / 2 - 1) << 10;
1196 reg3 |= ((fract >> 20) & 0x000001) << 15; /* [20] */
1197 reg4 |= ((fract >> 0) & 0x0fffff) << 8; /* [19:0] */
1198
1199 dev_dbg(&s->udev->dev,
1200 "%s: f_sr=%d f_vco=%d div_n=%d div_m=%d div_r_out=%d reg3=%08x reg4=%08x\n",
1201 __func__, f_sr, f_vco, div_n, div_m, div_r_out, reg3, reg4);
1202
1203 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00608008);
1204 if (ret)
1205 goto err;
1206
1207 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00000c05);
1208 if (ret)
1209 goto err;
1210
1211 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00020000);
1212 if (ret)
1213 goto err;
1214
1215 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00480102);
1216 if (ret)
1217 goto err;
1218
1219 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00f38008);
1220 if (ret)
1221 goto err;
1222
1223 ret = msi3101_ctrl_msg(s, CMD_WREG, reg7);
1224 if (ret)
1225 goto err;
1226
1227 ret = msi3101_ctrl_msg(s, CMD_WREG, reg4);
1228 if (ret)
1229 goto err;
1230
1231 ret = msi3101_ctrl_msg(s, CMD_WREG, reg3);
1232 if (ret)
1233 goto err;
1234 err:
1235 return ret;
1236 };
1237
1238 static int msi3101_set_tuner(struct msi3101_state *s)
1239 {
1240 int ret, i, len;
1241 unsigned int n, m, thresh, frac, vco_step, tmp;
1242 u32 reg;
1243 u64 f_vco;
1244 u8 mode, lo_div;
1245 const struct msi3101_gain *gain_lut;
1246 static const struct {
1247 u32 rf;
1248 u8 mode;
1249 u8 lo_div;
1250 } band_lut[] = {
1251 { 47000000, 0x01, 16}, /* AM_MODE1 */
1252 {108000000, 0x02, 32}, /* VHF_MODE */
1253 {330000000, 0x04, 16}, /* B3_MODE */
1254 {960000000, 0x08, 4}, /* B45_MODE */
1255 { ~0U, 0x10, 2}, /* BL_MODE */
1256 };
1257 static const struct {
1258 u32 freq;
1259 u8 val;
1260 } if_freq_lut[] = {
1261 { 0, 0x03}, /* Zero IF */
1262 { 450000, 0x02}, /* 450 kHz IF */
1263 {1620000, 0x01}, /* 1.62 MHz IF */
1264 {2048000, 0x00}, /* 2.048 MHz IF */
1265 };
1266 static const struct {
1267 u32 freq;
1268 u8 val;
1269 } bandwidth_lut[] = {
1270 { 200000, 0x00}, /* 200 kHz */
1271 { 300000, 0x01}, /* 300 kHz */
1272 { 600000, 0x02}, /* 600 kHz */
1273 {1536000, 0x03}, /* 1.536 MHz */
1274 {5000000, 0x04}, /* 5 MHz */
1275 {6000000, 0x05}, /* 6 MHz */
1276 {7000000, 0x06}, /* 7 MHz */
1277 {8000000, 0x07}, /* 8 MHz */
1278 };
1279
1280 unsigned int rf_freq = s->ctrl_tuner_rf->val64;
1281
1282 /*
1283 * bandwidth (Hz)
1284 * 200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000
1285 */
1286 int bandwidth = s->ctrl_tuner_bw->val;
1287
1288 /*
1289 * intermediate frequency (Hz)
1290 * 0, 450000, 1620000, 2048000
1291 */
1292 int if_freq = s->ctrl_tuner_if->val;
1293
1294 /*
1295 * gain reduction (dB)
1296 * 0 - 102 below 420 MHz
1297 * 0 - 85 above 420 MHz
1298 */
1299 int gain = s->ctrl_tuner_gain->val;
1300
1301 dev_dbg(&s->udev->dev,
1302 "%s: rf_freq=%d bandwidth=%d if_freq=%d gain=%d\n",
1303 __func__, rf_freq, bandwidth, if_freq, gain);
1304
1305 ret = -EINVAL;
1306
1307 for (i = 0; i < ARRAY_SIZE(band_lut); i++) {
1308 if (rf_freq <= band_lut[i].rf) {
1309 mode = band_lut[i].mode;
1310 lo_div = band_lut[i].lo_div;
1311 break;
1312 }
1313 }
1314
1315 if (i == ARRAY_SIZE(band_lut))
1316 goto err;
1317
1318 for (i = 0; i < ARRAY_SIZE(if_freq_lut); i++) {
1319 if (if_freq == if_freq_lut[i].freq) {
1320 if_freq = if_freq_lut[i].val;
1321 break;
1322 }
1323 }
1324
1325 if (i == ARRAY_SIZE(if_freq_lut))
1326 goto err;
1327
1328 for (i = 0; i < ARRAY_SIZE(bandwidth_lut); i++) {
1329 if (bandwidth == bandwidth_lut[i].freq) {
1330 bandwidth = bandwidth_lut[i].val;
1331 break;
1332 }
1333 }
1334
1335 if (i == ARRAY_SIZE(bandwidth_lut))
1336 goto err;
1337
1338 #define F_OUT_STEP 1
1339 #define R_REF 4
1340 #define F_IF 0
1341 f_vco = (rf_freq + F_IF) * lo_div;
1342 n = f_vco / (F_REF * R_REF);
1343 m = f_vco % (F_REF * R_REF);
1344
1345 vco_step = F_OUT_STEP * lo_div;
1346 thresh = (F_REF * R_REF) / vco_step;
1347 frac = 1ul * thresh * m / (F_REF * R_REF);
1348
1349 /* Divide to reg max. After that RF resolution will be +-500Hz. */
1350 tmp = DIV_ROUND_UP(thresh, 4095);
1351 thresh = DIV_ROUND_CLOSEST(thresh, tmp);
1352 frac = DIV_ROUND_CLOSEST(frac, tmp);
1353
1354 /* calc real RF set */
1355 tmp = 1ul * F_REF * R_REF * n;
1356 tmp += 1ul * F_REF * R_REF * frac / thresh;
1357 tmp /= lo_div;
1358
1359 dev_dbg(&s->udev->dev,
1360 "%s: rf=%u:%u n=%d thresh=%d frac=%d\n",
1361 __func__, rf_freq, tmp, n, thresh, frac);
1362
1363 ret = msi3101_tuner_write(s, 0x00000e);
1364 ret = msi3101_tuner_write(s, 0x000003);
1365
1366 reg = 0 << 0;
1367 reg |= mode << 4;
1368 reg |= 1 << 10;
1369 reg |= if_freq << 12;
1370 reg |= bandwidth << 14;
1371 reg |= 0x02 << 17;
1372 reg |= 0x00 << 20;
1373 ret = msi3101_tuner_write(s, reg);
1374 if (ret)
1375 goto err;
1376
1377 reg = 5 << 0;
1378 reg |= thresh << 4;
1379 reg |= 1 << 19;
1380 reg |= 1 << 21;
1381 ret = msi3101_tuner_write(s, reg);
1382 if (ret)
1383 goto err;
1384
1385 reg = 2 << 0;
1386 reg |= frac << 4;
1387 reg |= n << 16;
1388 ret = msi3101_tuner_write(s, reg);
1389 if (ret)
1390 goto err;
1391
1392 if (rf_freq < 120000000) {
1393 gain_lut = msi3101_gain_lut_120;
1394 len = ARRAY_SIZE(msi3101_gain_lut_120);
1395 } else if (rf_freq < 245000000) {
1396 gain_lut = msi3101_gain_lut_245;
1397 len = ARRAY_SIZE(msi3101_gain_lut_120);
1398 } else {
1399 gain_lut = msi3101_gain_lut_1000;
1400 len = ARRAY_SIZE(msi3101_gain_lut_1000);
1401 }
1402
1403 for (i = 0; i < len; i++) {
1404 if (gain_lut[i].tot >= gain)
1405 break;
1406 }
1407
1408 if (i == len)
1409 goto err;
1410
1411 dev_dbg(&s->udev->dev,
1412 "%s: gain tot=%d baseband=%d lna=%d mixer=%d\n",
1413 __func__, gain_lut[i].tot, gain_lut[i].baseband,
1414 gain_lut[i].lna, gain_lut[i].mixer);
1415
1416 reg = 1 << 0;
1417 reg |= gain_lut[i].baseband << 4;
1418 reg |= 0 << 10;
1419 reg |= gain_lut[i].mixer << 12;
1420 reg |= gain_lut[i].lna << 13;
1421 reg |= 4 << 14;
1422 reg |= 0 << 17;
1423 ret = msi3101_tuner_write(s, reg);
1424 if (ret)
1425 goto err;
1426
1427 reg = 6 << 0;
1428 reg |= 63 << 4;
1429 reg |= 4095 << 10;
1430 ret = msi3101_tuner_write(s, reg);
1431 if (ret)
1432 goto err;
1433
1434 return 0;
1435 err:
1436 dev_dbg(&s->udev->dev, "%s: failed %d\n", __func__, ret);
1437 return ret;
1438 };
1439
1440 static int msi3101_start_streaming(struct vb2_queue *vq, unsigned int count)
1441 {
1442 struct msi3101_state *s = vb2_get_drv_priv(vq);
1443 int ret;
1444 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1445
1446 if (!s->udev)
1447 return -ENODEV;
1448
1449 if (mutex_lock_interruptible(&s->v4l2_lock))
1450 return -ERESTARTSYS;
1451
1452 ret = msi3101_set_usb_adc(s);
1453
1454 ret = msi3101_isoc_init(s);
1455 if (ret)
1456 msi3101_cleanup_queued_bufs(s);
1457
1458 ret = msi3101_ctrl_msg(s, CMD_START_STREAMING, 0);
1459
1460 mutex_unlock(&s->v4l2_lock);
1461
1462 return ret;
1463 }
1464
1465 static int msi3101_stop_streaming(struct vb2_queue *vq)
1466 {
1467 struct msi3101_state *s = vb2_get_drv_priv(vq);
1468 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1469
1470 if (mutex_lock_interruptible(&s->v4l2_lock))
1471 return -ERESTARTSYS;
1472
1473 if (s->udev)
1474 msi3101_isoc_cleanup(s);
1475
1476 msi3101_cleanup_queued_bufs(s);
1477
1478 /* according to tests, at least 700us delay is required */
1479 msleep(20);
1480 msi3101_ctrl_msg(s, CMD_STOP_STREAMING, 0);
1481
1482 mutex_unlock(&s->v4l2_lock);
1483
1484 return 0;
1485 }
1486
1487 static struct vb2_ops msi3101_vb2_ops = {
1488 .queue_setup = msi3101_queue_setup,
1489 .buf_prepare = msi3101_buf_prepare,
1490 .buf_queue = msi3101_buf_queue,
1491 .start_streaming = msi3101_start_streaming,
1492 .stop_streaming = msi3101_stop_streaming,
1493 .wait_prepare = vb2_ops_wait_prepare,
1494 .wait_finish = vb2_ops_wait_finish,
1495 };
1496
1497 static int msi3101_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1498 {
1499 if (i->index != 0)
1500 return -EINVAL;
1501
1502 strlcpy(i->name, "SDR data", sizeof(i->name));
1503 i->type = V4L2_INPUT_TYPE_CAMERA;
1504
1505 return 0;
1506 }
1507
1508 static int msi3101_g_input(struct file *file, void *fh, unsigned int *i)
1509 {
1510 *i = 0;
1511
1512 return 0;
1513 }
1514
1515 static int msi3101_s_input(struct file *file, void *fh, unsigned int i)
1516 {
1517 return i ? -EINVAL : 0;
1518 }
1519
1520 static int vidioc_s_tuner(struct file *file, void *priv,
1521 const struct v4l2_tuner *v)
1522 {
1523 struct msi3101_state *s = video_drvdata(file);
1524 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1525
1526 return 0;
1527 }
1528
1529 static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
1530 {
1531 struct msi3101_state *s = video_drvdata(file);
1532 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1533
1534 strcpy(v->name, "SDR RX");
1535 v->capability = V4L2_TUNER_CAP_LOW;
1536
1537 return 0;
1538 }
1539
1540 static int vidioc_s_frequency(struct file *file, void *priv,
1541 const struct v4l2_frequency *f)
1542 {
1543 struct msi3101_state *s = video_drvdata(file);
1544 dev_dbg(&s->udev->dev, "%s: frequency=%lu Hz (%u)\n",
1545 __func__, f->frequency * 625UL / 10UL, f->frequency);
1546
1547 return v4l2_ctrl_s_ctrl_int64(s->ctrl_tuner_rf,
1548 f->frequency * 625UL / 10UL);
1549 }
1550
1551 const struct v4l2_ioctl_ops msi3101_ioctl_ops = {
1552 .vidioc_querycap = msi3101_querycap,
1553
1554 .vidioc_enum_input = msi3101_enum_input,
1555 .vidioc_g_input = msi3101_g_input,
1556 .vidioc_s_input = msi3101_s_input,
1557
1558 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1559 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1560 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1561 .vidioc_querybuf = vb2_ioctl_querybuf,
1562 .vidioc_qbuf = vb2_ioctl_qbuf,
1563 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1564
1565 .vidioc_streamon = vb2_ioctl_streamon,
1566 .vidioc_streamoff = vb2_ioctl_streamoff,
1567
1568 .vidioc_g_tuner = vidioc_g_tuner,
1569 .vidioc_s_tuner = vidioc_s_tuner,
1570 .vidioc_s_frequency = vidioc_s_frequency,
1571
1572 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1573 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1574 .vidioc_log_status = v4l2_ctrl_log_status,
1575 };
1576
1577 static const struct v4l2_file_operations msi3101_fops = {
1578 .owner = THIS_MODULE,
1579 .open = v4l2_fh_open,
1580 .release = vb2_fop_release,
1581 .read = vb2_fop_read,
1582 .poll = vb2_fop_poll,
1583 .mmap = vb2_fop_mmap,
1584 .unlocked_ioctl = video_ioctl2,
1585 };
1586
1587 static struct video_device msi3101_template = {
1588 .name = "Mirics MSi3101 SDR Dongle",
1589 .release = video_device_release_empty,
1590 .fops = &msi3101_fops,
1591 .ioctl_ops = &msi3101_ioctl_ops,
1592 };
1593
1594 static int msi3101_s_ctrl(struct v4l2_ctrl *ctrl)
1595 {
1596 struct msi3101_state *s =
1597 container_of(ctrl->handler, struct msi3101_state,
1598 ctrl_handler);
1599 int ret;
1600 dev_dbg(&s->udev->dev,
1601 "%s: id=%d name=%s val=%d min=%d max=%d step=%d\n",
1602 __func__, ctrl->id, ctrl->name, ctrl->val,
1603 ctrl->minimum, ctrl->maximum, ctrl->step);
1604
1605 switch (ctrl->id) {
1606 case MSI3101_CID_SAMPLING_MODE:
1607 case MSI3101_CID_SAMPLING_RATE:
1608 case MSI3101_CID_SAMPLING_RESOLUTION:
1609 ret = 0;
1610 break;
1611 case MSI3101_CID_TUNER_RF:
1612 case MSI3101_CID_TUNER_BW:
1613 case MSI3101_CID_TUNER_IF:
1614 case MSI3101_CID_TUNER_GAIN:
1615 ret = msi3101_set_tuner(s);
1616 break;
1617 default:
1618 ret = -EINVAL;
1619 }
1620
1621 return ret;
1622 }
1623
1624 static const struct v4l2_ctrl_ops msi3101_ctrl_ops = {
1625 .s_ctrl = msi3101_s_ctrl,
1626 };
1627
1628 static void msi3101_video_release(struct v4l2_device *v)
1629 {
1630 struct msi3101_state *s =
1631 container_of(v, struct msi3101_state, v4l2_dev);
1632
1633 v4l2_ctrl_handler_free(&s->ctrl_handler);
1634 v4l2_device_unregister(&s->v4l2_dev);
1635 kfree(s);
1636 }
1637
1638 static int msi3101_probe(struct usb_interface *intf,
1639 const struct usb_device_id *id)
1640 {
1641 struct usb_device *udev = interface_to_usbdev(intf);
1642 struct msi3101_state *s = NULL;
1643 int ret;
1644 static const char * const ctrl_sampling_mode_qmenu_strings[] = {
1645 "Quadrature Sampling",
1646 NULL,
1647 };
1648 static const struct v4l2_ctrl_config ctrl_sampling_mode = {
1649 .ops = &msi3101_ctrl_ops,
1650 .id = MSI3101_CID_SAMPLING_MODE,
1651 .type = V4L2_CTRL_TYPE_MENU,
1652 .flags = V4L2_CTRL_FLAG_INACTIVE,
1653 .name = "Sampling Mode",
1654 .qmenu = ctrl_sampling_mode_qmenu_strings,
1655 };
1656 static const struct v4l2_ctrl_config ctrl_sampling_rate = {
1657 .ops = &msi3101_ctrl_ops,
1658 .id = MSI3101_CID_SAMPLING_RATE,
1659 .type = V4L2_CTRL_TYPE_INTEGER64,
1660 .name = "Sampling Rate",
1661 .min = 500000,
1662 .max = 12000000,
1663 .def = 2048000,
1664 .step = 1,
1665 };
1666 static const struct v4l2_ctrl_config ctrl_sampling_resolution = {
1667 .ops = &msi3101_ctrl_ops,
1668 .id = MSI3101_CID_SAMPLING_RESOLUTION,
1669 .type = V4L2_CTRL_TYPE_INTEGER,
1670 .flags = V4L2_CTRL_FLAG_INACTIVE,
1671 .name = "Sampling Resolution",
1672 .min = 10,
1673 .max = 10,
1674 .def = 10,
1675 .step = 1,
1676 };
1677 static const struct v4l2_ctrl_config ctrl_tuner_rf = {
1678 .ops = &msi3101_ctrl_ops,
1679 .id = MSI3101_CID_TUNER_RF,
1680 .type = V4L2_CTRL_TYPE_INTEGER64,
1681 .name = "Tuner RF",
1682 .min = 40000000,
1683 .max = 2000000000,
1684 .def = 100000000,
1685 .step = 1,
1686 };
1687 static const struct v4l2_ctrl_config ctrl_tuner_bw = {
1688 .ops = &msi3101_ctrl_ops,
1689 .id = MSI3101_CID_TUNER_BW,
1690 .type = V4L2_CTRL_TYPE_INTEGER,
1691 .name = "Tuner BW",
1692 .min = 200000,
1693 .max = 8000000,
1694 .def = 600000,
1695 .step = 1,
1696 };
1697 static const struct v4l2_ctrl_config ctrl_tuner_if = {
1698 .ops = &msi3101_ctrl_ops,
1699 .id = MSI3101_CID_TUNER_IF,
1700 .type = V4L2_CTRL_TYPE_INTEGER,
1701 .flags = V4L2_CTRL_FLAG_INACTIVE,
1702 .name = "Tuner IF",
1703 .min = 0,
1704 .max = 2048000,
1705 .def = 0,
1706 .step = 1,
1707 };
1708 static const struct v4l2_ctrl_config ctrl_tuner_gain = {
1709 .ops = &msi3101_ctrl_ops,
1710 .id = MSI3101_CID_TUNER_GAIN,
1711 .type = V4L2_CTRL_TYPE_INTEGER,
1712 .name = "Tuner Gain",
1713 .min = 0,
1714 .max = 102,
1715 .def = 0,
1716 .step = 1,
1717 };
1718
1719 s = kzalloc(sizeof(struct msi3101_state), GFP_KERNEL);
1720 if (s == NULL) {
1721 pr_err("Could not allocate memory for msi3101_state\n");
1722 return -ENOMEM;
1723 }
1724
1725 mutex_init(&s->v4l2_lock);
1726 mutex_init(&s->vb_queue_lock);
1727 spin_lock_init(&s->queued_bufs_lock);
1728 INIT_LIST_HEAD(&s->queued_bufs);
1729
1730 s->udev = udev;
1731
1732 /* Init videobuf2 queue structure */
1733 s->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1734 s->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1735 s->vb_queue.drv_priv = s;
1736 s->vb_queue.buf_struct_size = sizeof(struct msi3101_frame_buf);
1737 s->vb_queue.ops = &msi3101_vb2_ops;
1738 s->vb_queue.mem_ops = &vb2_vmalloc_memops;
1739 s->vb_queue.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1740 ret = vb2_queue_init(&s->vb_queue);
1741 if (ret < 0) {
1742 dev_err(&s->udev->dev, "Could not initialize vb2 queue\n");
1743 goto err_free_mem;
1744 }
1745
1746 /* Init video_device structure */
1747 s->vdev = msi3101_template;
1748 s->vdev.queue = &s->vb_queue;
1749 s->vdev.queue->lock = &s->vb_queue_lock;
1750 set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev.flags);
1751 video_set_drvdata(&s->vdev, s);
1752
1753 /* Register controls */
1754 v4l2_ctrl_handler_init(&s->ctrl_handler, 7);
1755 v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_sampling_mode, NULL);
1756 s->ctrl_sampling_rate = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_sampling_rate, NULL);
1757 v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_sampling_resolution, NULL);
1758 s->ctrl_tuner_rf = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_tuner_rf, NULL);
1759 s->ctrl_tuner_bw = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_tuner_bw, NULL);
1760 s->ctrl_tuner_if = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_tuner_if, NULL);
1761 s->ctrl_tuner_gain = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_tuner_gain, NULL);
1762 if (s->ctrl_handler.error) {
1763 ret = s->ctrl_handler.error;
1764 dev_err(&s->udev->dev, "Could not initialize controls\n");
1765 goto err_free_controls;
1766 }
1767
1768 /* Register the v4l2_device structure */
1769 s->v4l2_dev.release = msi3101_video_release;
1770 ret = v4l2_device_register(&intf->dev, &s->v4l2_dev);
1771 if (ret) {
1772 dev_err(&s->udev->dev,
1773 "Failed to register v4l2-device (%d)\n", ret);
1774 goto err_free_controls;
1775 }
1776
1777 s->v4l2_dev.ctrl_handler = &s->ctrl_handler;
1778 s->vdev.v4l2_dev = &s->v4l2_dev;
1779 s->vdev.lock = &s->v4l2_lock;
1780
1781 ret = video_register_device(&s->vdev, VFL_TYPE_GRABBER, -1);
1782 if (ret < 0) {
1783 dev_err(&s->udev->dev,
1784 "Failed to register as video device (%d)\n",
1785 ret);
1786 goto err_unregister_v4l2_dev;
1787 }
1788 dev_info(&s->udev->dev, "Registered as %s\n",
1789 video_device_node_name(&s->vdev));
1790
1791 return 0;
1792
1793 err_unregister_v4l2_dev:
1794 v4l2_device_unregister(&s->v4l2_dev);
1795 err_free_controls:
1796 v4l2_ctrl_handler_free(&s->ctrl_handler);
1797 err_free_mem:
1798 kfree(s);
1799 return ret;
1800 }
1801
1802 /* USB device ID list */
1803 static struct usb_device_id msi3101_id_table[] = {
1804 { USB_DEVICE(0x1df7, 0x2500) }, /* Mirics MSi3101 SDR Dongle */
1805 { USB_DEVICE(0x2040, 0xd300) }, /* Hauppauge WinTV 133559 LF */
1806 { }
1807 };
1808 MODULE_DEVICE_TABLE(usb, msi3101_id_table);
1809
1810 /* USB subsystem interface */
1811 static struct usb_driver msi3101_driver = {
1812 .name = KBUILD_MODNAME,
1813 .probe = msi3101_probe,
1814 .disconnect = msi3101_disconnect,
1815 .id_table = msi3101_id_table,
1816 };
1817
1818 module_usb_driver(msi3101_driver);
1819
1820 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1821 MODULE_DESCRIPTION("Mirics MSi3101 SDR Dongle");
1822 MODULE_LICENSE("GPL");
(deprecated) Btrfs devel tree