1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92#include <linux/kernel.h>
93#include <linux/module.h>
94#include <linux/init.h>
95#include <linux/slab.h>
96#include <linux/input.h>
97#include <linux/videodev2.h>
98#include <media/v4l2-device.h>
99#include <media/v4l2-ioctl.h>
100#include <linux/usb.h>
101
102
103
104
105#include <linux/version.h>
106
107#define DRIVER_VERSION "v0.46"
108#define RADIO_VERSION KERNEL_VERSION(0, 4, 6)
109
110#define DRIVER_AUTHOR "Markus Demleitner <msdemlei@tucana.harvard.edu>"
111#define DRIVER_DESC "D-Link DSB-R100 USB FM radio driver"
112
113#define DSB100_VENDOR 0x04b4
114#define DSB100_PRODUCT 0x1002
115
116
117#define DSB100_TUNE 1
118#define DSB100_ONOFF 2
119
120#define TB_LEN 16
121
122
123
124#define FREQ_MIN 87.5
125#define FREQ_MAX 108.0
126#define FREQ_MUL 16000
127
128
129#define STARTED 0
130#define STOPPED 1
131
132#define videodev_to_radio(d) container_of(d, struct dsbr100_device, videodev)
133
134static int usb_dsbr100_probe(struct usb_interface *intf,
135 const struct usb_device_id *id);
136static void usb_dsbr100_disconnect(struct usb_interface *intf);
137static int usb_dsbr100_suspend(struct usb_interface *intf,
138 pm_message_t message);
139static int usb_dsbr100_resume(struct usb_interface *intf);
140
141static int radio_nr = -1;
142module_param(radio_nr, int, 0);
143
144
145struct dsbr100_device {
146 struct usb_device *usbdev;
147 struct video_device videodev;
148 struct v4l2_device v4l2_dev;
149
150 u8 *transfer_buffer;
151 struct mutex lock;
152 int curfreq;
153 int stereo;
154 int removed;
155 int status;
156};
157
158static struct usb_device_id usb_dsbr100_device_table [] = {
159 { USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) },
160 { }
161};
162
163MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table);
164
165
166static struct usb_driver usb_dsbr100_driver = {
167 .name = "dsbr100",
168 .probe = usb_dsbr100_probe,
169 .disconnect = usb_dsbr100_disconnect,
170 .id_table = usb_dsbr100_device_table,
171 .suspend = usb_dsbr100_suspend,
172 .resume = usb_dsbr100_resume,
173 .reset_resume = usb_dsbr100_resume,
174 .supports_autosuspend = 0,
175};
176
177
178
179
180static int dsbr100_start(struct dsbr100_device *radio)
181{
182 int retval;
183 int request;
184
185 mutex_lock(&radio->lock);
186
187 retval = usb_control_msg(radio->usbdev,
188 usb_rcvctrlpipe(radio->usbdev, 0),
189 USB_REQ_GET_STATUS,
190 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
191 0x00, 0xC7, radio->transfer_buffer, 8, 300);
192
193 if (retval < 0) {
194 request = USB_REQ_GET_STATUS;
195 goto usb_control_msg_failed;
196 }
197
198 retval = usb_control_msg(radio->usbdev,
199 usb_rcvctrlpipe(radio->usbdev, 0),
200 DSB100_ONOFF,
201 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
202 0x01, 0x00, radio->transfer_buffer, 8, 300);
203
204 if (retval < 0) {
205 request = DSB100_ONOFF;
206 goto usb_control_msg_failed;
207 }
208
209 radio->status = STARTED;
210 mutex_unlock(&radio->lock);
211 return (radio->transfer_buffer)[0];
212
213usb_control_msg_failed:
214 mutex_unlock(&radio->lock);
215 dev_err(&radio->usbdev->dev,
216 "%s - usb_control_msg returned %i, request %i\n",
217 __func__, retval, request);
218 return retval;
219
220}
221
222
223static int dsbr100_stop(struct dsbr100_device *radio)
224{
225 int retval;
226 int request;
227
228 mutex_lock(&radio->lock);
229
230 retval = usb_control_msg(radio->usbdev,
231 usb_rcvctrlpipe(radio->usbdev, 0),
232 USB_REQ_GET_STATUS,
233 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
234 0x16, 0x1C, radio->transfer_buffer, 8, 300);
235
236 if (retval < 0) {
237 request = USB_REQ_GET_STATUS;
238 goto usb_control_msg_failed;
239 }
240
241 retval = usb_control_msg(radio->usbdev,
242 usb_rcvctrlpipe(radio->usbdev, 0),
243 DSB100_ONOFF,
244 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
245 0x00, 0x00, radio->transfer_buffer, 8, 300);
246
247 if (retval < 0) {
248 request = DSB100_ONOFF;
249 goto usb_control_msg_failed;
250 }
251
252 radio->status = STOPPED;
253 mutex_unlock(&radio->lock);
254 return (radio->transfer_buffer)[0];
255
256usb_control_msg_failed:
257 mutex_unlock(&radio->lock);
258 dev_err(&radio->usbdev->dev,
259 "%s - usb_control_msg returned %i, request %i\n",
260 __func__, retval, request);
261 return retval;
262
263}
264
265
266static int dsbr100_setfreq(struct dsbr100_device *radio)
267{
268 int retval;
269 int request;
270 int freq = (radio->curfreq / 16 * 80) / 1000 + 856;
271
272 mutex_lock(&radio->lock);
273
274 retval = usb_control_msg(radio->usbdev,
275 usb_rcvctrlpipe(radio->usbdev, 0),
276 DSB100_TUNE,
277 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
278 (freq >> 8) & 0x00ff, freq & 0xff,
279 radio->transfer_buffer, 8, 300);
280
281 if (retval < 0) {
282 request = DSB100_TUNE;
283 goto usb_control_msg_failed;
284 }
285
286 retval = usb_control_msg(radio->usbdev,
287 usb_rcvctrlpipe(radio->usbdev, 0),
288 USB_REQ_GET_STATUS,
289 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
290 0x96, 0xB7, radio->transfer_buffer, 8, 300);
291
292 if (retval < 0) {
293 request = USB_REQ_GET_STATUS;
294 goto usb_control_msg_failed;
295 }
296
297 retval = usb_control_msg(radio->usbdev,
298 usb_rcvctrlpipe(radio->usbdev, 0),
299 USB_REQ_GET_STATUS,
300 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
301 0x00, 0x24, radio->transfer_buffer, 8, 300);
302
303 if (retval < 0) {
304 request = USB_REQ_GET_STATUS;
305 goto usb_control_msg_failed;
306 }
307
308 radio->stereo = !((radio->transfer_buffer)[0] & 0x01);
309 mutex_unlock(&radio->lock);
310 return (radio->transfer_buffer)[0];
311
312usb_control_msg_failed:
313 radio->stereo = -1;
314 mutex_unlock(&radio->lock);
315 dev_err(&radio->usbdev->dev,
316 "%s - usb_control_msg returned %i, request %i\n",
317 __func__, retval, request);
318 return retval;
319}
320
321
322
323static void dsbr100_getstat(struct dsbr100_device *radio)
324{
325 int retval;
326
327 mutex_lock(&radio->lock);
328
329 retval = usb_control_msg(radio->usbdev,
330 usb_rcvctrlpipe(radio->usbdev, 0),
331 USB_REQ_GET_STATUS,
332 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
333 0x00 , 0x24, radio->transfer_buffer, 8, 300);
334
335 if (retval < 0) {
336 radio->stereo = -1;
337 dev_err(&radio->usbdev->dev,
338 "%s - usb_control_msg returned %i, request %i\n",
339 __func__, retval, USB_REQ_GET_STATUS);
340 } else {
341 radio->stereo = !(radio->transfer_buffer[0] & 0x01);
342 }
343
344 mutex_unlock(&radio->lock);
345}
346
347
348
349
350
351
352
353
354
355static void usb_dsbr100_disconnect(struct usb_interface *intf)
356{
357 struct dsbr100_device *radio = usb_get_intfdata(intf);
358
359 usb_set_intfdata (intf, NULL);
360
361 mutex_lock(&radio->lock);
362 radio->removed = 1;
363 mutex_unlock(&radio->lock);
364
365 video_unregister_device(&radio->videodev);
366 v4l2_device_disconnect(&radio->v4l2_dev);
367}
368
369
370static int vidioc_querycap(struct file *file, void *priv,
371 struct v4l2_capability *v)
372{
373 struct dsbr100_device *radio = video_drvdata(file);
374
375 strlcpy(v->driver, "dsbr100", sizeof(v->driver));
376 strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card));
377 usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
378 v->version = RADIO_VERSION;
379 v->capabilities = V4L2_CAP_TUNER;
380 return 0;
381}
382
383static int vidioc_g_tuner(struct file *file, void *priv,
384 struct v4l2_tuner *v)
385{
386 struct dsbr100_device *radio = video_drvdata(file);
387
388
389 if (radio->removed)
390 return -EIO;
391
392 if (v->index > 0)
393 return -EINVAL;
394
395 dsbr100_getstat(radio);
396 strcpy(v->name, "FM");
397 v->type = V4L2_TUNER_RADIO;
398 v->rangelow = FREQ_MIN * FREQ_MUL;
399 v->rangehigh = FREQ_MAX * FREQ_MUL;
400 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
401 v->capability = V4L2_TUNER_CAP_LOW;
402 if(radio->stereo)
403 v->audmode = V4L2_TUNER_MODE_STEREO;
404 else
405 v->audmode = V4L2_TUNER_MODE_MONO;
406 v->signal = 0xffff;
407 return 0;
408}
409
410static int vidioc_s_tuner(struct file *file, void *priv,
411 struct v4l2_tuner *v)
412{
413 struct dsbr100_device *radio = video_drvdata(file);
414
415
416 if (radio->removed)
417 return -EIO;
418
419 if (v->index > 0)
420 return -EINVAL;
421
422 return 0;
423}
424
425static int vidioc_s_frequency(struct file *file, void *priv,
426 struct v4l2_frequency *f)
427{
428 struct dsbr100_device *radio = video_drvdata(file);
429 int retval;
430
431
432 if (radio->removed)
433 return -EIO;
434
435 mutex_lock(&radio->lock);
436 radio->curfreq = f->frequency;
437 mutex_unlock(&radio->lock);
438
439 retval = dsbr100_setfreq(radio);
440 if (retval < 0)
441 dev_warn(&radio->usbdev->dev, "Set frequency failed\n");
442 return 0;
443}
444
445static int vidioc_g_frequency(struct file *file, void *priv,
446 struct v4l2_frequency *f)
447{
448 struct dsbr100_device *radio = video_drvdata(file);
449
450
451 if (radio->removed)
452 return -EIO;
453
454 f->type = V4L2_TUNER_RADIO;
455 f->frequency = radio->curfreq;
456 return 0;
457}
458
459static int vidioc_queryctrl(struct file *file, void *priv,
460 struct v4l2_queryctrl *qc)
461{
462 switch (qc->id) {
463 case V4L2_CID_AUDIO_MUTE:
464 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
465 }
466
467 return -EINVAL;
468}
469
470static int vidioc_g_ctrl(struct file *file, void *priv,
471 struct v4l2_control *ctrl)
472{
473 struct dsbr100_device *radio = video_drvdata(file);
474
475
476 if (radio->removed)
477 return -EIO;
478
479 switch (ctrl->id) {
480 case V4L2_CID_AUDIO_MUTE:
481 ctrl->value = radio->status;
482 return 0;
483 }
484 return -EINVAL;
485}
486
487static int vidioc_s_ctrl(struct file *file, void *priv,
488 struct v4l2_control *ctrl)
489{
490 struct dsbr100_device *radio = video_drvdata(file);
491 int retval;
492
493
494 if (radio->removed)
495 return -EIO;
496
497 switch (ctrl->id) {
498 case V4L2_CID_AUDIO_MUTE:
499 if (ctrl->value) {
500 retval = dsbr100_stop(radio);
501 if (retval < 0) {
502 dev_warn(&radio->usbdev->dev,
503 "Radio did not respond properly\n");
504 return -EBUSY;
505 }
506 } else {
507 retval = dsbr100_start(radio);
508 if (retval < 0) {
509 dev_warn(&radio->usbdev->dev,
510 "Radio did not respond properly\n");
511 return -EBUSY;
512 }
513 }
514 return 0;
515 }
516 return -EINVAL;
517}
518
519static int vidioc_g_audio(struct file *file, void *priv,
520 struct v4l2_audio *a)
521{
522 if (a->index > 1)
523 return -EINVAL;
524
525 strcpy(a->name, "Radio");
526 a->capability = V4L2_AUDCAP_STEREO;
527 return 0;
528}
529
530static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
531{
532 *i = 0;
533 return 0;
534}
535
536static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
537{
538 if (i != 0)
539 return -EINVAL;
540 return 0;
541}
542
543static int vidioc_s_audio(struct file *file, void *priv,
544 struct v4l2_audio *a)
545{
546 if (a->index != 0)
547 return -EINVAL;
548 return 0;
549}
550
551
552static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message)
553{
554 struct dsbr100_device *radio = usb_get_intfdata(intf);
555 int retval;
556
557 if (radio->status == STARTED) {
558 retval = dsbr100_stop(radio);
559 if (retval < 0)
560 dev_warn(&intf->dev, "dsbr100_stop failed\n");
561
562
563
564
565
566
567
568 mutex_lock(&radio->lock);
569 radio->status = STARTED;
570 mutex_unlock(&radio->lock);
571 }
572
573 dev_info(&intf->dev, "going into suspend..\n");
574
575 return 0;
576}
577
578
579static int usb_dsbr100_resume(struct usb_interface *intf)
580{
581 struct dsbr100_device *radio = usb_get_intfdata(intf);
582 int retval;
583
584 if (radio->status == STARTED) {
585 retval = dsbr100_start(radio);
586 if (retval < 0)
587 dev_warn(&intf->dev, "dsbr100_start failed\n");
588 }
589
590 dev_info(&intf->dev, "coming out of suspend..\n");
591
592 return 0;
593}
594
595
596static void usb_dsbr100_video_device_release(struct video_device *videodev)
597{
598 struct dsbr100_device *radio = videodev_to_radio(videodev);
599
600 v4l2_device_unregister(&radio->v4l2_dev);
601 kfree(radio->transfer_buffer);
602 kfree(radio);
603}
604
605
606static const struct v4l2_file_operations usb_dsbr100_fops = {
607 .owner = THIS_MODULE,
608 .ioctl = video_ioctl2,
609};
610
611static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = {
612 .vidioc_querycap = vidioc_querycap,
613 .vidioc_g_tuner = vidioc_g_tuner,
614 .vidioc_s_tuner = vidioc_s_tuner,
615 .vidioc_g_frequency = vidioc_g_frequency,
616 .vidioc_s_frequency = vidioc_s_frequency,
617 .vidioc_queryctrl = vidioc_queryctrl,
618 .vidioc_g_ctrl = vidioc_g_ctrl,
619 .vidioc_s_ctrl = vidioc_s_ctrl,
620 .vidioc_g_audio = vidioc_g_audio,
621 .vidioc_s_audio = vidioc_s_audio,
622 .vidioc_g_input = vidioc_g_input,
623 .vidioc_s_input = vidioc_s_input,
624};
625
626
627static int usb_dsbr100_probe(struct usb_interface *intf,
628 const struct usb_device_id *id)
629{
630 struct dsbr100_device *radio;
631 struct v4l2_device *v4l2_dev;
632 int retval;
633
634 radio = kzalloc(sizeof(struct dsbr100_device), GFP_KERNEL);
635
636 if (!radio)
637 return -ENOMEM;
638
639 radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL);
640
641 if (!(radio->transfer_buffer)) {
642 kfree(radio);
643 return -ENOMEM;
644 }
645
646 v4l2_dev = &radio->v4l2_dev;
647
648 retval = v4l2_device_register(&intf->dev, v4l2_dev);
649 if (retval < 0) {
650 v4l2_err(v4l2_dev, "couldn't register v4l2_device\n");
651 kfree(radio->transfer_buffer);
652 kfree(radio);
653 return retval;
654 }
655
656 strlcpy(radio->videodev.name, v4l2_dev->name, sizeof(radio->videodev.name));
657 radio->videodev.v4l2_dev = v4l2_dev;
658 radio->videodev.fops = &usb_dsbr100_fops;
659 radio->videodev.ioctl_ops = &usb_dsbr100_ioctl_ops;
660 radio->videodev.release = usb_dsbr100_video_device_release;
661
662 mutex_init(&radio->lock);
663
664 radio->removed = 0;
665 radio->usbdev = interface_to_usbdev(intf);
666 radio->curfreq = FREQ_MIN * FREQ_MUL;
667 radio->status = STOPPED;
668
669 video_set_drvdata(&radio->videodev, radio);
670
671 retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
672 if (retval < 0) {
673 v4l2_err(v4l2_dev, "couldn't register video device\n");
674 v4l2_device_unregister(v4l2_dev);
675 kfree(radio->transfer_buffer);
676 kfree(radio);
677 return -EIO;
678 }
679 usb_set_intfdata(intf, radio);
680 return 0;
681}
682
683static int __init dsbr100_init(void)
684{
685 int retval = usb_register(&usb_dsbr100_driver);
686 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
687 DRIVER_DESC "\n");
688 return retval;
689}
690
691static void __exit dsbr100_exit(void)
692{
693 usb_deregister(&usb_dsbr100_driver);
694}
695
696module_init (dsbr100_init);
697module_exit (dsbr100_exit);
698
699MODULE_AUTHOR( DRIVER_AUTHOR );
700MODULE_DESCRIPTION( DRIVER_DESC );
701MODULE_LICENSE("GPL");
702