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