This source file includes following definitions.
- msi2500_get_next_fill_buf
- msi2500_convert_stream
- msi2500_isoc_handler
- msi2500_iso_stop
- msi2500_iso_free
- msi2500_isoc_cleanup
- msi2500_isoc_init
- msi2500_cleanup_queued_bufs
- msi2500_disconnect
- msi2500_querycap
- msi2500_queue_setup
- msi2500_buf_queue
- msi2500_ctrl_msg
- msi2500_set_usb_adc
- msi2500_start_streaming
- msi2500_stop_streaming
- msi2500_enum_fmt_sdr_cap
- msi2500_g_fmt_sdr_cap
- msi2500_s_fmt_sdr_cap
- msi2500_try_fmt_sdr_cap
- msi2500_s_tuner
- msi2500_g_tuner
- msi2500_g_frequency
- msi2500_s_frequency
- msi2500_enum_freq_bands
- msi2500_video_release
- msi2500_transfer_one_message
- msi2500_probe
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
26 static bool msi2500_emulated_fmt;
27 module_param_named(emulated_formats, msi2500_emulated_fmt, bool, 0644);
28 MODULE_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
56 static 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
68 struct msi2500_format {
69 u32 pixelformat;
70 u32 buffersize;
71 };
72
73
74 static 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
96 static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats);
97
98
99 struct msi2500_frame_buf {
100
101 struct vb2_v4l2_buffer vb;
102 struct list_head list;
103 };
104
105 struct 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
143 static 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);
155 leave:
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
242 static 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
363 static 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
426 handler_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
432 static 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
447 static 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
470 static 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
479 static 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
544 static 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
563 static 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
584 static 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
598 static 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
615 static 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
651 static 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
670 static 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);
822 err:
823 return ret;
824 }
825
826 static 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
855 static 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 (!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
881 static 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
890 static 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
905 static 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 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
916
917 return 0;
918 }
919
920 static int msi2500_s_fmt_sdr_cap(struct file *file, void *priv,
921 struct v4l2_format *f)
922 {
923 struct msi2500_dev *dev = video_drvdata(file);
924 struct vb2_queue *q = &dev->vb_queue;
925 int i;
926
927 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
928 (char *)&f->fmt.sdr.pixelformat);
929
930 if (vb2_is_busy(q))
931 return -EBUSY;
932
933 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
934 for (i = 0; i < dev->num_formats; i++) {
935 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
936 dev->pixelformat = formats[i].pixelformat;
937 dev->buffersize = formats[i].buffersize;
938 f->fmt.sdr.buffersize = formats[i].buffersize;
939 return 0;
940 }
941 }
942
943 dev->pixelformat = formats[0].pixelformat;
944 dev->buffersize = formats[0].buffersize;
945 f->fmt.sdr.pixelformat = formats[0].pixelformat;
946 f->fmt.sdr.buffersize = formats[0].buffersize;
947
948 return 0;
949 }
950
951 static int msi2500_try_fmt_sdr_cap(struct file *file, void *priv,
952 struct v4l2_format *f)
953 {
954 struct msi2500_dev *dev = video_drvdata(file);
955 int i;
956
957 dev_dbg(dev->dev, "pixelformat fourcc %4.4s\n",
958 (char *)&f->fmt.sdr.pixelformat);
959
960 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
961 for (i = 0; i < dev->num_formats; i++) {
962 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
963 f->fmt.sdr.buffersize = formats[i].buffersize;
964 return 0;
965 }
966 }
967
968 f->fmt.sdr.pixelformat = formats[0].pixelformat;
969 f->fmt.sdr.buffersize = formats[0].buffersize;
970
971 return 0;
972 }
973
974 static int msi2500_s_tuner(struct file *file, void *priv,
975 const struct v4l2_tuner *v)
976 {
977 struct msi2500_dev *dev = video_drvdata(file);
978 int ret;
979
980 dev_dbg(dev->dev, "index=%d\n", v->index);
981
982 if (v->index == 0)
983 ret = 0;
984 else if (v->index == 1)
985 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, s_tuner, v);
986 else
987 ret = -EINVAL;
988
989 return ret;
990 }
991
992 static int msi2500_g_tuner(struct file *file, void *priv, struct v4l2_tuner *v)
993 {
994 struct msi2500_dev *dev = video_drvdata(file);
995 int ret;
996
997 dev_dbg(dev->dev, "index=%d\n", v->index);
998
999 if (v->index == 0) {
1000 strscpy(v->name, "Mirics MSi2500", sizeof(v->name));
1001 v->type = V4L2_TUNER_ADC;
1002 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1003 v->rangelow = 1200000;
1004 v->rangehigh = 15000000;
1005 ret = 0;
1006 } else if (v->index == 1) {
1007 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, g_tuner, v);
1008 } else {
1009 ret = -EINVAL;
1010 }
1011
1012 return ret;
1013 }
1014
1015 static int msi2500_g_frequency(struct file *file, void *priv,
1016 struct v4l2_frequency *f)
1017 {
1018 struct msi2500_dev *dev = video_drvdata(file);
1019 int ret = 0;
1020
1021 dev_dbg(dev->dev, "tuner=%d type=%d\n", f->tuner, f->type);
1022
1023 if (f->tuner == 0) {
1024 f->frequency = dev->f_adc;
1025 ret = 0;
1026 } else if (f->tuner == 1) {
1027 f->type = V4L2_TUNER_RF;
1028 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, g_frequency, f);
1029 } else {
1030 ret = -EINVAL;
1031 }
1032
1033 return ret;
1034 }
1035
1036 static int msi2500_s_frequency(struct file *file, void *priv,
1037 const struct v4l2_frequency *f)
1038 {
1039 struct msi2500_dev *dev = video_drvdata(file);
1040 int ret;
1041
1042 dev_dbg(dev->dev, "tuner=%d type=%d frequency=%u\n",
1043 f->tuner, f->type, f->frequency);
1044
1045 if (f->tuner == 0) {
1046 dev->f_adc = clamp_t(unsigned int, f->frequency,
1047 bands[0].rangelow,
1048 bands[0].rangehigh);
1049 dev_dbg(dev->dev, "ADC frequency=%u Hz\n", dev->f_adc);
1050 ret = msi2500_set_usb_adc(dev);
1051 } else if (f->tuner == 1) {
1052 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner, s_frequency, f);
1053 } else {
1054 ret = -EINVAL;
1055 }
1056
1057 return ret;
1058 }
1059
1060 static int msi2500_enum_freq_bands(struct file *file, void *priv,
1061 struct v4l2_frequency_band *band)
1062 {
1063 struct msi2500_dev *dev = video_drvdata(file);
1064 int ret;
1065
1066 dev_dbg(dev->dev, "tuner=%d type=%d index=%d\n",
1067 band->tuner, band->type, band->index);
1068
1069 if (band->tuner == 0) {
1070 if (band->index >= ARRAY_SIZE(bands)) {
1071 ret = -EINVAL;
1072 } else {
1073 *band = bands[band->index];
1074 ret = 0;
1075 }
1076 } else if (band->tuner == 1) {
1077 ret = v4l2_subdev_call(dev->v4l2_subdev, tuner,
1078 enum_freq_bands, band);
1079 } else {
1080 ret = -EINVAL;
1081 }
1082
1083 return ret;
1084 }
1085
1086 static const struct v4l2_ioctl_ops msi2500_ioctl_ops = {
1087 .vidioc_querycap = msi2500_querycap,
1088
1089 .vidioc_enum_fmt_sdr_cap = msi2500_enum_fmt_sdr_cap,
1090 .vidioc_g_fmt_sdr_cap = msi2500_g_fmt_sdr_cap,
1091 .vidioc_s_fmt_sdr_cap = msi2500_s_fmt_sdr_cap,
1092 .vidioc_try_fmt_sdr_cap = msi2500_try_fmt_sdr_cap,
1093
1094 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1095 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1096 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1097 .vidioc_querybuf = vb2_ioctl_querybuf,
1098 .vidioc_qbuf = vb2_ioctl_qbuf,
1099 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1100
1101 .vidioc_streamon = vb2_ioctl_streamon,
1102 .vidioc_streamoff = vb2_ioctl_streamoff,
1103
1104 .vidioc_g_tuner = msi2500_g_tuner,
1105 .vidioc_s_tuner = msi2500_s_tuner,
1106
1107 .vidioc_g_frequency = msi2500_g_frequency,
1108 .vidioc_s_frequency = msi2500_s_frequency,
1109 .vidioc_enum_freq_bands = msi2500_enum_freq_bands,
1110
1111 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1112 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1113 .vidioc_log_status = v4l2_ctrl_log_status,
1114 };
1115
1116 static const struct v4l2_file_operations msi2500_fops = {
1117 .owner = THIS_MODULE,
1118 .open = v4l2_fh_open,
1119 .release = vb2_fop_release,
1120 .read = vb2_fop_read,
1121 .poll = vb2_fop_poll,
1122 .mmap = vb2_fop_mmap,
1123 .unlocked_ioctl = video_ioctl2,
1124 };
1125
1126 static const struct video_device msi2500_template = {
1127 .name = "Mirics MSi3101 SDR Dongle",
1128 .release = video_device_release_empty,
1129 .fops = &msi2500_fops,
1130 .ioctl_ops = &msi2500_ioctl_ops,
1131 };
1132
1133 static void msi2500_video_release(struct v4l2_device *v)
1134 {
1135 struct msi2500_dev *dev = container_of(v, struct msi2500_dev, v4l2_dev);
1136
1137 v4l2_ctrl_handler_free(&dev->hdl);
1138 v4l2_device_unregister(&dev->v4l2_dev);
1139 kfree(dev);
1140 }
1141
1142 static int msi2500_transfer_one_message(struct spi_master *master,
1143 struct spi_message *m)
1144 {
1145 struct msi2500_dev *dev = spi_master_get_devdata(master);
1146 struct spi_transfer *t;
1147 int ret = 0;
1148 u32 data;
1149
1150 list_for_each_entry(t, &m->transfers, transfer_list) {
1151 dev_dbg(dev->dev, "msg=%*ph\n", t->len, t->tx_buf);
1152 data = 0x09;
1153 data |= ((u8 *)t->tx_buf)[0] << 8;
1154 data |= ((u8 *)t->tx_buf)[1] << 16;
1155 data |= ((u8 *)t->tx_buf)[2] << 24;
1156 ret = msi2500_ctrl_msg(dev, CMD_WREG, data);
1157 }
1158
1159 m->status = ret;
1160 spi_finalize_current_message(master);
1161 return ret;
1162 }
1163
1164 static int msi2500_probe(struct usb_interface *intf,
1165 const struct usb_device_id *id)
1166 {
1167 struct msi2500_dev *dev;
1168 struct v4l2_subdev *sd;
1169 struct spi_master *master;
1170 int ret;
1171 static struct spi_board_info board_info = {
1172 .modalias = "msi001",
1173 .bus_num = 0,
1174 .chip_select = 0,
1175 .max_speed_hz = 12000000,
1176 };
1177
1178 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1179 if (!dev) {
1180 ret = -ENOMEM;
1181 goto err;
1182 }
1183
1184 mutex_init(&dev->v4l2_lock);
1185 mutex_init(&dev->vb_queue_lock);
1186 spin_lock_init(&dev->queued_bufs_lock);
1187 INIT_LIST_HEAD(&dev->queued_bufs);
1188 dev->dev = &intf->dev;
1189 dev->udev = interface_to_usbdev(intf);
1190 dev->f_adc = bands[0].rangelow;
1191 dev->pixelformat = formats[0].pixelformat;
1192 dev->buffersize = formats[0].buffersize;
1193 dev->num_formats = NUM_FORMATS;
1194 if (!msi2500_emulated_fmt)
1195 dev->num_formats -= 2;
1196
1197
1198 dev->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1199 dev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1200 dev->vb_queue.drv_priv = dev;
1201 dev->vb_queue.buf_struct_size = sizeof(struct msi2500_frame_buf);
1202 dev->vb_queue.ops = &msi2500_vb2_ops;
1203 dev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1204 dev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1205 ret = vb2_queue_init(&dev->vb_queue);
1206 if (ret) {
1207 dev_err(dev->dev, "Could not initialize vb2 queue\n");
1208 goto err_free_mem;
1209 }
1210
1211
1212 dev->vdev = msi2500_template;
1213 dev->vdev.queue = &dev->vb_queue;
1214 dev->vdev.queue->lock = &dev->vb_queue_lock;
1215 video_set_drvdata(&dev->vdev, dev);
1216
1217
1218 dev->v4l2_dev.release = msi2500_video_release;
1219 ret = v4l2_device_register(&intf->dev, &dev->v4l2_dev);
1220 if (ret) {
1221 dev_err(dev->dev, "Failed to register v4l2-device (%d)\n", ret);
1222 goto err_free_mem;
1223 }
1224
1225
1226 master = spi_alloc_master(dev->dev, 0);
1227 if (master == NULL) {
1228 ret = -ENOMEM;
1229 goto err_unregister_v4l2_dev;
1230 }
1231
1232 dev->master = master;
1233 master->bus_num = 0;
1234 master->num_chipselect = 1;
1235 master->transfer_one_message = msi2500_transfer_one_message;
1236 spi_master_set_devdata(master, dev);
1237 ret = spi_register_master(master);
1238 if (ret) {
1239 spi_master_put(master);
1240 goto err_unregister_v4l2_dev;
1241 }
1242
1243
1244 sd = v4l2_spi_new_subdev(&dev->v4l2_dev, master, &board_info);
1245 dev->v4l2_subdev = sd;
1246 if (sd == NULL) {
1247 dev_err(dev->dev, "cannot get v4l2 subdevice\n");
1248 ret = -ENODEV;
1249 goto err_unregister_master;
1250 }
1251
1252
1253 v4l2_ctrl_handler_init(&dev->hdl, 0);
1254 if (dev->hdl.error) {
1255 ret = dev->hdl.error;
1256 dev_err(dev->dev, "Could not initialize controls\n");
1257 goto err_free_controls;
1258 }
1259
1260
1261 v4l2_ctrl_add_handler(&dev->hdl, sd->ctrl_handler, NULL, true);
1262
1263 dev->v4l2_dev.ctrl_handler = &dev->hdl;
1264 dev->vdev.v4l2_dev = &dev->v4l2_dev;
1265 dev->vdev.lock = &dev->v4l2_lock;
1266 dev->vdev.device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
1267 V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
1268
1269 ret = video_register_device(&dev->vdev, VFL_TYPE_SDR, -1);
1270 if (ret) {
1271 dev_err(dev->dev,
1272 "Failed to register as video device (%d)\n", ret);
1273 goto err_unregister_v4l2_dev;
1274 }
1275 dev_info(dev->dev, "Registered as %s\n",
1276 video_device_node_name(&dev->vdev));
1277 dev_notice(dev->dev,
1278 "SDR API is still slightly experimental and functionality changes may follow\n");
1279 return 0;
1280 err_free_controls:
1281 v4l2_ctrl_handler_free(&dev->hdl);
1282 err_unregister_master:
1283 spi_unregister_master(dev->master);
1284 err_unregister_v4l2_dev:
1285 v4l2_device_unregister(&dev->v4l2_dev);
1286 err_free_mem:
1287 kfree(dev);
1288 err:
1289 return ret;
1290 }
1291
1292
1293 static const struct usb_device_id msi2500_id_table[] = {
1294 {USB_DEVICE(0x1df7, 0x2500)},
1295 {USB_DEVICE(0x2040, 0xd300)},
1296 {}
1297 };
1298 MODULE_DEVICE_TABLE(usb, msi2500_id_table);
1299
1300
1301 static struct usb_driver msi2500_driver = {
1302 .name = KBUILD_MODNAME,
1303 .probe = msi2500_probe,
1304 .disconnect = msi2500_disconnect,
1305 .id_table = msi2500_id_table,
1306 };
1307
1308 module_usb_driver(msi2500_driver);
1309
1310 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1311 MODULE_DESCRIPTION("Mirics MSi3101 SDR Dongle");
1312 MODULE_LICENSE("GPL");