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 msi2500_isoc_cleanup(dev);
513 return -ENOMEM;
514 }
515 dev->urbs[i] = urb;
516 dev_dbg(dev->dev, "Allocated URB at 0x%p\n", urb);
517
518 urb->interval = 1;
519 urb->dev = dev->udev;
520 urb->pipe = usb_rcvisocpipe(dev->udev, 0x81);
521 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
522 urb->transfer_buffer = usb_alloc_coherent(dev->udev,
523 ISO_BUFFER_SIZE,
524 GFP_KERNEL, &urb->transfer_dma);
525 if (urb->transfer_buffer == NULL) {
526 dev_err(dev->dev,
527 "Failed to allocate urb buffer %d\n", i);
528 msi2500_isoc_cleanup(dev);
529 return -ENOMEM;
530 }
531 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
532 urb->complete = msi2500_isoc_handler;
533 urb->context = dev;
534 urb->start_frame = 0;
535 urb->number_of_packets = ISO_FRAMES_PER_DESC;
536 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
537 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
538 urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
539 }
540 }
541
542
543 for (i = 0; i < MAX_ISO_BUFS; i++) {
544 ret = usb_submit_urb(dev->urbs[i], GFP_KERNEL);
545 if (ret) {
546 dev_err(dev->dev,
547 "usb_submit_urb %d failed with error %d\n",
548 i, ret);
549 msi2500_isoc_cleanup(dev);
550 return ret;
551 }
552 dev_dbg(dev->dev, "URB 0x%p submitted.\n", dev->urbs[i]);
553 }
554
555
556 return 0;
557}
558
559
560static void msi2500_cleanup_queued_bufs(struct msi2500_dev *dev)
561{
562 unsigned long flags;
563
564 dev_dbg(dev->dev, "\n");
565
566 spin_lock_irqsave(&dev->queued_bufs_lock, flags);
567 while (!list_empty(&dev->queued_bufs)) {
568 struct msi2500_frame_buf *buf;
569
570 buf = list_entry(dev->queued_bufs.next,
571 struct msi2500_frame_buf, list);
572 list_del(&buf->list);
573 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
574 }
575 spin_unlock_irqrestore(&dev->queued_bufs_lock, flags);
576}
577
578
579static void msi2500_disconnect(struct usb_interface *intf)
580{
581 struct v4l2_device *v = usb_get_intfdata(intf);
582 struct msi2500_dev *dev =
583 container_of(v, struct msi2500_dev, v4l2_dev);
584
585 dev_dbg(dev->dev, "\n");
586
587 mutex_lock(&dev->vb_queue_lock);
588 mutex_lock(&dev->v4l2_lock);
589
590 dev->udev = NULL;
591 v4l2_device_disconnect(&dev->v4l2_dev);
592 video_unregister_device(&dev->vdev);
593 spi_unregister_master(dev->master);
594 mutex_unlock(&dev->v4l2_lock);
595 mutex_unlock(&dev->vb_queue_lock);
596
597 v4l2_device_put(&dev->v4l2_dev);
598}
599
600static int msi2500_querycap(struct file *file, void *fh,
601 struct v4l2_capability *cap)
602{
603 struct msi2500_dev *dev = video_drvdata(file);
604
605 dev_dbg(dev->dev, "\n");
606
607 strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
608 strlcpy(cap->card, dev->vdev.name, sizeof(cap->card));
609 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
610 cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
611 V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
612 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
613 return 0;
614}
615
616
617static int msi2500_queue_setup(struct vb2_queue *vq,
618 unsigned int *nbuffers,
619 unsigned int *nplanes, unsigned int sizes[],
620 struct device *alloc_devs[])
621{
622 struct msi2500_dev *dev = vb2_get_drv_priv(vq);
623
624 dev_dbg(dev->dev, "nbuffers=%d\n", *nbuffers);
625
626
627 *nbuffers = clamp_t(unsigned int, *nbuffers, 8, 32);
628 *nplanes = 1;
629 sizes[0] = PAGE_ALIGN(dev->buffersize);
630 dev_dbg(dev->dev, "nbuffers=%d sizes[0]=%d\n", *nbuffers, sizes[0]);
631 return 0;
632}
633
634static void msi2500_buf_queue(struct vb2_buffer *vb)
635{
636 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
637 struct msi2500_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
638 struct msi2500_frame_buf *buf = container_of(vbuf,
639 struct msi2500_frame_buf,
640 vb);
641 unsigned long flags;
642
643
644 if (unlikely(!dev->udev)) {
645 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
646 return;
647 }
648
649 spin_lock_irqsave(&dev->queued_bufs_lock, flags);
650 list_add_tail(&buf->list, &dev->queued_bufs);
651 spin_unlock_irqrestore(&dev->queued_bufs_lock, flags);
652}
653
654#define CMD_WREG 0x41
655#define CMD_START_STREAMING 0x43
656#define CMD_STOP_STREAMING 0x45
657#define CMD_READ_UNKNOWN 0x48
658
659#define msi2500_dbg_usb_control_msg(_dev, _r, _t, _v, _i, _b, _l) { \
660 char *_direction; \
661 if (_t & USB_DIR_IN) \
662 _direction = "<<<"; \
663 else \
664 _direction = ">>>"; \
665 dev_dbg(_dev, "%02x %02x %02x %02x %02x %02x %02x %02x %s %*ph\n", \
666 _t, _r, _v & 0xff, _v >> 8, _i & 0xff, _i >> 8, \
667 _l & 0xff, _l >> 8, _direction, _l, _b); \
668}
669
670static int msi2500_ctrl_msg(struct msi2500_dev *dev, u8 cmd, u32 data)
671{
672 int ret;
673 u8 request = cmd;
674 u8 requesttype = USB_DIR_OUT | USB_TYPE_VENDOR;
675 u16 value = (data >> 0) & 0xffff;
676 u16 index = (data >> 16) & 0xffff;
677
678 msi2500_dbg_usb_control_msg(dev->dev, request, requesttype,
679 value, index, NULL, 0);
680 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), request,
681 requesttype, value, index, NULL, 0, 2000);
682 if (ret)
683 dev_err(dev->dev, "failed %d, cmd %02x, data %04x\n",
684 ret, cmd, data);
685
686 return ret;
687}
688
689static int msi2500_set_usb_adc(struct msi2500_dev *dev)
690{
691 int ret;
692 unsigned int f_vco, f_sr, div_n, k, k_cw, div_out;
693 u32 reg3, reg4, reg7;
694 struct v4l2_ctrl *bandwidth_auto;
695 struct v4l2_ctrl *bandwidth;
696
697 f_sr = dev->f_adc;
698
699
700 bandwidth_auto = v4l2_ctrl_find(&dev->hdl,
701 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO);
702 if (v4l2_ctrl_g_ctrl(bandwidth_auto)) {
703 bandwidth = v4l2_ctrl_find(&dev->hdl,
704 V4L2_CID_RF_TUNER_BANDWIDTH);
705 v4l2_ctrl_s_ctrl(bandwidth, dev->f_adc);
706 }
707
708
709 switch (dev->pixelformat) {
710 case V4L2_SDR_FMT_CU8:
711 reg7 = 0x000c9407;
712 break;
713 case V4L2_SDR_FMT_CU16LE:
714 reg7 = 0x00009407;
715 break;
716 case V4L2_SDR_FMT_CS8:
717 reg7 = 0x000c9407;
718 break;
719 case MSI2500_PIX_FMT_SDR_MSI2500_384:
720 reg7 = 0x0000a507;
721 break;
722 case MSI2500_PIX_FMT_SDR_S12:
723 reg7 = 0x00008507;
724 break;
725 case V4L2_SDR_FMT_CS14LE:
726 reg7 = 0x00009407;
727 break;
728 default:
729 reg7 = 0x000c9407;
730 break;
731 }
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 #define F_REF 24000000
777 #define DIV_PRE_N 2
778 #define DIV_LO_OUT 12
779 reg3 = 0x01000303;
780 reg4 = 0x00000004;
781
782
783 if (f_sr < 6000000)
784 reg3 |= 0x1 << 20;
785 else if (f_sr < 7000000)
786 reg3 |= 0x5 << 20;
787 else if (f_sr < 8500000)
788 reg3 |= 0x9 << 20;
789 else
790 reg3 |= 0xd << 20;
791
792 for (div_out = 4; div_out < 16; div_out += 2) {
793 f_vco = f_sr * div_out * DIV_LO_OUT;
794 dev_dbg(dev->dev, "div_out=%u f_vco=%u\n", div_out, f_vco);
795 if (f_vco >= 202000000)
796 break;
797 }
798
799
800 div_n = div_u64_rem(f_vco, DIV_PRE_N * F_REF, &k);
801 k_cw = div_u64((u64) k * 0x200000, DIV_PRE_N * F_REF);
802
803 reg3 |= div_n << 16;
804 reg3 |= (div_out / 2 - 1) << 10;
805 reg3 |= ((k_cw >> 20) & 0x000001) << 15;
806 reg4 |= ((k_cw >> 0) & 0x0fffff) << 8;
807
808 dev_dbg(dev->dev,
809 "f_sr=%u f_vco=%u div_n=%u k=%u div_out=%u reg3=%08x reg4=%08x\n",
810 f_sr, f_vco, div_n, k, div_out, reg3, reg4);
811
812 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00608008);
813 if (ret)
814 goto err;
815
816 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00000c05);
817 if (ret)
818 goto err;
819
820 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00020000);
821 if (ret)
822 goto err;
823
824 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00480102);
825 if (ret)
826 goto err;
827
828 ret = msi2500_ctrl_msg(dev, CMD_WREG, 0x00f38008);
829 if (ret)
830 goto err;
831
832 ret = msi2500_ctrl_msg(dev, CMD_WREG, reg7);
833 if (ret)
834 goto err;
835
836 ret = msi2500_ctrl_msg(dev, CMD_WREG, reg4);
837 if (ret)
838 goto err;
839
840 ret = msi2500_ctrl_msg(dev, CMD_WREG, reg3);
841err:
842 return ret;
843}
844
845static int msi2500_start_streaming(struct vb2_queue *vq, unsigned int count)
846{
847 struct msi2500_dev *dev = vb2_get_drv_priv(vq);
848 int ret;
849
850 dev_dbg(dev->dev, "\n");
851
852 if (!dev->udev)
853 return -ENODEV;
854
855 if (mutex_lock_interruptible(&dev->v4l2_lock))
856 return -ERESTARTSYS;
857
858
859 v4l2_subdev_call(dev->v4l2_subdev, core, s_power, 1);
860
861 ret = msi2500_set_usb_adc(dev);
862
863 ret = msi2500_isoc_init(dev);
864 if (ret)
865 msi2500_cleanup_queued_bufs(dev);
866
867 ret = msi2500_ctrl_msg(dev, CMD_START_STREAMING, 0);
868
869 mutex_unlock(&dev->v4l2_lock);
870
871 return ret;
872}
873
874static void msi2500_stop_streaming(struct vb2_queue *vq)
875{
876 struct msi2500_dev *dev = vb2_get_drv_priv(vq);
877
878 dev_dbg(dev->dev, "\n");
879
880 mutex_lock(&dev->v4l2_lock);
881
882 if (dev->udev)
883 msi2500_isoc_cleanup(dev);
884
885 msi2500_cleanup_queued_bufs(dev);
886
887
888 msleep(20);
889 if (!msi2500_ctrl_msg(dev, CMD_STOP_STREAMING, 0)) {
890
891 msi2500_ctrl_msg(dev, CMD_WREG, 0x01000003);
892 }
893
894
895 v4l2_subdev_call(dev->v4l2_subdev, core, s_power, 0);
896
897 mutex_unlock(&dev->v4l2_lock);
898}
899
900static const struct vb2_ops msi2500_vb2_ops = {
901 .queue_setup = msi2500_queue_setup,
902 .buf_queue = msi2500_buf_queue,
903 .start_streaming = msi2500_start_streaming,
904 .stop_streaming = msi2500_stop_streaming,
905 .wait_prepare = vb2_ops_wait_prepare,
906 .wait_finish = vb2_ops_wait_finish,
907};
908
909static int msi2500_enum_fmt_sdr_cap(struct file *file, void *priv,
910 struct v4l2_fmtdesc *f)
911{
912 struct msi2500_dev *dev = video_drvdata(file);
913
914 dev_dbg(dev->dev, "index=%d\n", f->index);
915
916 if (f->index >= dev->num_formats)
917 return -EINVAL;
918
919 strlcpy(f->description, formats[f->index].name, sizeof(f->description));
920 f->pixelformat = formats[f->index].pixelformat;
921
922 return 0;
923}
924
925static int msi2500_g_fmt_sdr_cap(struct file *file, void *priv,
926 struct v4l2_format *f)
927{
928 struct msi2500_dev *dev = video_drvdata(file);
929
930 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
931 (char *)&dev->pixelformat);
932
933 f->fmt.sdr.pixelformat = dev->pixelformat;
934 f->fmt.sdr.buffersize = dev->buffersize;
935 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
936
937 return 0;
938}
939
940static int msi2500_s_fmt_sdr_cap(struct file *file, void *priv,
941 struct v4l2_format *f)
942{
943 struct msi2500_dev *dev = video_drvdata(file);
944 struct vb2_queue *q = &dev->vb_queue;
945 int i;
946
947 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
948 (char *)&f->fmt.sdr.pixelformat);
949
950 if (vb2_is_busy(q))
951 return -EBUSY;
952
953 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
954 for (i = 0; i < dev->num_formats; i++) {
955 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
956 dev->pixelformat = formats[i].pixelformat;
957 dev->buffersize = formats[i].buffersize;
958 f->fmt.sdr.buffersize = formats[i].buffersize;
959 return 0;
960 }
961 }
962
963 dev->pixelformat = formats[0].pixelformat;
964 dev->buffersize = formats[0].buffersize;
965 f->fmt.sdr.pixelformat = formats[0].pixelformat;
966 f->fmt.sdr.buffersize = formats[0].buffersize;
967
968 return 0;
969}
970
971static int msi2500_try_fmt_sdr_cap(struct file *file, void *priv,
972 struct v4l2_format *f)
973{
974 struct msi2500_dev *dev = video_drvdata(file);
975 int i;
976
977 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
978 (char *)&f->fmt.sdr.pixelformat);
979
980 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
981 for (i = 0; i < dev->num_formats; i++) {
982 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
983 f->fmt.sdr.buffersize = formats[i].buffersize;
984 return 0;
985 }
986 }
987
988 f->fmt.sdr.pixelformat = formats[0].pixelformat;
989 f->fmt.sdr.buffersize = formats[0].buffersize;
990
991 return 0;
992}
993
994static int msi2500_s_tuner(struct file *file, void *priv,
995 const struct v4l2_tuner *v)
996{
997 struct msi2500_dev *dev = video_drvdata(file);
998 int ret;
999
1000 dev_dbg(dev->dev, "index=%d\n", v->index);
1001
1002 if (v->index == 0)
1003 ret = 0;
1004 else if (v->index == 1)
1005 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, s_tuner, v);
1006 else
1007 ret = -EINVAL;
1008
1009 return ret;
1010}
1011
1012static int msi2500_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
1013{
1014 struct msi2500_dev *dev = video_drvdata(file);
1015 int ret;
1016
1017 dev_dbg(dev->dev, "index=%d\n", v->index);
1018
1019 if (v->index == 0) {
1020 strlcpy(v->name, "Mirics MSi2500", sizeof(v->name));
1021 v->type = V4L2_TUNER_ADC;
1022 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1023 v->rangelow = 1200000;
1024 v->rangehigh = 15000000;
1025 ret = 0;
1026 } else if (v->index == 1) {
1027 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, g_tuner, v);
1028 } else {
1029 ret = -EINVAL;
1030 }
1031
1032 return ret;
1033}
1034
1035static int msi2500_g_frequency(struct file *file, void *priv,
1036 struct v4l2_frequency *f)
1037{
1038 struct msi2500_dev *dev = video_drvdata(file);
1039 int ret = 0;
1040
1041 dev_dbg(dev->dev, "tuner=%d type=%d\n", f->tuner, f->type);
1042
1043 if (f->tuner == 0) {
1044 f->frequency = dev->f_adc;
1045 ret = 0;
1046 } else if (f->tuner == 1) {
1047 f->type = V4L2_TUNER_RF;
1048 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, g_frequency, f);
1049 } else {
1050 ret = -EINVAL;
1051 }
1052
1053 return ret;
1054}
1055
1056static int msi2500_s_frequency(struct file *file, void *priv,
1057 const struct v4l2_frequency *f)
1058{
1059 struct msi2500_dev *dev = video_drvdata(file);
1060 int ret;
1061
1062 dev_dbg(dev->dev, "tuner=%d type=%d frequency=%u\n",
1063 f->tuner, f->type, f->frequency);
1064
1065 if (f->tuner == 0) {
1066 dev->f_adc = clamp_t(unsigned int, f->frequency,
1067 bands[0].rangelow,
1068 bands[0].rangehigh);
1069 dev_dbg(dev->dev, "ADC frequency=%u Hz\n", dev->f_adc);
1070 ret = msi2500_set_usb_adc(dev);
1071 } else if (f->tuner == 1) {
1072 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, s_frequency, f);
1073 } else {
1074 ret = -EINVAL;
1075 }
1076
1077 return ret;
1078}
1079
1080static int msi2500_enum_freq_bands(struct file *file, void *priv,
1081 struct v4l2_frequency_band *band)
1082{
1083 struct msi2500_dev *dev = video_drvdata(file);
1084 int ret;
1085
1086 dev_dbg(dev->dev, "tuner=%d type=%d index=%d\n",
1087 band->tuner, band->type, band->index);
1088
1089 if (band->tuner == 0) {
1090 if (band->index >= ARRAY_SIZE(bands)) {
1091 ret = -EINVAL;
1092 } else {
1093 *band = bands[band->index];
1094 ret = 0;
1095 }
1096 } else if (band->tuner == 1) {
1097 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner,
1098 enum_freq_bands, band);
1099 } else {
1100 ret = -EINVAL;
1101 }
1102
1103 return ret;
1104}
1105
1106static const struct v4l2_ioctl_ops msi2500_ioctl_ops = {
1107 .vidioc_querycap = msi2500_querycap,
1108
1109 .vidioc_enum_fmt_sdr_cap = msi2500_enum_fmt_sdr_cap,
1110 .vidioc_g_fmt_sdr_cap = msi2500_g_fmt_sdr_cap,
1111 .vidioc_s_fmt_sdr_cap = msi2500_s_fmt_sdr_cap,
1112 .vidioc_try_fmt_sdr_cap = msi2500_try_fmt_sdr_cap,
1113
1114 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1115 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1116 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1117 .vidioc_querybuf = vb2_ioctl_querybuf,
1118 .vidioc_qbuf = vb2_ioctl_qbuf,
1119 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1120
1121 .vidioc_streamon = vb2_ioctl_streamon,
1122 .vidioc_streamoff = vb2_ioctl_streamoff,
1123
1124 .vidioc_g_tuner = msi2500_g_tuner,
1125 .vidioc_s_tuner = msi2500_s_tuner,
1126
1127 .vidioc_g_frequency = msi2500_g_frequency,
1128 .vidioc_s_frequency = msi2500_s_frequency,
1129 .vidioc_enum_freq_bands = msi2500_enum_freq_bands,
1130
1131 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1132 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1133 .vidioc_log_status = v4l2_ctrl_log_status,
1134};
1135
1136static const struct v4l2_file_operations msi2500_fops = {
1137 .owner = THIS_MODULE,
1138 .open = v4l2_fh_open,
1139 .release = vb2_fop_release,
1140 .read = vb2_fop_read,
1141 .poll = vb2_fop_poll,
1142 .mmap = vb2_fop_mmap,
1143 .unlocked_ioctl = video_ioctl2,
1144};
1145
1146static struct video_device msi2500_template = {
1147 .name = "Mirics MSi3101 SDR Dongle",
1148 .release = video_device_release_empty,
1149 .fops = &msi2500_fops,
1150 .ioctl_ops = &msi2500_ioctl_ops,
1151};
1152
1153static void msi2500_video_release(struct v4l2_device *v)
1154{
1155 struct msi2500_dev *dev = container_of(v, struct msi2500_dev, v4l2_dev);
1156
1157 v4l2_ctrl_handler_free(&dev->hdl);
1158 v4l2_device_unregister(&dev->v4l2_dev);
1159 kfree(dev);
1160}
1161
1162static int msi2500_transfer_one_message(struct spi_master *master,
1163 struct spi_message *m)
1164{
1165 struct msi2500_dev *dev = spi_master_get_devdata(master);
1166 struct spi_transfer *t;
1167 int ret = 0;
1168 u32 data;
1169
1170 list_for_each_entry(t, &m->transfers, transfer_list) {
1171 dev_dbg(dev->dev, "msg=%*ph\n", t->len, t->tx_buf);
1172 data = 0x09;
1173 data |= ((u8 *)t->tx_buf)[0] << 8;
1174 data |= ((u8 *)t->tx_buf)[1] << 16;
1175 data |= ((u8 *)t->tx_buf)[2] << 24;
1176 ret = msi2500_ctrl_msg(dev, CMD_WREG, data);
1177 }
1178
1179 m->status = ret;
1180 spi_finalize_current_message(master);
1181 return ret;
1182}
1183
1184static int msi2500_probe(struct usb_interface *intf,
1185 const struct usb_device_id *id)
1186{
1187 struct msi2500_dev *dev;
1188 struct v4l2_subdev *sd;
1189 struct spi_master *master;
1190 int ret;
1191 static struct spi_board_info board_info = {
1192 .modalias = "msi001",
1193 .bus_num = 0,
1194 .chip_select = 0,
1195 .max_speed_hz = 12000000,
1196 };
1197
1198 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1199 if (!dev) {
1200 ret = -ENOMEM;
1201 goto err;
1202 }
1203
1204 mutex_init(&dev->v4l2_lock);
1205 mutex_init(&dev->vb_queue_lock);
1206 spin_lock_init(&dev->queued_bufs_lock);
1207 INIT_LIST_HEAD(&dev->queued_bufs);
1208 dev->dev = &intf->dev;
1209 dev->udev = interface_to_usbdev(intf);
1210 dev->f_adc = bands[0].rangelow;
1211 dev->pixelformat = formats[0].pixelformat;
1212 dev->buffersize = formats[0].buffersize;
1213 dev->num_formats = NUM_FORMATS;
1214 if (!msi2500_emulated_fmt)
1215 dev->num_formats -= 2;
1216
1217
1218 dev->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1219 dev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1220 dev->vb_queue.drv_priv = dev;
1221 dev->vb_queue.buf_struct_size = sizeof(struct msi2500_frame_buf);
1222 dev->vb_queue.ops = &msi2500_vb2_ops;
1223 dev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1224 dev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1225 ret = vb2_queue_init(&dev->vb_queue);
1226 if (ret) {
1227 dev_err(dev->dev, "Could not initialize vb2 queue\n");
1228 goto err_free_mem;
1229 }
1230
1231
1232 dev->vdev = msi2500_template;
1233 dev->vdev.queue = &dev->vb_queue;
1234 dev->vdev.queue->lock = &dev->vb_queue_lock;
1235 video_set_drvdata(&dev->vdev, dev);
1236
1237
1238 dev->v4l2_dev.release = msi2500_video_release;
1239 ret = v4l2_device_register(&intf->dev, &dev->v4l2_dev);
1240 if (ret) {
1241 dev_err(dev->dev, "Failed to register v4l2-device (%d)\n", ret);
1242 goto err_free_mem;
1243 }
1244
1245
1246 master = spi_alloc_master(dev->dev, 0);
1247 if (master == NULL) {
1248 ret = -ENOMEM;
1249 goto err_unregister_v4l2_dev;
1250 }
1251
1252 dev->master = master;
1253 master->bus_num = 0;
1254 master->num_chipselect = 1;
1255 master->transfer_one_message = msi2500_transfer_one_message;
1256 spi_master_set_devdata(master, dev);
1257 ret = spi_register_master(master);
1258 if (ret) {
1259 spi_master_put(master);
1260 goto err_unregister_v4l2_dev;
1261 }
1262
1263
1264 sd = v4l2_spi_new_subdev(&dev->v4l2_dev, master, &board_info);
1265 dev->v4l2_subdev = sd;
1266 if (sd == NULL) {
1267 dev_err(dev->dev, "cannot get v4l2 subdevice\n");
1268 ret = -ENODEV;
1269 goto err_unregister_master;
1270 }
1271
1272
1273 v4l2_ctrl_handler_init(&dev->hdl, 0);
1274 if (dev->hdl.error) {
1275 ret = dev->hdl.error;
1276 dev_err(dev->dev, "Could not initialize controls\n");
1277 goto err_free_controls;
1278 }
1279
1280
1281 v4l2_ctrl_add_handler(&dev->hdl, sd->ctrl_handler, NULL);
1282
1283 dev->v4l2_dev.ctrl_handler = &dev->hdl;
1284 dev->vdev.v4l2_dev = &dev->v4l2_dev;
1285 dev->vdev.lock = &dev->v4l2_lock;
1286
1287 ret = video_register_device(&dev->vdev, VFL_TYPE_SDR, -1);
1288 if (ret) {
1289 dev_err(dev->dev,
1290 "Failed to register as video device (%d)\n", ret);
1291 goto err_unregister_v4l2_dev;
1292 }
1293 dev_info(dev->dev, "Registered as %s\n",
1294 video_device_node_name(&dev->vdev));
1295 dev_notice(dev->dev,
1296 "SDR API is still slightly experimental and functionality changes may follow\n");
1297 return 0;
1298err_free_controls:
1299 v4l2_ctrl_handler_free(&dev->hdl);
1300err_unregister_master:
1301 spi_unregister_master(dev->master);
1302err_unregister_v4l2_dev:
1303 v4l2_device_unregister(&dev->v4l2_dev);
1304err_free_mem:
1305 kfree(dev);
1306err:
1307 return ret;
1308}
1309
1310
1311static struct usb_device_id msi2500_id_table[] = {
1312 {USB_DEVICE(0x1df7, 0x2500)},
1313 {USB_DEVICE(0x2040, 0xd300)},
1314 {}
1315};
1316MODULE_DEVICE_TABLE(usb, msi2500_id_table);
1317
1318
1319static struct usb_driver msi2500_driver = {
1320 .name = KBUILD_MODNAME,
1321 .probe = msi2500_probe,
1322 .disconnect = msi2500_disconnect,
1323 .id_table = msi2500_id_table,
1324};
1325
1326module_usb_driver(msi2500_driver);
1327
1328MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1329MODULE_DESCRIPTION("Mirics MSi3101 SDR Dongle");
1330MODULE_LICENSE("GPL");
1331