Commit | Line | Data |
---|---|---|
fc55bcb0 | 1 | /* A driver for the D-Link DSB-R100 USB radio and Gemtek USB Radio 21. |
5d778648 HV |
2 | * The device plugs into both the USB and an analog audio input, so this thing |
3 | * only deals with initialisation and frequency setting, the | |
4 | * audio data has to be handled by a sound driver. | |
5 | * | |
6 | * Major issue: I can't find out where the device reports the signal | |
7 | * strength, and indeed the windows software appearantly just looks | |
8 | * at the stereo indicator as well. So, scanning will only find | |
9 | * stereo stations. Sad, but I can't help it. | |
10 | * | |
11 | * Also, the windows program sends oodles of messages over to the | |
12 | * device, and I couldn't figure out their meaning. My suspicion | |
13 | * is that they don't have any:-) | |
14 | * | |
15 | * You might find some interesting stuff about this module at | |
16 | * http://unimut.fsk.uni-heidelberg.de/unimut/demi/dsbr | |
17 | * | |
18 | * Fully tested with the Keene USB FM Transmitter and the v4l2-compliance tool. | |
19 | * | |
20 | * Copyright (c) 2000 Markus Demleitner <msdemlei@cl.uni-heidelberg.de> | |
21 | * | |
22 | * This program is free software; you can redistribute it and/or modify | |
23 | * it under the terms of the GNU General Public License as published by | |
24 | * the Free Software Foundation; either version 2 of the License, or | |
25 | * (at your option) any later version. | |
26 | * | |
27 | * This program is distributed in the hope that it will be useful, | |
28 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
29 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
30 | * GNU General Public License for more details. | |
31 | * | |
32 | * You should have received a copy of the GNU General Public License | |
33 | * along with this program; if not, write to the Free Software | |
34 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
1da177e4 LT |
35 | */ |
36 | ||
1da177e4 LT |
37 | #include <linux/kernel.h> |
38 | #include <linux/module.h> | |
39 | #include <linux/init.h> | |
40 | #include <linux/slab.h> | |
41 | #include <linux/input.h> | |
5aff308c | 42 | #include <linux/videodev2.h> |
5d778648 | 43 | #include <linux/usb.h> |
406827cc | 44 | #include <media/v4l2-device.h> |
35ea11ff | 45 | #include <media/v4l2-ioctl.h> |
5d778648 HV |
46 | #include <media/v4l2-ctrls.h> |
47 | #include <media/v4l2-event.h> | |
1da177e4 LT |
48 | |
49 | /* | |
50 | * Version Information | |
51 | */ | |
5d778648 HV |
52 | MODULE_AUTHOR("Markus Demleitner <msdemlei@tucana.harvard.edu>"); |
53 | MODULE_DESCRIPTION("D-Link DSB-R100 USB FM radio driver"); | |
54 | MODULE_LICENSE("GPL"); | |
55 | MODULE_VERSION("1.1.0"); | |
1da177e4 LT |
56 | |
57 | #define DSB100_VENDOR 0x04b4 | |
58 | #define DSB100_PRODUCT 0x1002 | |
59 | ||
60 | /* Commands the device appears to understand */ | |
61 | #define DSB100_TUNE 1 | |
62 | #define DSB100_ONOFF 2 | |
63 | ||
64 | #define TB_LEN 16 | |
65 | ||
66 | /* Frequency limits in MHz -- these are European values. For Japanese | |
67 | devices, that would be 76 and 91. */ | |
68 | #define FREQ_MIN 87.5 | |
69 | #define FREQ_MAX 108.0 | |
70 | #define FREQ_MUL 16000 | |
71 | ||
13099294 | 72 | #define v4l2_dev_to_radio(d) container_of(d, struct dsbr100_device, v4l2_dev) |
1da177e4 | 73 | |
1da177e4 LT |
74 | static int radio_nr = -1; |
75 | module_param(radio_nr, int, 0); | |
76 | ||
77 | /* Data for one (physical) device */ | |
5aff308c | 78 | struct dsbr100_device { |
1da177e4 | 79 | struct usb_device *usbdev; |
3a0efc32 | 80 | struct video_device videodev; |
406827cc | 81 | struct v4l2_device v4l2_dev; |
5d778648 | 82 | struct v4l2_ctrl_handler hdl; |
406827cc | 83 | |
863c86dd | 84 | u8 *transfer_buffer; |
e64d07c9 | 85 | struct mutex v4l2_lock; |
1da177e4 | 86 | int curfreq; |
5d778648 HV |
87 | bool stereo; |
88 | bool muted; | |
1da177e4 LT |
89 | }; |
90 | ||
91 | /* Low-level device interface begins here */ | |
92 | ||
5d778648 HV |
93 | /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */ |
94 | static int dsbr100_setfreq(struct dsbr100_device *radio, unsigned freq) | |
1da177e4 | 95 | { |
5d778648 HV |
96 | unsigned f = (freq / 16 * 80) / 1000 + 856; |
97 | int retval = 0; | |
98 | ||
99 | if (!radio->muted) { | |
100 | retval = usb_control_msg(radio->usbdev, | |
101 | usb_rcvctrlpipe(radio->usbdev, 0), | |
102 | DSB100_TUNE, | |
103 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, | |
104 | (f >> 8) & 0x00ff, f & 0xff, | |
105 | radio->transfer_buffer, 8, 300); | |
106 | if (retval >= 0) | |
107 | mdelay(1); | |
3a0efc32 AK |
108 | } |
109 | ||
5d778648 HV |
110 | if (retval >= 0) { |
111 | radio->curfreq = freq; | |
112 | return 0; | |
417b7953 | 113 | } |
417b7953 AK |
114 | dev_err(&radio->usbdev->dev, |
115 | "%s - usb_control_msg returned %i, request %i\n", | |
5d778648 | 116 | __func__, retval, DSB100_TUNE); |
d25cb646 | 117 | return retval; |
1da177e4 LT |
118 | } |
119 | ||
5d778648 HV |
120 | /* switch on radio */ |
121 | static int dsbr100_start(struct dsbr100_device *radio) | |
1da177e4 | 122 | { |
5d778648 | 123 | int retval = usb_control_msg(radio->usbdev, |
417b7953 AK |
124 | usb_rcvctrlpipe(radio->usbdev, 0), |
125 | DSB100_ONOFF, | |
126 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, | |
5d778648 | 127 | 0x01, 0x00, radio->transfer_buffer, 8, 300); |
417b7953 | 128 | |
5d778648 HV |
129 | if (retval >= 0) |
130 | return dsbr100_setfreq(radio, radio->curfreq); | |
417b7953 AK |
131 | dev_err(&radio->usbdev->dev, |
132 | "%s - usb_control_msg returned %i, request %i\n", | |
5d778648 | 133 | __func__, retval, DSB100_ONOFF); |
d25cb646 | 134 | return retval; |
417b7953 | 135 | |
1da177e4 LT |
136 | } |
137 | ||
5d778648 HV |
138 | /* switch off radio */ |
139 | static int dsbr100_stop(struct dsbr100_device *radio) | |
1da177e4 | 140 | { |
5d778648 | 141 | int retval = usb_control_msg(radio->usbdev, |
417b7953 | 142 | usb_rcvctrlpipe(radio->usbdev, 0), |
5d778648 | 143 | DSB100_ONOFF, |
417b7953 | 144 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, |
5d778648 | 145 | 0x00, 0x00, radio->transfer_buffer, 8, 300); |
417b7953 | 146 | |
5d778648 HV |
147 | if (retval >= 0) |
148 | return 0; | |
417b7953 AK |
149 | dev_err(&radio->usbdev->dev, |
150 | "%s - usb_control_msg returned %i, request %i\n", | |
5d778648 | 151 | __func__, retval, DSB100_ONOFF); |
d25cb646 | 152 | return retval; |
5d778648 | 153 | |
1da177e4 LT |
154 | } |
155 | ||
156 | /* return the device status. This is, in effect, just whether it | |
157 | sees a stereo signal or not. Pity. */ | |
5aff308c | 158 | static void dsbr100_getstat(struct dsbr100_device *radio) |
1da177e4 | 159 | { |
5d778648 | 160 | int retval = usb_control_msg(radio->usbdev, |
417b7953 | 161 | usb_rcvctrlpipe(radio->usbdev, 0), |
d56410e0 | 162 | USB_REQ_GET_STATUS, |
1da177e4 | 163 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, |
5d778648 | 164 | 0x00, 0x24, radio->transfer_buffer, 8, 300); |
417b7953 AK |
165 | |
166 | if (retval < 0) { | |
5d778648 | 167 | radio->stereo = false; |
417b7953 AK |
168 | dev_err(&radio->usbdev->dev, |
169 | "%s - usb_control_msg returned %i, request %i\n", | |
170 | __func__, retval, USB_REQ_GET_STATUS); | |
171 | } else { | |
223377e7 | 172 | radio->stereo = !(radio->transfer_buffer[0] & 0x01); |
417b7953 | 173 | } |
1da177e4 LT |
174 | } |
175 | ||
7002a4f3 DL |
176 | static int vidioc_querycap(struct file *file, void *priv, |
177 | struct v4l2_capability *v) | |
178 | { | |
c7181cfa AK |
179 | struct dsbr100_device *radio = video_drvdata(file); |
180 | ||
7002a4f3 DL |
181 | strlcpy(v->driver, "dsbr100", sizeof(v->driver)); |
182 | strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card)); | |
c7181cfa | 183 | usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info)); |
5d778648 HV |
184 | v->device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER; |
185 | v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS; | |
7002a4f3 DL |
186 | return 0; |
187 | } | |
1da177e4 | 188 | |
7002a4f3 DL |
189 | static int vidioc_g_tuner(struct file *file, void *priv, |
190 | struct v4l2_tuner *v) | |
1da177e4 | 191 | { |
c170ecf4 | 192 | struct dsbr100_device *radio = video_drvdata(file); |
7002a4f3 DL |
193 | |
194 | if (v->index > 0) | |
195 | return -EINVAL; | |
196 | ||
197 | dsbr100_getstat(radio); | |
198 | strcpy(v->name, "FM"); | |
199 | v->type = V4L2_TUNER_RADIO; | |
223377e7 AK |
200 | v->rangelow = FREQ_MIN * FREQ_MUL; |
201 | v->rangehigh = FREQ_MAX * FREQ_MUL; | |
5d778648 HV |
202 | v->rxsubchans = radio->stereo ? V4L2_TUNER_SUB_STEREO : |
203 | V4L2_TUNER_SUB_MONO; | |
204 | v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO; | |
205 | v->audmode = V4L2_TUNER_MODE_STEREO; | |
206 | v->signal = radio->stereo ? 0xffff : 0; /* We can't get the signal strength */ | |
7002a4f3 DL |
207 | return 0; |
208 | } | |
1da177e4 | 209 | |
7002a4f3 | 210 | static int vidioc_s_tuner(struct file *file, void *priv, |
2f73c7c5 | 211 | const struct v4l2_tuner *v) |
7002a4f3 | 212 | { |
13099294 | 213 | return v->index ? -EINVAL : 0; |
7002a4f3 | 214 | } |
5aff308c | 215 | |
7002a4f3 | 216 | static int vidioc_s_frequency(struct file *file, void *priv, |
b530a447 | 217 | const struct v4l2_frequency *f) |
7002a4f3 | 218 | { |
c170ecf4 | 219 | struct dsbr100_device *radio = video_drvdata(file); |
1da177e4 | 220 | |
5d778648 HV |
221 | if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO) |
222 | return -EINVAL; | |
fdf9c997 | 223 | |
5d778648 HV |
224 | return dsbr100_setfreq(radio, clamp_t(unsigned, f->frequency, |
225 | FREQ_MIN * FREQ_MUL, FREQ_MAX * FREQ_MUL)); | |
7002a4f3 | 226 | } |
5aff308c | 227 | |
7002a4f3 DL |
228 | static int vidioc_g_frequency(struct file *file, void *priv, |
229 | struct v4l2_frequency *f) | |
230 | { | |
c170ecf4 | 231 | struct dsbr100_device *radio = video_drvdata(file); |
5aff308c | 232 | |
5d778648 HV |
233 | if (f->tuner) |
234 | return -EINVAL; | |
7002a4f3 DL |
235 | f->type = V4L2_TUNER_RADIO; |
236 | f->frequency = radio->curfreq; | |
237 | return 0; | |
238 | } | |
5aff308c | 239 | |
5d778648 | 240 | static int usb_dsbr100_s_ctrl(struct v4l2_ctrl *ctrl) |
7002a4f3 | 241 | { |
5d778648 HV |
242 | struct dsbr100_device *radio = |
243 | container_of(ctrl->handler, struct dsbr100_device, hdl); | |
1da177e4 | 244 | |
7002a4f3 DL |
245 | switch (ctrl->id) { |
246 | case V4L2_CID_AUDIO_MUTE: | |
5d778648 HV |
247 | radio->muted = ctrl->val; |
248 | return radio->muted ? dsbr100_stop(radio) : dsbr100_start(radio); | |
7002a4f3 DL |
249 | } |
250 | return -EINVAL; | |
251 | } | |
5aff308c | 252 | |
1da177e4 | 253 | |
e64d07c9 HV |
254 | /* USB subsystem interface begins here */ |
255 | ||
256 | /* | |
257 | * Handle unplugging of the device. | |
258 | * We call video_unregister_device in any case. | |
259 | * The last function called in this procedure is | |
260 | * usb_dsbr100_video_device_release | |
261 | */ | |
262 | static void usb_dsbr100_disconnect(struct usb_interface *intf) | |
263 | { | |
264 | struct dsbr100_device *radio = usb_get_intfdata(intf); | |
265 | ||
e64d07c9 | 266 | mutex_lock(&radio->v4l2_lock); |
5d778648 HV |
267 | /* |
268 | * Disconnect is also called on unload, and in that case we need to | |
269 | * mute the device. This call will silently fail if it is called | |
270 | * after a physical disconnect. | |
271 | */ | |
272 | usb_control_msg(radio->usbdev, | |
273 | usb_rcvctrlpipe(radio->usbdev, 0), | |
274 | DSB100_ONOFF, | |
275 | USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, | |
276 | 0x00, 0x00, radio->transfer_buffer, 8, 300); | |
13099294 | 277 | usb_set_intfdata(intf, NULL); |
e64d07c9 HV |
278 | video_unregister_device(&radio->videodev); |
279 | v4l2_device_disconnect(&radio->v4l2_dev); | |
13099294 HV |
280 | mutex_unlock(&radio->v4l2_lock); |
281 | v4l2_device_put(&radio->v4l2_dev); | |
e64d07c9 HV |
282 | } |
283 | ||
284 | ||
04e0ffbb AK |
285 | /* Suspend device - stop device. */ |
286 | static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message) | |
287 | { | |
288 | struct dsbr100_device *radio = usb_get_intfdata(intf); | |
04e0ffbb | 289 | |
e64d07c9 | 290 | mutex_lock(&radio->v4l2_lock); |
5d778648 HV |
291 | if (!radio->muted && dsbr100_stop(radio) < 0) |
292 | dev_warn(&intf->dev, "dsbr100_stop failed\n"); | |
e64d07c9 | 293 | mutex_unlock(&radio->v4l2_lock); |
04e0ffbb AK |
294 | |
295 | dev_info(&intf->dev, "going into suspend..\n"); | |
04e0ffbb AK |
296 | return 0; |
297 | } | |
298 | ||
299 | /* Resume device - start device. */ | |
300 | static int usb_dsbr100_resume(struct usb_interface *intf) | |
301 | { | |
302 | struct dsbr100_device *radio = usb_get_intfdata(intf); | |
04e0ffbb | 303 | |
e64d07c9 | 304 | mutex_lock(&radio->v4l2_lock); |
5d778648 HV |
305 | if (!radio->muted && dsbr100_start(radio) < 0) |
306 | dev_warn(&intf->dev, "dsbr100_start failed\n"); | |
e64d07c9 | 307 | mutex_unlock(&radio->v4l2_lock); |
04e0ffbb AK |
308 | |
309 | dev_info(&intf->dev, "coming out of suspend..\n"); | |
04e0ffbb AK |
310 | return 0; |
311 | } | |
312 | ||
fc55bcb0 | 313 | /* free data structures */ |
13099294 | 314 | static void usb_dsbr100_release(struct v4l2_device *v4l2_dev) |
3a0efc32 | 315 | { |
13099294 | 316 | struct dsbr100_device *radio = v4l2_dev_to_radio(v4l2_dev); |
3a0efc32 | 317 | |
5d778648 | 318 | v4l2_ctrl_handler_free(&radio->hdl); |
406827cc | 319 | v4l2_device_unregister(&radio->v4l2_dev); |
3a0efc32 AK |
320 | kfree(radio->transfer_buffer); |
321 | kfree(radio); | |
322 | } | |
323 | ||
5d778648 HV |
324 | static const struct v4l2_ctrl_ops usb_dsbr100_ctrl_ops = { |
325 | .s_ctrl = usb_dsbr100_s_ctrl, | |
326 | }; | |
327 | ||
7002a4f3 | 328 | /* File system interface */ |
bec43661 | 329 | static const struct v4l2_file_operations usb_dsbr100_fops = { |
7002a4f3 | 330 | .owner = THIS_MODULE, |
e64d07c9 | 331 | .unlocked_ioctl = video_ioctl2, |
5d778648 HV |
332 | .open = v4l2_fh_open, |
333 | .release = v4l2_fh_release, | |
334 | .poll = v4l2_ctrl_poll, | |
7002a4f3 DL |
335 | }; |
336 | ||
a399810c | 337 | static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = { |
7002a4f3 DL |
338 | .vidioc_querycap = vidioc_querycap, |
339 | .vidioc_g_tuner = vidioc_g_tuner, | |
340 | .vidioc_s_tuner = vidioc_s_tuner, | |
341 | .vidioc_g_frequency = vidioc_g_frequency, | |
342 | .vidioc_s_frequency = vidioc_s_frequency, | |
5d778648 HV |
343 | .vidioc_log_status = v4l2_ctrl_log_status, |
344 | .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, | |
345 | .vidioc_unsubscribe_event = v4l2_event_unsubscribe, | |
7002a4f3 DL |
346 | }; |
347 | ||
fc55bcb0 | 348 | /* check if the device is present and register with v4l and usb if it is */ |
7002a4f3 DL |
349 | static int usb_dsbr100_probe(struct usb_interface *intf, |
350 | const struct usb_device_id *id) | |
351 | { | |
352 | struct dsbr100_device *radio; | |
406827cc | 353 | struct v4l2_device *v4l2_dev; |
417b7953 | 354 | int retval; |
7002a4f3 | 355 | |
406827cc | 356 | radio = kzalloc(sizeof(struct dsbr100_device), GFP_KERNEL); |
223377e7 AK |
357 | |
358 | if (!radio) | |
7002a4f3 | 359 | return -ENOMEM; |
223377e7 AK |
360 | |
361 | radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL); | |
362 | ||
363 | if (!(radio->transfer_buffer)) { | |
863c86dd ON |
364 | kfree(radio); |
365 | return -ENOMEM; | |
366 | } | |
223377e7 | 367 | |
406827cc | 368 | v4l2_dev = &radio->v4l2_dev; |
13099294 | 369 | v4l2_dev->release = usb_dsbr100_release; |
406827cc AK |
370 | |
371 | retval = v4l2_device_register(&intf->dev, v4l2_dev); | |
372 | if (retval < 0) { | |
373 | v4l2_err(v4l2_dev, "couldn't register v4l2_device\n"); | |
5d778648 | 374 | goto err_reg_dev; |
406827cc AK |
375 | } |
376 | ||
5d778648 HV |
377 | v4l2_ctrl_handler_init(&radio->hdl, 1); |
378 | v4l2_ctrl_new_std(&radio->hdl, &usb_dsbr100_ctrl_ops, | |
379 | V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); | |
380 | if (radio->hdl.error) { | |
381 | retval = radio->hdl.error; | |
382 | v4l2_err(v4l2_dev, "couldn't register control\n"); | |
383 | goto err_reg_ctrl; | |
384 | } | |
e64d07c9 | 385 | mutex_init(&radio->v4l2_lock); |
406827cc AK |
386 | strlcpy(radio->videodev.name, v4l2_dev->name, sizeof(radio->videodev.name)); |
387 | radio->videodev.v4l2_dev = v4l2_dev; | |
388 | radio->videodev.fops = &usb_dsbr100_fops; | |
389 | radio->videodev.ioctl_ops = &usb_dsbr100_ioctl_ops; | |
13099294 | 390 | radio->videodev.release = video_device_release_empty; |
e64d07c9 | 391 | radio->videodev.lock = &radio->v4l2_lock; |
5d778648 | 392 | radio->videodev.ctrl_handler = &radio->hdl; |
3a0efc32 | 393 | |
7002a4f3 | 394 | radio->usbdev = interface_to_usbdev(intf); |
223377e7 | 395 | radio->curfreq = FREQ_MIN * FREQ_MUL; |
5d778648 | 396 | radio->muted = true; |
406827cc | 397 | |
3a0efc32 | 398 | video_set_drvdata(&radio->videodev, radio); |
5d778648 | 399 | usb_set_intfdata(intf, radio); |
406827cc | 400 | |
417b7953 | 401 | retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr); |
5d778648 HV |
402 | if (retval == 0) |
403 | return 0; | |
404 | v4l2_err(v4l2_dev, "couldn't register video device\n"); | |
405 | ||
406 | err_reg_ctrl: | |
407 | v4l2_ctrl_handler_free(&radio->hdl); | |
408 | v4l2_device_unregister(v4l2_dev); | |
409 | err_reg_dev: | |
410 | kfree(radio->transfer_buffer); | |
411 | kfree(radio); | |
412 | return retval; | |
7002a4f3 DL |
413 | } |
414 | ||
5d778648 HV |
415 | static struct usb_device_id usb_dsbr100_device_table[] = { |
416 | { USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) }, | |
417 | { } /* Terminating entry */ | |
418 | }; | |
1da177e4 | 419 | |
5d778648 HV |
420 | MODULE_DEVICE_TABLE(usb, usb_dsbr100_device_table); |
421 | ||
422 | /* USB subsystem interface */ | |
423 | static struct usb_driver usb_dsbr100_driver = { | |
424 | .name = "dsbr100", | |
425 | .probe = usb_dsbr100_probe, | |
426 | .disconnect = usb_dsbr100_disconnect, | |
427 | .id_table = usb_dsbr100_device_table, | |
428 | .suspend = usb_dsbr100_suspend, | |
429 | .resume = usb_dsbr100_resume, | |
430 | .reset_resume = usb_dsbr100_resume, | |
431 | }; | |
432 | ||
433 | module_usb_driver(usb_dsbr100_driver); |