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