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#include <linux/kernel.h>
34#include <linux/module.h>
35#include <linux/init.h>
36#include <linux/slab.h>
37#include <linux/input.h>
38#include <linux/videodev2.h>
39#include <linux/usb.h>
40#include <media/v4l2-device.h>
41#include <media/v4l2-ioctl.h>
42#include <media/v4l2-ctrls.h>
43#include <media/v4l2-event.h>
44
45
46
47
48MODULE_AUTHOR("Markus Demleitner <msdemlei@tucana.harvard.edu>");
49MODULE_DESCRIPTION("D-Link DSB-R100 USB FM radio driver");
50MODULE_LICENSE("GPL");
51MODULE_VERSION("1.1.0");
52
53#define DSB100_VENDOR 0x04b4
54#define DSB100_PRODUCT 0x1002
55
56
57#define DSB100_TUNE 1
58#define DSB100_ONOFF 2
59
60#define TB_LEN 16
61
62
63
64#define FREQ_MIN 87.5
65#define FREQ_MAX 108.0
66#define FREQ_MUL 16000
67
68#define v4l2_dev_to_radio(d) container_of(d, struct dsbr100_device, v4l2_dev)
69
70static int radio_nr = -1;
71module_param(radio_nr, int, 0);
72
73
74struct dsbr100_device {
75 struct usb_device *usbdev;
76 struct video_device videodev;
77 struct v4l2_device v4l2_dev;
78 struct v4l2_ctrl_handler hdl;
79
80 u8 *transfer_buffer;
81 struct mutex v4l2_lock;
82 int curfreq;
83 bool stereo;
84 bool muted;
85};
86
87
88
89
90static int dsbr100_setfreq(struct dsbr100_device *radio, unsigned freq)
91{
92 unsigned f = (freq / 16 * 80) / 1000 + 856;
93 int retval = 0;
94
95 if (!radio->muted) {
96 retval = usb_control_msg(radio->usbdev,
97 usb_rcvctrlpipe(radio->usbdev, 0),
98 DSB100_TUNE,
99 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
100 (f >> 8) & 0x00ff, f & 0xff,
101 radio->transfer_buffer, 8, 300);
102 if (retval >= 0)
103 mdelay(1);
104 }
105
106 if (retval >= 0) {
107 radio->curfreq = freq;
108 return 0;
109 }
110 dev_err(&radio->usbdev->dev,
111 "%s - usb_control_msg returned %i, request %i\n",
112 __func__, retval, DSB100_TUNE);
113 return retval;
114}
115
116
117static int dsbr100_start(struct dsbr100_device *radio)
118{
119 int retval = usb_control_msg(radio->usbdev,
120 usb_rcvctrlpipe(radio->usbdev, 0),
121 DSB100_ONOFF,
122 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
123 0x01, 0x00, radio->transfer_buffer, 8, 300);
124
125 if (retval >= 0)
126 return dsbr100_setfreq(radio, radio->curfreq);
127 dev_err(&radio->usbdev->dev,
128 "%s - usb_control_msg returned %i, request %i\n",
129 __func__, retval, DSB100_ONOFF);
130 return retval;
131
132}
133
134
135static int dsbr100_stop(struct dsbr100_device *radio)
136{
137 int retval = usb_control_msg(radio->usbdev,
138 usb_rcvctrlpipe(radio->usbdev, 0),
139 DSB100_ONOFF,
140 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
141 0x00, 0x00, radio->transfer_buffer, 8, 300);
142
143 if (retval >= 0)
144 return 0;
145 dev_err(&radio->usbdev->dev,
146 "%s - usb_control_msg returned %i, request %i\n",
147 __func__, retval, DSB100_ONOFF);
148 return retval;
149
150}
151
152
153
154static void dsbr100_getstat(struct dsbr100_device *radio)
155{
156 int retval = usb_control_msg(radio->usbdev,
157 usb_rcvctrlpipe(radio->usbdev, 0),
158 USB_REQ_GET_STATUS,
159 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
160 0x00, 0x24, radio->transfer_buffer, 8, 300);
161
162 if (retval < 0) {
163 radio->stereo = false;
164 dev_err(&radio->usbdev->dev,
165 "%s - usb_control_msg returned %i, request %i\n",
166 __func__, retval, USB_REQ_GET_STATUS);
167 } else {
168 radio->stereo = !(radio->transfer_buffer[0] & 0x01);
169 }
170}
171
172static int vidioc_querycap(struct file *file, void *priv,
173 struct v4l2_capability *v)
174{
175 struct dsbr100_device *radio = video_drvdata(file);
176
177 strlcpy(v->driver, "dsbr100", sizeof(v->driver));
178 strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card));
179 usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
180 v->device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
181 v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
182 return 0;
183}
184
185static int vidioc_g_tuner(struct file *file, void *priv,
186 struct v4l2_tuner *v)
187{
188 struct dsbr100_device *radio = video_drvdata(file);
189
190 if (v->index > 0)
191 return -EINVAL;
192
193 dsbr100_getstat(radio);
194 strcpy(v->name, "FM");
195 v->type = V4L2_TUNER_RADIO;
196 v->rangelow = FREQ_MIN * FREQ_MUL;
197 v->rangehigh = FREQ_MAX * FREQ_MUL;
198 v->rxsubchans = radio->stereo ? V4L2_TUNER_SUB_STEREO :
199 V4L2_TUNER_SUB_MONO;
200 v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
201 v->audmode = V4L2_TUNER_MODE_STEREO;
202 v->signal = radio->stereo ? 0xffff : 0;
203 return 0;
204}
205
206static int vidioc_s_tuner(struct file *file, void *priv,
207 const struct v4l2_tuner *v)
208{
209 return v->index ? -EINVAL : 0;
210}
211
212static int vidioc_s_frequency(struct file *file, void *priv,
213 const struct v4l2_frequency *f)
214{
215 struct dsbr100_device *radio = video_drvdata(file);
216
217 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
218 return -EINVAL;
219
220 return dsbr100_setfreq(radio, clamp_t(unsigned, f->frequency,
221 FREQ_MIN * FREQ_MUL, FREQ_MAX * FREQ_MUL));
222}
223
224static int vidioc_g_frequency(struct file *file, void *priv,
225 struct v4l2_frequency *f)
226{
227 struct dsbr100_device *radio = video_drvdata(file);
228
229 if (f->tuner)
230 return -EINVAL;
231 f->type = V4L2_TUNER_RADIO;
232 f->frequency = radio->curfreq;
233 return 0;
234}
235
236static int usb_dsbr100_s_ctrl(struct v4l2_ctrl *ctrl)
237{
238 struct dsbr100_device *radio =
239 container_of(ctrl->handler, struct dsbr100_device, hdl);
240
241 switch (ctrl->id) {
242 case V4L2_CID_AUDIO_MUTE:
243 radio->muted = ctrl->val;
244 return radio->muted ? dsbr100_stop(radio) : dsbr100_start(radio);
245 }
246 return -EINVAL;
247}
248
249
250
251
252
253
254
255
256
257
258static void usb_dsbr100_disconnect(struct usb_interface *intf)
259{
260 struct dsbr100_device *radio = usb_get_intfdata(intf);
261
262 mutex_lock(&radio->v4l2_lock);
263
264
265
266
267
268 usb_control_msg(radio->usbdev,
269 usb_rcvctrlpipe(radio->usbdev, 0),
270 DSB100_ONOFF,
271 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
272 0x00, 0x00, radio->transfer_buffer, 8, 300);
273 usb_set_intfdata(intf, NULL);
274 video_unregister_device(&radio->videodev);
275 v4l2_device_disconnect(&radio->v4l2_dev);
276 mutex_unlock(&radio->v4l2_lock);
277 v4l2_device_put(&radio->v4l2_dev);
278}
279
280
281
282static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message)
283{
284 struct dsbr100_device *radio = usb_get_intfdata(intf);
285
286 mutex_lock(&radio->v4l2_lock);
287 if (!radio->muted && dsbr100_stop(radio) < 0)
288 dev_warn(&intf->dev, "dsbr100_stop failed\n");
289 mutex_unlock(&radio->v4l2_lock);
290
291 dev_info(&intf->dev, "going into suspend..\n");
292 return 0;
293}
294
295
296static int usb_dsbr100_resume(struct usb_interface *intf)
297{
298 struct dsbr100_device *radio = usb_get_intfdata(intf);
299
300 mutex_lock(&radio->v4l2_lock);
301 if (!radio->muted && dsbr100_start(radio) < 0)
302 dev_warn(&intf->dev, "dsbr100_start failed\n");
303 mutex_unlock(&radio->v4l2_lock);
304
305 dev_info(&intf->dev, "coming out of suspend..\n");
306 return 0;
307}
308
309
310static void usb_dsbr100_release(struct v4l2_device *v4l2_dev)
311{
312 struct dsbr100_device *radio = v4l2_dev_to_radio(v4l2_dev);
313
314 v4l2_ctrl_handler_free(&radio->hdl);
315 v4l2_device_unregister(&radio->v4l2_dev);
316 kfree(radio->transfer_buffer);
317 kfree(radio);
318}
319
320static const struct v4l2_ctrl_ops usb_dsbr100_ctrl_ops = {
321 .s_ctrl = usb_dsbr100_s_ctrl,
322};
323
324
325static const struct v4l2_file_operations usb_dsbr100_fops = {
326 .owner = THIS_MODULE,
327 .unlocked_ioctl = video_ioctl2,
328 .open = v4l2_fh_open,
329 .release = v4l2_fh_release,
330 .poll = v4l2_ctrl_poll,
331};
332
333static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = {
334 .vidioc_querycap = vidioc_querycap,
335 .vidioc_g_tuner = vidioc_g_tuner,
336 .vidioc_s_tuner = vidioc_s_tuner,
337 .vidioc_g_frequency = vidioc_g_frequency,
338 .vidioc_s_frequency = vidioc_s_frequency,
339 .vidioc_log_status = v4l2_ctrl_log_status,
340 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
341 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
342};
343
344
345static int usb_dsbr100_probe(struct usb_interface *intf,
346 const struct usb_device_id *id)
347{
348 struct dsbr100_device *radio;
349 struct v4l2_device *v4l2_dev;
350 int retval;
351
352 radio = kzalloc(sizeof(struct dsbr100_device), GFP_KERNEL);
353
354 if (!radio)
355 return -ENOMEM;
356
357 radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL);
358
359 if (!(radio->transfer_buffer)) {
360 kfree(radio);
361 return -ENOMEM;
362 }
363
364 v4l2_dev = &radio->v4l2_dev;
365 v4l2_dev->release = usb_dsbr100_release;
366
367 retval = v4l2_device_register(&intf->dev, v4l2_dev);
368 if (retval < 0) {
369 v4l2_err(v4l2_dev, "couldn't register v4l2_device\n");
370 goto err_reg_dev;
371 }
372
373 v4l2_ctrl_handler_init(&radio->hdl, 1);
374 v4l2_ctrl_new_std(&radio->hdl, &usb_dsbr100_ctrl_ops,
375 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
376 if (radio->hdl.error) {
377 retval = radio->hdl.error;
378 v4l2_err(v4l2_dev, "couldn't register control\n");
379 goto err_reg_ctrl;
380 }
381 mutex_init(&radio->v4l2_lock);
382 strlcpy(radio->videodev.name, v4l2_dev->name, sizeof(radio->videodev.name));
383 radio->videodev.v4l2_dev = v4l2_dev;
384 radio->videodev.fops = &usb_dsbr100_fops;
385 radio->videodev.ioctl_ops = &usb_dsbr100_ioctl_ops;
386 radio->videodev.release = video_device_release_empty;
387 radio->videodev.lock = &radio->v4l2_lock;
388 radio->videodev.ctrl_handler = &radio->hdl;
389
390 radio->usbdev = interface_to_usbdev(intf);
391 radio->curfreq = FREQ_MIN * FREQ_MUL;
392 radio->muted = true;
393
394 video_set_drvdata(&radio->videodev, radio);
395 usb_set_intfdata(intf, radio);
396
397 retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
398 if (retval == 0)
399 return 0;
400 v4l2_err(v4l2_dev, "couldn't register video device\n");
401
402err_reg_ctrl:
403 v4l2_ctrl_handler_free(&radio->hdl);
404 v4l2_device_unregister(v4l2_dev);
405err_reg_dev:
406 kfree(radio->transfer_buffer);
407 kfree(radio);
408 return retval;
409}
410
411static const struct usb_device_id usb_dsbr100_device_table[] = {
412 { USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) },
413 { }
414};
415
416MODULE_DEVICE_TABLE(usb, usb_dsbr100_device_table);
417
418
419static struct usb_driver usb_dsbr100_driver = {
420 .name = "dsbr100",
421 .probe = usb_dsbr100_probe,
422 .disconnect = usb_dsbr100_disconnect,
423 .id_table = usb_dsbr100_device_table,
424 .suspend = usb_dsbr100_suspend,
425 .resume = usb_dsbr100_resume,
426 .reset_resume = usb_dsbr100_resume,
427};
428
429module_usb_driver(usb_dsbr100_driver);
430