?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[media] msi3101: implement stream format 504
[linux-2.6/btrfs-unstable.git] / drivers / staging / media / msi3101 / sdr-msi3101.c
blobbf735f9b5db9f75334a742e2729a0776b1791bc7
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 type '384'
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 8-bit integer into 32-bit IEEE floating point
506 * representation.
507 */
508 static u32 msi3101_convert_sample_504(struct msi3101_state *s, u16 x)
509 {
510 u32 msb, exponent, fraction, sign;
511
512 /* Zero is special */
513 if (!x)
514 return 0;
515
516 /* Negative / positive value */
517 if (x & (1 << 7)) {
518 x = -x;
519 x &= 0x7f; /* result is 7 bit ... + sign */
520 sign = 1 << 31;
521 } else {
522 sign = 0 << 31;
523 }
524
525 /* Get location of the most significant bit */
526 msb = __fls(x);
527
528 fraction = ror32(x, (msb - I2F_FRAC_BITS) & 0x1f) & I2F_MASK;
529 exponent = (127 + msb) << I2F_FRAC_BITS;
530
531 return (fraction + exponent) | sign;
532 }
533
534 static int msi3101_convert_stream_504(struct msi3101_state *s, u32 *dst,
535 u8 *src, unsigned int src_len)
536 {
537 int i, j, i_max, dst_len = 0;
538 u16 sample[2];
539 u32 sample_num[3];
540
541 /* There could be 1-3 1024 bytes URB frames */
542 i_max = src_len / 1024;
543
544 for (i = 0; i < i_max; i++) {
545 sample_num[i] = src[3] << 24 | src[2] << 16 | src[1] << 8 | src[0] << 0;
546 if (i == 0 && s->next_sample != sample_num[0]) {
547 dev_dbg_ratelimited(&s->udev->dev,
548 "%d samples lost, %d %08x:%08x\n",
549 sample_num[0] - s->next_sample,
550 src_len, s->next_sample, sample_num[0]);
551 }
552
553 /*
554 * Dump all unknown 'garbage' data - maybe we will discover
555 * someday if there is something rational...
556 */
557 dev_dbg_ratelimited(&s->udev->dev, "%*ph\n", 12, &src[4]);
558
559 src += 16;
560 for (j = 0; j < 1008; j += 2) {
561 sample[0] = src[j + 0];
562 sample[1] = src[j + 1];
563
564 *dst++ = msi3101_convert_sample_504(s, sample[0]);
565 *dst++ = msi3101_convert_sample_504(s, sample[1]);
566 }
567 /* 504 x I+Q 32bit float samples */
568 dst_len += 504 * 2 * 4;
569 src += 1008;
570 }
571
572 /* calculate samping rate and output it in 10 seconds intervals */
573 if ((s->jiffies + msecs_to_jiffies(10000)) <= jiffies) {
574 unsigned long jiffies_now = jiffies;
575 unsigned long msecs = jiffies_to_msecs(jiffies_now) - jiffies_to_msecs(s->jiffies);
576 unsigned int samples = sample_num[i_max - 1] - s->sample;
577 s->jiffies = jiffies_now;
578 s->sample = sample_num[i_max - 1];
579 dev_dbg(&s->udev->dev,
580 "slen=%d samples=%u msecs=%lu sampling rate=%lu\n",
581 src_len, samples, msecs,
582 samples * 1000UL / msecs);
583 }
584
585 /* next sample (sample = sample + i * 504) */
586 s->next_sample = sample_num[i_max - 1] + 504;
587
588 return dst_len;
589 }
590
591 /*
592 * Converts signed ~10+3-bit integer into 32-bit IEEE floating point
593 * representation.
594 */
595 static u32 msi3101_convert_sample_384(struct msi3101_state *s, u16 x, int shift)
596 {
597 u32 msb, exponent, fraction, sign;
598 s->sample_ctrl_bit[shift]++;
599
600 /* Zero is special */
601 if (!x)
602 return 0;
603
604 /* Convert 10-bit two's complement to 13-bit */
605 if (x & (1 << 9)) {
606 x |= ~0U << 10; /* set all the rest bits to one */
607 x <<= shift;
608 x = -x;
609 x &= 0xfff; /* result is 12 bit ... + sign */
610 sign = 1 << 31;
611 } else {
612 x <<= shift;
613 sign = 0 << 31;
614 }
615
616 /* Get location of the most significant bit */
617 msb = __fls(x);
618
619 fraction = ror32(x, (msb - I2F_FRAC_BITS) & 0x1f) & I2F_MASK;
620 exponent = (127 + msb) << I2F_FRAC_BITS;
621
622 return (fraction + exponent) | sign;
623 }
624
625 static int msi3101_convert_stream_384(struct msi3101_state *s, u32 *dst,
626 u8 *src, unsigned int src_len)
627 {
628 int i, j, k, l, i_max, dst_len = 0;
629 u16 sample[4];
630 u32 bits;
631 u32 sample_num[3];
632
633 /* There could be 1-3 1024 bytes URB frames */
634 i_max = src_len / 1024;
635 for (i = 0; i < i_max; i++) {
636 sample_num[i] = src[3] << 24 | src[2] << 16 | src[1] << 8 | src[0] << 0;
637 if (i == 0 && s->next_sample != sample_num[0]) {
638 dev_dbg_ratelimited(&s->udev->dev,
639 "%d samples lost, %d %08x:%08x\n",
640 sample_num[0] - s->next_sample,
641 src_len, s->next_sample, sample_num[0]);
642 }
643
644 /*
645 * Dump all unknown 'garbage' data - maybe we will discover
646 * someday if there is something rational...
647 */
648 dev_dbg_ratelimited(&s->udev->dev,
649 "%*ph %*ph\n", 12, &src[4], 24, &src[1000]);
650
651 src += 16;
652 for (j = 0; j < 6; j++) {
653 bits = src[160 + 3] << 24 | src[160 + 2] << 16 | src[160 + 1] << 8 | src[160 + 0] << 0;
654 for (k = 0; k < 16; k++) {
655 for (l = 0; l < 10; l += 5) {
656 sample[0] = (src[l + 0] & 0xff) >> 0 | (src[l + 1] & 0x03) << 8;
657 sample[1] = (src[l + 1] & 0xfc) >> 2 | (src[l + 2] & 0x0f) << 6;
658 sample[2] = (src[l + 2] & 0xf0) >> 4 | (src[l + 3] & 0x3f) << 4;
659 sample[3] = (src[l + 3] & 0xc0) >> 6 | (src[l + 4] & 0xff) << 2;
660
661 *dst++ = msi3101_convert_sample_384(s, sample[0], (bits >> (2 * k)) & 0x3);
662 *dst++ = msi3101_convert_sample_384(s, sample[1], (bits >> (2 * k)) & 0x3);
663 *dst++ = msi3101_convert_sample_384(s, sample[2], (bits >> (2 * k)) & 0x3);
664 *dst++ = msi3101_convert_sample_384(s, sample[3], (bits >> (2 * k)) & 0x3);
665 }
666 src += 10;
667 }
668 dev_dbg_ratelimited(&s->udev->dev,
669 "sample control bits %08x\n", bits);
670 src += 4;
671 }
672 /* 384 x I+Q 32bit float samples */
673 dst_len += 384 * 2 * 4;
674 src += 24;
675 }
676
677 /* calculate samping rate and output it in 10 seconds intervals */
678 if ((s->jiffies + msecs_to_jiffies(10000)) <= jiffies) {
679 unsigned long jiffies_now = jiffies;
680 unsigned long msecs = jiffies_to_msecs(jiffies_now) - jiffies_to_msecs(s->jiffies);
681 unsigned int samples = sample_num[i_max - 1] - s->sample;
682 s->jiffies = jiffies_now;
683 s->sample = sample_num[i_max - 1];
684 dev_dbg(&s->udev->dev,
685 "slen=%d samples=%u msecs=%lu sampling rate=%lu bits=%d.%d.%d.%d\n",
686 src_len, samples, msecs,
687 samples * 1000UL / msecs,
688 s->sample_ctrl_bit[0], s->sample_ctrl_bit[1],
689 s->sample_ctrl_bit[2], s->sample_ctrl_bit[3]);
690 }
691
692 /* next sample (sample = sample + i * 384) */
693 s->next_sample = sample_num[i_max - 1] + 384;
694
695 return dst_len;
696 }
697
698 /*
699 * Converts signed 12-bit integer into 32-bit IEEE floating point
700 * representation.
701 */
702 static u32 msi3101_convert_sample_336(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 << 11)) {
712 x = -x;
713 x &= 0x7ff; /* result is 11 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_336(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 += 3) {
755 sample[0] = (src[j + 0] & 0xff) >> 0 | (src[j + 1] & 0x0f) << 8;
756 sample[1] = (src[j + 1] & 0xf0) >> 4 | (src[j + 2] & 0xff) << 4;
757
758 *dst++ = msi3101_convert_sample_336(s, sample[0]);
759 *dst++ = msi3101_convert_sample_336(s, sample[1]);
760 }
761 /* 336 x I+Q 32bit float samples */
762 dst_len += 336 * 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 * 336) */
780 s->next_sample = sample_num[i_max - 1] + 336;
781
782 return dst_len;
783 }
784
785 /*
786 * Converts signed 14-bit integer into 32-bit IEEE floating point
787 * representation.
788 */
789 static u32 msi3101_convert_sample_252(struct msi3101_state *s, u16 x)
790 {
791 u32 msb, exponent, fraction, sign;
792
793 /* Zero is special */
794 if (!x)
795 return 0;
796
797 /* Negative / positive value */
798 if (x & (1 << 13)) {
799 x = -x;
800 x &= 0x1fff; /* result is 13 bit ... + sign */
801 sign = 1 << 31;
802 } else {
803 sign = 0 << 31;
804 }
805
806 /* Get location of the most significant bit */
807 msb = __fls(x);
808
809 fraction = ror32(x, (msb - I2F_FRAC_BITS) & 0x1f) & I2F_MASK;
810 exponent = (127 + msb) << I2F_FRAC_BITS;
811
812 return (fraction + exponent) | sign;
813 }
814
815 static int msi3101_convert_stream_252(struct msi3101_state *s, u32 *dst,
816 u8 *src, unsigned int src_len)
817 {
818 int i, j, i_max, dst_len = 0;
819 u16 sample[2];
820 u32 sample_num[3];
821
822 /* There could be 1-3 1024 bytes URB frames */
823 i_max = src_len / 1024;
824
825 for (i = 0; i < i_max; i++) {
826 sample_num[i] = src[3] << 24 | src[2] << 16 | src[1] << 8 | src[0] << 0;
827 if (i == 0 && s->next_sample != sample_num[0]) {
828 dev_dbg_ratelimited(&s->udev->dev,
829 "%d samples lost, %d %08x:%08x\n",
830 sample_num[0] - s->next_sample,
831 src_len, s->next_sample, sample_num[0]);
832 }
833
834 /*
835 * Dump all unknown 'garbage' data - maybe we will discover
836 * someday if there is something rational...
837 */
838 dev_dbg_ratelimited(&s->udev->dev, "%*ph\n", 12, &src[4]);
839
840 src += 16;
841 for (j = 0; j < 1008; j += 4) {
842 sample[0] = src[j + 0] >> 0 | src[j + 1] << 8;
843 sample[1] = src[j + 2] >> 0 | src[j + 3] << 8;
844
845 *dst++ = msi3101_convert_sample_252(s, sample[0]);
846 *dst++ = msi3101_convert_sample_252(s, sample[1]);
847 }
848 /* 252 x I+Q 32bit float samples */
849 dst_len += 252 * 2 * 4;
850 src += 1008;
851 }
852
853 /* calculate samping rate and output it in 10 seconds intervals */
854 if ((s->jiffies + msecs_to_jiffies(10000)) <= jiffies) {
855 unsigned long jiffies_now = jiffies;
856 unsigned long msecs = jiffies_to_msecs(jiffies_now) - jiffies_to_msecs(s->jiffies);
857 unsigned int samples = sample_num[i_max - 1] - s->sample;
858 s->jiffies = jiffies_now;
859 s->sample = sample_num[i_max - 1];
860 dev_dbg(&s->udev->dev,
861 "slen=%d samples=%u msecs=%lu sampling rate=%lu\n",
862 src_len, samples, msecs,
863 samples * 1000UL / msecs);
864 }
865
866 /* next sample (sample = sample + i * 252) */
867 s->next_sample = sample_num[i_max - 1] + 252;
868
869 return dst_len;
870 }
871
872 /*
873 * This gets called for the Isochronous pipe (stream). This is done in interrupt
874 * time, so it has to be fast, not crash, and not stall. Neat.
875 */
876 static void msi3101_isoc_handler(struct urb *urb)
877 {
878 struct msi3101_state *s = (struct msi3101_state *)urb->context;
879 int i, flen, fstatus;
880 unsigned char *iso_buf = NULL;
881 struct msi3101_frame_buf *fbuf;
882
883 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
884 urb->status == -ESHUTDOWN) {
885 dev_dbg(&s->udev->dev, "URB (%p) unlinked %ssynchronuously\n",
886 urb, urb->status == -ENOENT ? "" : "a");
887 return;
888 }
889
890 if (urb->status != 0) {
891 dev_dbg(&s->udev->dev,
892 "msi3101_isoc_handler() called with status %d\n",
893 urb->status);
894 /* Give up after a number of contiguous errors */
895 if (++s->isoc_errors > MAX_ISOC_ERRORS)
896 dev_dbg(&s->udev->dev,
897 "Too many ISOC errors, bailing out\n");
898 goto handler_end;
899 } else {
900 /* Reset ISOC error counter. We did get here, after all. */
901 s->isoc_errors = 0;
902 }
903
904 /* Compact data */
905 for (i = 0; i < urb->number_of_packets; i++) {
906 void *ptr;
907
908 /* Check frame error */
909 fstatus = urb->iso_frame_desc[i].status;
910 if (fstatus) {
911 dev_dbg_ratelimited(&s->udev->dev,
912 "frame=%d/%d has error %d skipping\n",
913 i, urb->number_of_packets, fstatus);
914 goto skip;
915 }
916
917 /* Check if that frame contains data */
918 flen = urb->iso_frame_desc[i].actual_length;
919 if (flen == 0)
920 goto skip;
921
922 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
923
924 /* Get free framebuffer */
925 fbuf = msi3101_get_next_fill_buf(s);
926 if (fbuf == NULL) {
927 s->vb_full++;
928 dev_dbg_ratelimited(&s->udev->dev,
929 "videobuf is full, %d packets dropped\n",
930 s->vb_full);
931 goto skip;
932 }
933
934 /* fill framebuffer */
935 ptr = vb2_plane_vaddr(&fbuf->vb, 0);
936 flen = s->convert_stream(s, ptr, iso_buf, flen);
937 vb2_set_plane_payload(&fbuf->vb, 0, flen);
938 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
939 skip:
940 ;
941 }
942
943 handler_end:
944 i = usb_submit_urb(urb, GFP_ATOMIC);
945 if (i != 0)
946 dev_dbg(&s->udev->dev,
947 "Error (%d) re-submitting urb in msi3101_isoc_handler\n",
948 i);
949 }
950
951 static void msi3101_iso_stop(struct msi3101_state *s)
952 {
953 int i;
954 dev_dbg(&s->udev->dev, "%s:\n", __func__);
955
956 /* Unlinking ISOC buffers one by one */
957 for (i = 0; i < MAX_ISO_BUFS; i++) {
958 if (s->urbs[i]) {
959 dev_dbg(&s->udev->dev, "Unlinking URB %p\n",
960 s->urbs[i]);
961 usb_kill_urb(s->urbs[i]);
962 }
963 }
964 }
965
966 static void msi3101_iso_free(struct msi3101_state *s)
967 {
968 int i;
969 dev_dbg(&s->udev->dev, "%s:\n", __func__);
970
971 /* Freeing ISOC buffers one by one */
972 for (i = 0; i < MAX_ISO_BUFS; i++) {
973 if (s->urbs[i]) {
974 dev_dbg(&s->udev->dev, "Freeing URB\n");
975 if (s->urbs[i]->transfer_buffer) {
976 usb_free_coherent(s->udev,
977 s->urbs[i]->transfer_buffer_length,
978 s->urbs[i]->transfer_buffer,
979 s->urbs[i]->transfer_dma);
980 }
981 usb_free_urb(s->urbs[i]);
982 s->urbs[i] = NULL;
983 }
984 }
985 }
986
987 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
988 static void msi3101_isoc_cleanup(struct msi3101_state *s)
989 {
990 dev_dbg(&s->udev->dev, "%s:\n", __func__);
991
992 msi3101_iso_stop(s);
993 msi3101_iso_free(s);
994 }
995
996 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
997 static int msi3101_isoc_init(struct msi3101_state *s)
998 {
999 struct usb_device *udev;
1000 struct urb *urb;
1001 int i, j, ret;
1002 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1003
1004 s->isoc_errors = 0;
1005 udev = s->udev;
1006
1007 ret = usb_set_interface(s->udev, 0, 1);
1008 if (ret < 0)
1009 return ret;
1010
1011 /* Allocate and init Isochronuous urbs */
1012 for (i = 0; i < MAX_ISO_BUFS; i++) {
1013 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
1014 if (urb == NULL) {
1015 dev_err(&s->udev->dev,
1016 "Failed to allocate urb %d\n", i);
1017 msi3101_isoc_cleanup(s);
1018 return -ENOMEM;
1019 }
1020 s->urbs[i] = urb;
1021 dev_dbg(&s->udev->dev, "Allocated URB at 0x%p\n", urb);
1022
1023 urb->interval = 1;
1024 urb->dev = udev;
1025 urb->pipe = usb_rcvisocpipe(udev, 0x81);
1026 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1027 urb->transfer_buffer = usb_alloc_coherent(udev, ISO_BUFFER_SIZE,
1028 GFP_KERNEL, &urb->transfer_dma);
1029 if (urb->transfer_buffer == NULL) {
1030 dev_err(&s->udev->dev,
1031 "Failed to allocate urb buffer %d\n",
1032 i);
1033 msi3101_isoc_cleanup(s);
1034 return -ENOMEM;
1035 }
1036 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
1037 urb->complete = msi3101_isoc_handler;
1038 urb->context = s;
1039 urb->start_frame = 0;
1040 urb->number_of_packets = ISO_FRAMES_PER_DESC;
1041 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
1042 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
1043 urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
1044 }
1045 }
1046
1047 /* link */
1048 for (i = 0; i < MAX_ISO_BUFS; i++) {
1049 ret = usb_submit_urb(s->urbs[i], GFP_KERNEL);
1050 if (ret) {
1051 dev_err(&s->udev->dev,
1052 "isoc_init() submit_urb %d failed with error %d\n",
1053 i, ret);
1054 msi3101_isoc_cleanup(s);
1055 return ret;
1056 }
1057 dev_dbg(&s->udev->dev, "URB 0x%p submitted.\n", s->urbs[i]);
1058 }
1059
1060 /* All is done... */
1061 return 0;
1062 }
1063
1064 /* Must be called with vb_queue_lock hold */
1065 static void msi3101_cleanup_queued_bufs(struct msi3101_state *s)
1066 {
1067 unsigned long flags = 0;
1068 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1069
1070 spin_lock_irqsave(&s->queued_bufs_lock, flags);
1071 while (!list_empty(&s->queued_bufs)) {
1072 struct msi3101_frame_buf *buf;
1073
1074 buf = list_entry(s->queued_bufs.next, struct msi3101_frame_buf,
1075 list);
1076 list_del(&buf->list);
1077 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
1078 }
1079 spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
1080 }
1081
1082 /* The user yanked out the cable... */
1083 static void msi3101_disconnect(struct usb_interface *intf)
1084 {
1085 struct v4l2_device *v = usb_get_intfdata(intf);
1086 struct msi3101_state *s =
1087 container_of(v, struct msi3101_state, v4l2_dev);
1088 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1089
1090 mutex_lock(&s->vb_queue_lock);
1091 mutex_lock(&s->v4l2_lock);
1092 /* No need to keep the urbs around after disconnection */
1093 s->udev = NULL;
1094
1095 v4l2_device_disconnect(&s->v4l2_dev);
1096 video_unregister_device(&s->vdev);
1097 mutex_unlock(&s->v4l2_lock);
1098 mutex_unlock(&s->vb_queue_lock);
1099
1100 v4l2_device_put(&s->v4l2_dev);
1101 }
1102
1103 static int msi3101_querycap(struct file *file, void *fh,
1104 struct v4l2_capability *cap)
1105 {
1106 struct msi3101_state *s = video_drvdata(file);
1107 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1108
1109 strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
1110 strlcpy(cap->card, s->vdev.name, sizeof(cap->card));
1111 usb_make_path(s->udev, cap->bus_info, sizeof(cap->bus_info));
1112 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1113 V4L2_CAP_READWRITE;
1114 cap->device_caps = V4L2_CAP_TUNER;
1115 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1116 return 0;
1117 }
1118
1119
1120 /* Videobuf2 operations */
1121 static int msi3101_queue_setup(struct vb2_queue *vq,
1122 const struct v4l2_format *fmt, unsigned int *nbuffers,
1123 unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
1124 {
1125 struct msi3101_state *s = vb2_get_drv_priv(vq);
1126 dev_dbg(&s->udev->dev, "%s: *nbuffers=%d\n", __func__, *nbuffers);
1127
1128 /* Absolute min and max number of buffers available for mmap() */
1129 *nbuffers = 32;
1130 *nplanes = 1;
1131 sizes[0] = PAGE_ALIGN(3 * 3072); /* 3 * 768 * 4 */
1132 dev_dbg(&s->udev->dev, "%s: nbuffers=%d sizes[0]=%d\n",
1133 __func__, *nbuffers, sizes[0]);
1134 return 0;
1135 }
1136
1137 static int msi3101_buf_prepare(struct vb2_buffer *vb)
1138 {
1139 struct msi3101_state *s = vb2_get_drv_priv(vb->vb2_queue);
1140
1141 /* Don't allow queing new buffers after device disconnection */
1142 if (!s->udev)
1143 return -ENODEV;
1144
1145 return 0;
1146 }
1147
1148 static void msi3101_buf_queue(struct vb2_buffer *vb)
1149 {
1150 struct msi3101_state *s = vb2_get_drv_priv(vb->vb2_queue);
1151 struct msi3101_frame_buf *buf =
1152 container_of(vb, struct msi3101_frame_buf, vb);
1153 unsigned long flags = 0;
1154
1155 /* Check the device has not disconnected between prep and queuing */
1156 if (!s->udev) {
1157 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
1158 return;
1159 }
1160
1161 spin_lock_irqsave(&s->queued_bufs_lock, flags);
1162 list_add_tail(&buf->list, &s->queued_bufs);
1163 spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
1164 }
1165
1166 #define CMD_WREG 0x41
1167 #define CMD_START_STREAMING 0x43
1168 #define CMD_STOP_STREAMING 0x45
1169 #define CMD_READ_UNKNOW 0x48
1170
1171 #define msi3101_dbg_usb_control_msg(udev, r, t, v, _i, b, l) { \
1172 char *direction; \
1173 if (t == (USB_TYPE_VENDOR | USB_DIR_OUT)) \
1174 direction = ">>>"; \
1175 else \
1176 direction = "<<<"; \
1177 dev_dbg(&udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \
1178 "%s %*ph\n", __func__, t, r, v & 0xff, v >> 8, \
1179 _i & 0xff, _i >> 8, l & 0xff, l >> 8, direction, l, b); \
1180 }
1181
1182 static int msi3101_ctrl_msg(struct msi3101_state *s, u8 cmd, u32 data)
1183 {
1184 int ret;
1185 u8 request = cmd;
1186 u8 requesttype = USB_DIR_OUT | USB_TYPE_VENDOR;
1187 u16 value = (data >> 0) & 0xffff;
1188 u16 index = (data >> 16) & 0xffff;
1189
1190 msi3101_dbg_usb_control_msg(s->udev,
1191 request, requesttype, value, index, NULL, 0);
1192
1193 ret = usb_control_msg(s->udev, usb_sndctrlpipe(s->udev, 0),
1194 request, requesttype, value, index, NULL, 0, 2000);
1195
1196 if (ret)
1197 dev_err(&s->udev->dev, "%s: failed %d, cmd %02x, data %04x\n",
1198 __func__, ret, cmd, data);
1199
1200 return ret;
1201 };
1202
1203 static int msi3101_tuner_write(struct msi3101_state *s, u32 data)
1204 {
1205 return msi3101_ctrl_msg(s, CMD_WREG, data << 8 | 0x09);
1206 };
1207
1208 #define F_REF 24000000
1209 #define DIV_R_IN 2
1210 static int msi3101_set_usb_adc(struct msi3101_state *s)
1211 {
1212 int ret, div_n, div_m, div_r_out, f_sr, f_vco, fract;
1213 u32 reg3, reg4, reg7;
1214
1215 f_sr = s->ctrl_sampling_rate->val64;
1216
1217 /* select stream format */
1218 if (f_sr < 6000000) {
1219 s->convert_stream = msi3101_convert_stream_252;
1220 reg7 = 0x00009407;
1221 } else if (f_sr < 8000000) {
1222 s->convert_stream = msi3101_convert_stream_336;
1223 reg7 = 0x00008507;
1224 } else if (f_sr < 9000000) {
1225 s->convert_stream = msi3101_convert_stream_384;
1226 reg7 = 0x0000a507;
1227 } else {
1228 s->convert_stream = msi3101_convert_stream_504;
1229 reg7 = 0x000c9407;
1230 }
1231
1232 /*
1233 * Synthesizer config is just a educated guess...
1234 *
1235 * [7:0] 0x03, register address
1236 * [8] 1, always
1237 * [9] ?
1238 * [12:10] output divider
1239 * [13] 0 ?
1240 * [14] 0 ?
1241 * [15] fractional MSB, bit 20
1242 * [16:19] N
1243 * [23:20] ?
1244 * [24:31] 0x01
1245 *
1246 * output divider
1247 * val div
1248 * 0 - (invalid)
1249 * 1 4
1250 * 2 6
1251 * 3 8
1252 * 4 10
1253 * 5 12
1254 * 6 14
1255 * 7 16
1256 *
1257 * VCO 202000000 - 720000000++
1258 */
1259 reg3 = 0x01000303;
1260 reg4 = 0x00000004;
1261
1262 /* XXX: Filters? AGC? */
1263 if (f_sr < 6000000)
1264 reg3 |= 0x1 << 20;
1265 else if (f_sr < 7000000)
1266 reg3 |= 0x5 << 20;
1267 else if (f_sr < 8500000)
1268 reg3 |= 0x9 << 20;
1269 else
1270 reg3 |= 0xd << 20;
1271
1272 for (div_r_out = 4; div_r_out < 16; div_r_out += 2) {
1273 f_vco = f_sr * div_r_out * 12;
1274 dev_dbg(&s->udev->dev, "%s: div_r_out=%d f_vco=%d\n",
1275 __func__, div_r_out, f_vco);
1276 if (f_vco >= 202000000)
1277 break;
1278 }
1279
1280 div_n = f_vco / (F_REF * DIV_R_IN);
1281 div_m = f_vco % (F_REF * DIV_R_IN);
1282 fract = 0x200000ul * div_m / (F_REF * DIV_R_IN);
1283
1284 reg3 |= div_n << 16;
1285 reg3 |= (div_r_out / 2 - 1) << 10;
1286 reg3 |= ((fract >> 20) & 0x000001) << 15; /* [20] */
1287 reg4 |= ((fract >> 0) & 0x0fffff) << 8; /* [19:0] */
1288
1289 dev_dbg(&s->udev->dev,
1290 "%s: f_sr=%d f_vco=%d div_n=%d div_m=%d div_r_out=%d reg3=%08x reg4=%08x\n",
1291 __func__, f_sr, f_vco, div_n, div_m, div_r_out, reg3, reg4);
1292
1293 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00608008);
1294 if (ret)
1295 goto err;
1296
1297 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00000c05);
1298 if (ret)
1299 goto err;
1300
1301 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00020000);
1302 if (ret)
1303 goto err;
1304
1305 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00480102);
1306 if (ret)
1307 goto err;
1308
1309 ret = msi3101_ctrl_msg(s, CMD_WREG, 0x00f38008);
1310 if (ret)
1311 goto err;
1312
1313 ret = msi3101_ctrl_msg(s, CMD_WREG, reg7);
1314 if (ret)
1315 goto err;
1316
1317 ret = msi3101_ctrl_msg(s, CMD_WREG, reg4);
1318 if (ret)
1319 goto err;
1320
1321 ret = msi3101_ctrl_msg(s, CMD_WREG, reg3);
1322 if (ret)
1323 goto err;
1324 err:
1325 return ret;
1326 };
1327
1328 static int msi3101_set_tuner(struct msi3101_state *s)
1329 {
1330 int ret, i, len;
1331 unsigned int n, m, thresh, frac, vco_step, tmp;
1332 u32 reg;
1333 u64 f_vco;
1334 u8 mode, lo_div;
1335 const struct msi3101_gain *gain_lut;
1336 static const struct {
1337 u32 rf;
1338 u8 mode;
1339 u8 lo_div;
1340 } band_lut[] = {
1341 { 47000000, 0x01, 16}, /* AM_MODE1 */
1342 {108000000, 0x02, 32}, /* VHF_MODE */
1343 {330000000, 0x04, 16}, /* B3_MODE */
1344 {960000000, 0x08, 4}, /* B45_MODE */
1345 { ~0U, 0x10, 2}, /* BL_MODE */
1346 };
1347 static const struct {
1348 u32 freq;
1349 u8 val;
1350 } if_freq_lut[] = {
1351 { 0, 0x03}, /* Zero IF */
1352 { 450000, 0x02}, /* 450 kHz IF */
1353 {1620000, 0x01}, /* 1.62 MHz IF */
1354 {2048000, 0x00}, /* 2.048 MHz IF */
1355 };
1356 static const struct {
1357 u32 freq;
1358 u8 val;
1359 } bandwidth_lut[] = {
1360 { 200000, 0x00}, /* 200 kHz */
1361 { 300000, 0x01}, /* 300 kHz */
1362 { 600000, 0x02}, /* 600 kHz */
1363 {1536000, 0x03}, /* 1.536 MHz */
1364 {5000000, 0x04}, /* 5 MHz */
1365 {6000000, 0x05}, /* 6 MHz */
1366 {7000000, 0x06}, /* 7 MHz */
1367 {8000000, 0x07}, /* 8 MHz */
1368 };
1369
1370 unsigned int rf_freq = s->ctrl_tuner_rf->val64;
1371
1372 /*
1373 * bandwidth (Hz)
1374 * 200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000
1375 */
1376 int bandwidth = s->ctrl_tuner_bw->val;
1377
1378 /*
1379 * intermediate frequency (Hz)
1380 * 0, 450000, 1620000, 2048000
1381 */
1382 int if_freq = s->ctrl_tuner_if->val;
1383
1384 /*
1385 * gain reduction (dB)
1386 * 0 - 102 below 420 MHz
1387 * 0 - 85 above 420 MHz
1388 */
1389 int gain = s->ctrl_tuner_gain->val;
1390
1391 dev_dbg(&s->udev->dev,
1392 "%s: rf_freq=%d bandwidth=%d if_freq=%d gain=%d\n",
1393 __func__, rf_freq, bandwidth, if_freq, gain);
1394
1395 ret = -EINVAL;
1396
1397 for (i = 0; i < ARRAY_SIZE(band_lut); i++) {
1398 if (rf_freq <= band_lut[i].rf) {
1399 mode = band_lut[i].mode;
1400 lo_div = band_lut[i].lo_div;
1401 break;
1402 }
1403 }
1404
1405 if (i == ARRAY_SIZE(band_lut))
1406 goto err;
1407
1408 for (i = 0; i < ARRAY_SIZE(if_freq_lut); i++) {
1409 if (if_freq == if_freq_lut[i].freq) {
1410 if_freq = if_freq_lut[i].val;
1411 break;
1412 }
1413 }
1414
1415 if (i == ARRAY_SIZE(if_freq_lut))
1416 goto err;
1417
1418 for (i = 0; i < ARRAY_SIZE(bandwidth_lut); i++) {
1419 if (bandwidth == bandwidth_lut[i].freq) {
1420 bandwidth = bandwidth_lut[i].val;
1421 break;
1422 }
1423 }
1424
1425 if (i == ARRAY_SIZE(bandwidth_lut))
1426 goto err;
1427
1428 #define F_OUT_STEP 1
1429 #define R_REF 4
1430 #define F_IF 0
1431 f_vco = (rf_freq + F_IF) * lo_div;
1432 n = f_vco / (F_REF * R_REF);
1433 m = f_vco % (F_REF * R_REF);
1434
1435 vco_step = F_OUT_STEP * lo_div;
1436 thresh = (F_REF * R_REF) / vco_step;
1437 frac = 1ul * thresh * m / (F_REF * R_REF);
1438
1439 /* Divide to reg max. After that RF resolution will be +-500Hz. */
1440 tmp = DIV_ROUND_UP(thresh, 4095);
1441 thresh = DIV_ROUND_CLOSEST(thresh, tmp);
1442 frac = DIV_ROUND_CLOSEST(frac, tmp);
1443
1444 /* calc real RF set */
1445 tmp = 1ul * F_REF * R_REF * n;
1446 tmp += 1ul * F_REF * R_REF * frac / thresh;
1447 tmp /= lo_div;
1448
1449 dev_dbg(&s->udev->dev,
1450 "%s: rf=%u:%u n=%d thresh=%d frac=%d\n",
1451 __func__, rf_freq, tmp, n, thresh, frac);
1452
1453 ret = msi3101_tuner_write(s, 0x00000e);
1454 ret = msi3101_tuner_write(s, 0x000003);
1455
1456 reg = 0 << 0;
1457 reg |= mode << 4;
1458 reg |= 1 << 10;
1459 reg |= if_freq << 12;
1460 reg |= bandwidth << 14;
1461 reg |= 0x02 << 17;
1462 reg |= 0x00 << 20;
1463 ret = msi3101_tuner_write(s, reg);
1464 if (ret)
1465 goto err;
1466
1467 reg = 5 << 0;
1468 reg |= thresh << 4;
1469 reg |= 1 << 19;
1470 reg |= 1 << 21;
1471 ret = msi3101_tuner_write(s, reg);
1472 if (ret)
1473 goto err;
1474
1475 reg = 2 << 0;
1476 reg |= frac << 4;
1477 reg |= n << 16;
1478 ret = msi3101_tuner_write(s, reg);
1479 if (ret)
1480 goto err;
1481
1482 if (rf_freq < 120000000) {
1483 gain_lut = msi3101_gain_lut_120;
1484 len = ARRAY_SIZE(msi3101_gain_lut_120);
1485 } else if (rf_freq < 245000000) {
1486 gain_lut = msi3101_gain_lut_245;
1487 len = ARRAY_SIZE(msi3101_gain_lut_120);
1488 } else {
1489 gain_lut = msi3101_gain_lut_1000;
1490 len = ARRAY_SIZE(msi3101_gain_lut_1000);
1491 }
1492
1493 for (i = 0; i < len; i++) {
1494 if (gain_lut[i].tot >= gain)
1495 break;
1496 }
1497
1498 if (i == len)
1499 goto err;
1500
1501 dev_dbg(&s->udev->dev,
1502 "%s: gain tot=%d baseband=%d lna=%d mixer=%d\n",
1503 __func__, gain_lut[i].tot, gain_lut[i].baseband,
1504 gain_lut[i].lna, gain_lut[i].mixer);
1505
1506 reg = 1 << 0;
1507 reg |= gain_lut[i].baseband << 4;
1508 reg |= 0 << 10;
1509 reg |= gain_lut[i].mixer << 12;
1510 reg |= gain_lut[i].lna << 13;
1511 reg |= 4 << 14;
1512 reg |= 0 << 17;
1513 ret = msi3101_tuner_write(s, reg);
1514 if (ret)
1515 goto err;
1516
1517 reg = 6 << 0;
1518 reg |= 63 << 4;
1519 reg |= 4095 << 10;
1520 ret = msi3101_tuner_write(s, reg);
1521 if (ret)
1522 goto err;
1523
1524 return 0;
1525 err:
1526 dev_dbg(&s->udev->dev, "%s: failed %d\n", __func__, ret);
1527 return ret;
1528 };
1529
1530 static int msi3101_start_streaming(struct vb2_queue *vq, unsigned int count)
1531 {
1532 struct msi3101_state *s = vb2_get_drv_priv(vq);
1533 int ret;
1534 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1535
1536 if (!s->udev)
1537 return -ENODEV;
1538
1539 if (mutex_lock_interruptible(&s->v4l2_lock))
1540 return -ERESTARTSYS;
1541
1542 ret = msi3101_set_usb_adc(s);
1543
1544 ret = msi3101_isoc_init(s);
1545 if (ret)
1546 msi3101_cleanup_queued_bufs(s);
1547
1548 ret = msi3101_ctrl_msg(s, CMD_START_STREAMING, 0);
1549
1550 mutex_unlock(&s->v4l2_lock);
1551
1552 return ret;
1553 }
1554
1555 static int msi3101_stop_streaming(struct vb2_queue *vq)
1556 {
1557 struct msi3101_state *s = vb2_get_drv_priv(vq);
1558 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1559
1560 if (mutex_lock_interruptible(&s->v4l2_lock))
1561 return -ERESTARTSYS;
1562
1563 if (s->udev)
1564 msi3101_isoc_cleanup(s);
1565
1566 msi3101_cleanup_queued_bufs(s);
1567
1568 /* according to tests, at least 700us delay is required */
1569 msleep(20);
1570 msi3101_ctrl_msg(s, CMD_STOP_STREAMING, 0);
1571
1572 mutex_unlock(&s->v4l2_lock);
1573
1574 return 0;
1575 }
1576
1577 static struct vb2_ops msi3101_vb2_ops = {
1578 .queue_setup = msi3101_queue_setup,
1579 .buf_prepare = msi3101_buf_prepare,
1580 .buf_queue = msi3101_buf_queue,
1581 .start_streaming = msi3101_start_streaming,
1582 .stop_streaming = msi3101_stop_streaming,
1583 .wait_prepare = vb2_ops_wait_prepare,
1584 .wait_finish = vb2_ops_wait_finish,
1585 };
1586
1587 static int msi3101_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1588 {
1589 if (i->index != 0)
1590 return -EINVAL;
1591
1592 strlcpy(i->name, "SDR data", sizeof(i->name));
1593 i->type = V4L2_INPUT_TYPE_CAMERA;
1594
1595 return 0;
1596 }
1597
1598 static int msi3101_g_input(struct file *file, void *fh, unsigned int *i)
1599 {
1600 *i = 0;
1601
1602 return 0;
1603 }
1604
1605 static int msi3101_s_input(struct file *file, void *fh, unsigned int i)
1606 {
1607 return i ? -EINVAL : 0;
1608 }
1609
1610 static int vidioc_s_tuner(struct file *file, void *priv,
1611 const struct v4l2_tuner *v)
1612 {
1613 struct msi3101_state *s = video_drvdata(file);
1614 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1615
1616 return 0;
1617 }
1618
1619 static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
1620 {
1621 struct msi3101_state *s = video_drvdata(file);
1622 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1623
1624 strcpy(v->name, "SDR RX");
1625 v->capability = V4L2_TUNER_CAP_LOW;
1626
1627 return 0;
1628 }
1629
1630 static int vidioc_s_frequency(struct file *file, void *priv,
1631 const struct v4l2_frequency *f)
1632 {
1633 struct msi3101_state *s = video_drvdata(file);
1634 dev_dbg(&s->udev->dev, "%s: frequency=%lu Hz (%u)\n",
1635 __func__, f->frequency * 625UL / 10UL, f->frequency);
1636
1637 return v4l2_ctrl_s_ctrl_int64(s->ctrl_tuner_rf,
1638 f->frequency * 625UL / 10UL);
1639 }
1640
1641 const struct v4l2_ioctl_ops msi3101_ioctl_ops = {
1642 .vidioc_querycap = msi3101_querycap,
1643
1644 .vidioc_enum_input = msi3101_enum_input,
1645 .vidioc_g_input = msi3101_g_input,
1646 .vidioc_s_input = msi3101_s_input,
1647
1648 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1649 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1650 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1651 .vidioc_querybuf = vb2_ioctl_querybuf,
1652 .vidioc_qbuf = vb2_ioctl_qbuf,
1653 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1654
1655 .vidioc_streamon = vb2_ioctl_streamon,
1656 .vidioc_streamoff = vb2_ioctl_streamoff,
1657
1658 .vidioc_g_tuner = vidioc_g_tuner,
1659 .vidioc_s_tuner = vidioc_s_tuner,
1660 .vidioc_s_frequency = vidioc_s_frequency,
1661
1662 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1663 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1664 .vidioc_log_status = v4l2_ctrl_log_status,
1665 };
1666
1667 static const struct v4l2_file_operations msi3101_fops = {
1668 .owner = THIS_MODULE,
1669 .open = v4l2_fh_open,
1670 .release = vb2_fop_release,
1671 .read = vb2_fop_read,
1672 .poll = vb2_fop_poll,
1673 .mmap = vb2_fop_mmap,
1674 .unlocked_ioctl = video_ioctl2,
1675 };
1676
1677 static struct video_device msi3101_template = {
1678 .name = "Mirics MSi3101 SDR Dongle",
1679 .release = video_device_release_empty,
1680 .fops = &msi3101_fops,
1681 .ioctl_ops = &msi3101_ioctl_ops,
1682 };
1683
1684 static int msi3101_s_ctrl(struct v4l2_ctrl *ctrl)
1685 {
1686 struct msi3101_state *s =
1687 container_of(ctrl->handler, struct msi3101_state,
1688 ctrl_handler);
1689 int ret;
1690 dev_dbg(&s->udev->dev,
1691 "%s: id=%d name=%s val=%d min=%d max=%d step=%d\n",
1692 __func__, ctrl->id, ctrl->name, ctrl->val,
1693 ctrl->minimum, ctrl->maximum, ctrl->step);
1694
1695 switch (ctrl->id) {
1696 case MSI3101_CID_SAMPLING_MODE:
1697 case MSI3101_CID_SAMPLING_RATE:
1698 case MSI3101_CID_SAMPLING_RESOLUTION:
1699 ret = 0;
1700 break;
1701 case MSI3101_CID_TUNER_RF:
1702 case MSI3101_CID_TUNER_BW:
1703 case MSI3101_CID_TUNER_IF:
1704 case MSI3101_CID_TUNER_GAIN:
1705 ret = msi3101_set_tuner(s);
1706 break;
1707 default:
1708 ret = -EINVAL;
1709 }
1710
1711 return ret;
1712 }
1713
1714 static const struct v4l2_ctrl_ops msi3101_ctrl_ops = {
1715 .s_ctrl = msi3101_s_ctrl,
1716 };
1717
1718 static void msi3101_video_release(struct v4l2_device *v)
1719 {
1720 struct msi3101_state *s =
1721 container_of(v, struct msi3101_state, v4l2_dev);
1722
1723 v4l2_ctrl_handler_free(&s->ctrl_handler);
1724 v4l2_device_unregister(&s->v4l2_dev);
1725 kfree(s);
1726 }
1727
1728 static int msi3101_probe(struct usb_interface *intf,
1729 const struct usb_device_id *id)
1730 {
1731 struct usb_device *udev = interface_to_usbdev(intf);
1732 struct msi3101_state *s = NULL;
1733 int ret;
1734 static const char * const ctrl_sampling_mode_qmenu_strings[] = {
1735 "Quadrature Sampling",
1736 NULL,
1737 };
1738 static const struct v4l2_ctrl_config ctrl_sampling_mode = {
1739 .ops = &msi3101_ctrl_ops,
1740 .id = MSI3101_CID_SAMPLING_MODE,
1741 .type = V4L2_CTRL_TYPE_MENU,
1742 .flags = V4L2_CTRL_FLAG_INACTIVE,
1743 .name = "Sampling Mode",
1744 .qmenu = ctrl_sampling_mode_qmenu_strings,
1745 };
1746 static const struct v4l2_ctrl_config ctrl_sampling_rate = {
1747 .ops = &msi3101_ctrl_ops,
1748 .id = MSI3101_CID_SAMPLING_RATE,
1749 .type = V4L2_CTRL_TYPE_INTEGER64,
1750 .name = "Sampling Rate",
1751 .min = 500000,
1752 .max = 12000000,
1753 .def = 2048000,
1754 .step = 1,
1755 };
1756 static const struct v4l2_ctrl_config ctrl_sampling_resolution = {
1757 .ops = &msi3101_ctrl_ops,
1758 .id = MSI3101_CID_SAMPLING_RESOLUTION,
1759 .type = V4L2_CTRL_TYPE_INTEGER,
1760 .flags = V4L2_CTRL_FLAG_INACTIVE,
1761 .name = "Sampling Resolution",
1762 .min = 10,
1763 .max = 10,
1764 .def = 10,
1765 .step = 1,
1766 };
1767 static const struct v4l2_ctrl_config ctrl_tuner_rf = {
1768 .ops = &msi3101_ctrl_ops,
1769 .id = MSI3101_CID_TUNER_RF,
1770 .type = V4L2_CTRL_TYPE_INTEGER64,
1771 .name = "Tuner RF",
1772 .min = 40000000,
1773 .max = 2000000000,
1774 .def = 100000000,
1775 .step = 1,
1776 };
1777 static const struct v4l2_ctrl_config ctrl_tuner_bw = {
1778 .ops = &msi3101_ctrl_ops,
1779 .id = MSI3101_CID_TUNER_BW,
1780 .type = V4L2_CTRL_TYPE_INTEGER,
1781 .name = "Tuner BW",
1782 .min = 200000,
1783 .max = 8000000,
1784 .def = 600000,
1785 .step = 1,
1786 };
1787 static const struct v4l2_ctrl_config ctrl_tuner_if = {
1788 .ops = &msi3101_ctrl_ops,
1789 .id = MSI3101_CID_TUNER_IF,
1790 .type = V4L2_CTRL_TYPE_INTEGER,
1791 .flags = V4L2_CTRL_FLAG_INACTIVE,
1792 .name = "Tuner IF",
1793 .min = 0,
1794 .max = 2048000,
1795 .def = 0,
1796 .step = 1,
1797 };
1798 static const struct v4l2_ctrl_config ctrl_tuner_gain = {
1799 .ops = &msi3101_ctrl_ops,
1800 .id = MSI3101_CID_TUNER_GAIN,
1801 .type = V4L2_CTRL_TYPE_INTEGER,
1802 .name = "Tuner Gain",
1803 .min = 0,
1804 .max = 102,
1805 .def = 0,
1806 .step = 1,
1807 };
1808
1809 s = kzalloc(sizeof(struct msi3101_state), GFP_KERNEL);
1810 if (s == NULL) {
1811 pr_err("Could not allocate memory for msi3101_state\n");
1812 return -ENOMEM;
1813 }
1814
1815 mutex_init(&s->v4l2_lock);
1816 mutex_init(&s->vb_queue_lock);
1817 spin_lock_init(&s->queued_bufs_lock);
1818 INIT_LIST_HEAD(&s->queued_bufs);
1819
1820 s->udev = udev;
1821
1822 /* Init videobuf2 queue structure */
1823 s->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1824 s->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1825 s->vb_queue.drv_priv = s;
1826 s->vb_queue.buf_struct_size = sizeof(struct msi3101_frame_buf);
1827 s->vb_queue.ops = &msi3101_vb2_ops;
1828 s->vb_queue.mem_ops = &vb2_vmalloc_memops;
1829 s->vb_queue.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1830 ret = vb2_queue_init(&s->vb_queue);
1831 if (ret < 0) {
1832 dev_err(&s->udev->dev, "Could not initialize vb2 queue\n");
1833 goto err_free_mem;
1834 }
1835
1836 /* Init video_device structure */
1837 s->vdev = msi3101_template;
1838 s->vdev.queue = &s->vb_queue;
1839 s->vdev.queue->lock = &s->vb_queue_lock;
1840 set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev.flags);
1841 video_set_drvdata(&s->vdev, s);
1842
1843 /* Register controls */
1844 v4l2_ctrl_handler_init(&s->ctrl_handler, 7);
1845 v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_sampling_mode, NULL);
1846 s->ctrl_sampling_rate = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_sampling_rate, NULL);
1847 v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_sampling_resolution, NULL);
1848 s->ctrl_tuner_rf = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_tuner_rf, NULL);
1849 s->ctrl_tuner_bw = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_tuner_bw, NULL);
1850 s->ctrl_tuner_if = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_tuner_if, NULL);
1851 s->ctrl_tuner_gain = v4l2_ctrl_new_custom(&s->ctrl_handler, &ctrl_tuner_gain, NULL);
1852 if (s->ctrl_handler.error) {
1853 ret = s->ctrl_handler.error;
1854 dev_err(&s->udev->dev, "Could not initialize controls\n");
1855 goto err_free_controls;
1856 }
1857
1858 /* Register the v4l2_device structure */
1859 s->v4l2_dev.release = msi3101_video_release;
1860 ret = v4l2_device_register(&intf->dev, &s->v4l2_dev);
1861 if (ret) {
1862 dev_err(&s->udev->dev,
1863 "Failed to register v4l2-device (%d)\n", ret);
1864 goto err_free_controls;
1865 }
1866
1867 s->v4l2_dev.ctrl_handler = &s->ctrl_handler;
1868 s->vdev.v4l2_dev = &s->v4l2_dev;
1869 s->vdev.lock = &s->v4l2_lock;
1870
1871 ret = video_register_device(&s->vdev, VFL_TYPE_GRABBER, -1);
1872 if (ret < 0) {
1873 dev_err(&s->udev->dev,
1874 "Failed to register as video device (%d)\n",
1875 ret);
1876 goto err_unregister_v4l2_dev;
1877 }
1878 dev_info(&s->udev->dev, "Registered as %s\n",
1879 video_device_node_name(&s->vdev));
1880
1881 return 0;
1882
1883 err_unregister_v4l2_dev:
1884 v4l2_device_unregister(&s->v4l2_dev);
1885 err_free_controls:
1886 v4l2_ctrl_handler_free(&s->ctrl_handler);
1887 err_free_mem:
1888 kfree(s);
1889 return ret;
1890 }
1891
1892 /* USB device ID list */
1893 static struct usb_device_id msi3101_id_table[] = {
1894 { USB_DEVICE(0x1df7, 0x2500) }, /* Mirics MSi3101 SDR Dongle */
1895 { USB_DEVICE(0x2040, 0xd300) }, /* Hauppauge WinTV 133559 LF */
1896 { }
1897 };
1898 MODULE_DEVICE_TABLE(usb, msi3101_id_table);
1899
1900 /* USB subsystem interface */
1901 static struct usb_driver msi3101_driver = {
1902 .name = KBUILD_MODNAME,
1903 .probe = msi3101_probe,
1904 .disconnect = msi3101_disconnect,
1905 .id_table = msi3101_id_table,
1906 };
1907
1908 module_usb_driver(msi3101_driver);
1909
1910 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1911 MODULE_DESCRIPTION("Mirics MSi3101 SDR Dongle");
1912 MODULE_LICENSE("GPL");
(deprecated) Btrfs devel tree