Merge branch 'master' of ssh://master.kernel.org/pub/scm/linux/kernel/git/mchehab...
[linux-2.6] / drivers / media / radio / dsbr100.c
1 /* A driver for the D-Link DSB-R100 USB radio.  The R100 plugs
2  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  Copyright (c) 2000 Markus Demleitner <msdemlei@cl.uni-heidelberg.de>
19
20  This program is free software; you can redistribute it and/or modify
21  it under the terms of the GNU General Public License as published by
22  the Free Software Foundation; either version 2 of the License, or
23  (at your option) any later version.
24
25  This program is distributed in the hope that it will be useful,
26  but WITHOUT ANY WARRANTY; without even the implied warranty of
27  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28  GNU General Public License for more details.
29
30  You should have received a copy of the GNU General Public License
31  along with this program; if not, write to the Free Software
32  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33
34  History:
35
36  Version 0.42:
37         Converted dsbr100 to use video_ioctl2
38         by Douglas Landgraf <dougsland@gmail.com>
39
40  Version 0.41-ac1:
41         Alan Cox: Some cleanups and fixes
42
43  Version 0.41:
44         Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
45
46  Version 0.40:
47         Markus: Updates for 2.6.x kernels, code layout changes, name sanitizing
48
49  Version 0.30:
50         Markus: Updates for 2.5.x kernel and more ISO compliant source
51
52  Version 0.25:
53         PSL and Markus: Cleanup, radio now doesn't stop on device close
54
55  Version 0.24:
56         Markus: Hope I got these silly VIDEO_TUNER_LOW issues finally
57         right.  Some minor cleanup, improved standalone compilation
58
59  Version 0.23:
60         Markus: Sign extension bug fixed by declaring transfer_buffer unsigned
61
62  Version 0.22:
63         Markus: Some (brown bag) cleanup in what VIDIOCSTUNER returns,
64         thanks to Mike Cox for pointing the problem out.
65
66  Version 0.21:
67         Markus: Minor cleanup, warnings if something goes wrong, lame attempt
68         to adhere to Documentation/CodingStyle
69
70  Version 0.2:
71         Brad Hards <bradh@dynamite.com.au>: Fixes to make it work as non-module
72         Markus: Copyright clarification
73
74  Version 0.01: Markus: initial release
75
76 */
77
78 #include <linux/kernel.h>
79 #include <linux/module.h>
80 #include <linux/init.h>
81 #include <linux/slab.h>
82 #include <linux/input.h>
83 #include <linux/videodev2.h>
84 #include <media/v4l2-common.h>
85 #include <linux/usb.h>
86
87 /*
88  * Version Information
89  */
90 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
91
92 #define DRIVER_VERSION "v0.41"
93 #define RADIO_VERSION KERNEL_VERSION(0,4,1)
94
95 static struct v4l2_queryctrl radio_qctrl[] = {
96         {
97                 .id            = V4L2_CID_AUDIO_MUTE,
98                 .name          = "Mute",
99                 .minimum       = 0,
100                 .maximum       = 1,
101                 .default_value = 1,
102                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
103         }
104 };
105
106 #define DRIVER_AUTHOR "Markus Demleitner <msdemlei@tucana.harvard.edu>"
107 #define DRIVER_DESC "D-Link DSB-R100 USB FM radio driver"
108
109 #define DSB100_VENDOR 0x04b4
110 #define DSB100_PRODUCT 0x1002
111
112 /* Commands the device appears to understand */
113 #define DSB100_TUNE 1
114 #define DSB100_ONOFF 2
115
116 #define TB_LEN 16
117
118 /* Frequency limits in MHz -- these are European values.  For Japanese
119 devices, that would be 76 and 91.  */
120 #define FREQ_MIN  87.5
121 #define FREQ_MAX 108.0
122 #define FREQ_MUL 16000
123
124
125 static int usb_dsbr100_probe(struct usb_interface *intf,
126                              const struct usb_device_id *id);
127 static void usb_dsbr100_disconnect(struct usb_interface *intf);
128 static int usb_dsbr100_open(struct inode *inode, struct file *file);
129 static int usb_dsbr100_close(struct inode *inode, struct file *file);
130
131 static int radio_nr = -1;
132 module_param(radio_nr, int, 0);
133
134 /* Data for one (physical) device */
135 struct dsbr100_device {
136         struct usb_device *usbdev;
137         struct video_device *videodev;
138         unsigned char transfer_buffer[TB_LEN];
139         int curfreq;
140         int stereo;
141         int users;
142         int removed;
143         int muted;
144 };
145
146
147 static struct usb_device_id usb_dsbr100_device_table [] = {
148         { USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) },
149         { }                                             /* Terminating entry */
150 };
151
152 MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table);
153
154 /* USB subsystem interface */
155 static struct usb_driver usb_dsbr100_driver = {
156         .name =         "dsbr100",
157         .probe =        usb_dsbr100_probe,
158         .disconnect =   usb_dsbr100_disconnect,
159         .id_table =     usb_dsbr100_device_table,
160 };
161
162 /* Low-level device interface begins here */
163
164 /* switch on radio */
165 static int dsbr100_start(struct dsbr100_device *radio)
166 {
167         if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
168                         USB_REQ_GET_STATUS,
169                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
170                         0x00, 0xC7, radio->transfer_buffer, 8, 300)<0 ||
171         usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
172                         DSB100_ONOFF,
173                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
174                         0x01, 0x00, radio->transfer_buffer, 8, 300)<0)
175                 return -1;
176         radio->muted=0;
177         return (radio->transfer_buffer)[0];
178 }
179
180
181 /* switch off radio */
182 static int dsbr100_stop(struct dsbr100_device *radio)
183 {
184         if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
185                         USB_REQ_GET_STATUS,
186                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
187                         0x16, 0x1C, radio->transfer_buffer, 8, 300)<0 ||
188         usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
189                         DSB100_ONOFF,
190                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
191                         0x00, 0x00, radio->transfer_buffer, 8, 300)<0)
192                 return -1;
193         radio->muted=1;
194         return (radio->transfer_buffer)[0];
195 }
196
197 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
198 static int dsbr100_setfreq(struct dsbr100_device *radio, int freq)
199 {
200         freq = (freq/16*80)/1000+856;
201         if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
202                         DSB100_TUNE,
203                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
204                         (freq>>8)&0x00ff, freq&0xff,
205                         radio->transfer_buffer, 8, 300)<0 ||
206            usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
207                         USB_REQ_GET_STATUS,
208                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
209                         0x96, 0xB7, radio->transfer_buffer, 8, 300)<0 ||
210         usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
211                         USB_REQ_GET_STATUS,
212                         USB_TYPE_VENDOR | USB_RECIP_DEVICE |  USB_DIR_IN,
213                         0x00, 0x24, radio->transfer_buffer, 8, 300)<0) {
214                 radio->stereo = -1;
215                 return -1;
216         }
217         radio->stereo = ! ((radio->transfer_buffer)[0]&0x01);
218         return (radio->transfer_buffer)[0];
219 }
220
221 /* return the device status.  This is, in effect, just whether it
222 sees a stereo signal or not.  Pity. */
223 static void dsbr100_getstat(struct dsbr100_device *radio)
224 {
225         if (usb_control_msg(radio->usbdev, usb_rcvctrlpipe(radio->usbdev, 0),
226                 USB_REQ_GET_STATUS,
227                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
228                 0x00 , 0x24, radio->transfer_buffer, 8, 300)<0)
229                 radio->stereo = -1;
230         else
231                 radio->stereo = ! (radio->transfer_buffer[0]&0x01);
232 }
233
234
235 /* USB subsystem interface begins here */
236
237 /* handle unplugging of the device, release data structures
238 if nothing keeps us from doing it.  If something is still
239 keeping us busy, the release callback of v4l will take care
240 of releasing it.  stv680.c does not relase its private
241 data, so I don't do this here either.  Checking out the
242 code I'd expect I better did that, but if there's a memory
243 leak here it's tiny (~50 bytes per disconnect) */
244 static void usb_dsbr100_disconnect(struct usb_interface *intf)
245 {
246         struct dsbr100_device *radio = usb_get_intfdata(intf);
247
248         usb_set_intfdata (intf, NULL);
249         if (radio) {
250                 video_unregister_device(radio->videodev);
251                 radio->videodev = NULL;
252                 if (radio->users) {
253                         kfree(radio);
254                 } else {
255                         radio->removed = 1;
256                 }
257         }
258 }
259
260
261 static int vidioc_querycap(struct file *file, void *priv,
262                                         struct v4l2_capability *v)
263 {
264         strlcpy(v->driver, "dsbr100", sizeof(v->driver));
265         strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card));
266         sprintf(v->bus_info, "ISA");
267         v->version = RADIO_VERSION;
268         v->capabilities = V4L2_CAP_TUNER;
269         return 0;
270 }
271
272 static int vidioc_g_tuner(struct file *file, void *priv,
273                                 struct v4l2_tuner *v)
274 {
275         struct dsbr100_device *radio = video_get_drvdata(video_devdata(file));
276
277         if (v->index > 0)
278                 return -EINVAL;
279
280         dsbr100_getstat(radio);
281         strcpy(v->name, "FM");
282         v->type = V4L2_TUNER_RADIO;
283         v->rangelow = FREQ_MIN*FREQ_MUL;
284         v->rangehigh = FREQ_MAX*FREQ_MUL;
285         v->rxsubchans = V4L2_TUNER_SUB_MONO|V4L2_TUNER_SUB_STEREO;
286         v->capability = V4L2_TUNER_CAP_LOW;
287         if(radio->stereo)
288                 v->audmode = V4L2_TUNER_MODE_STEREO;
289         else
290                 v->audmode = V4L2_TUNER_MODE_MONO;
291         v->signal = 0xffff;     /* We can't get the signal strength */
292         return 0;
293 }
294
295 static int vidioc_s_tuner(struct file *file, void *priv,
296                                 struct v4l2_tuner *v)
297 {
298         if (v->index > 0)
299                 return -EINVAL;
300
301         return 0;
302 }
303
304 static int vidioc_s_frequency(struct file *file, void *priv,
305                                 struct v4l2_frequency *f)
306 {
307         struct dsbr100_device *radio = video_get_drvdata(video_devdata(file));
308
309         radio->curfreq = f->frequency;
310         if (dsbr100_setfreq(radio, radio->curfreq)==-1)
311                 warn("Set frequency failed");
312         return 0;
313 }
314
315 static int vidioc_g_frequency(struct file *file, void *priv,
316                                 struct v4l2_frequency *f)
317 {
318         struct dsbr100_device *radio = video_get_drvdata(video_devdata(file));
319
320         f->type = V4L2_TUNER_RADIO;
321         f->frequency = radio->curfreq;
322         return 0;
323 }
324
325 static int vidioc_queryctrl(struct file *file, void *priv,
326                                 struct v4l2_queryctrl *qc)
327 {
328         int i;
329
330         for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
331                 if (qc->id && qc->id == radio_qctrl[i].id) {
332                         memcpy(qc, &(radio_qctrl[i]),
333                                                 sizeof(*qc));
334                         return 0;
335                 }
336         }
337         return -EINVAL;
338 }
339
340 static int vidioc_g_ctrl(struct file *file, void *priv,
341                                 struct v4l2_control *ctrl)
342 {
343         struct dsbr100_device *radio = video_get_drvdata(video_devdata(file));
344
345         switch (ctrl->id) {
346         case V4L2_CID_AUDIO_MUTE:
347                 ctrl->value = radio->muted;
348                 return 0;
349         }
350         return -EINVAL;
351 }
352
353 static int vidioc_s_ctrl(struct file *file, void *priv,
354                                 struct v4l2_control *ctrl)
355 {
356         struct dsbr100_device *radio = video_get_drvdata(video_devdata(file));
357
358         switch (ctrl->id) {
359         case V4L2_CID_AUDIO_MUTE:
360                 if (ctrl->value) {
361                         if (dsbr100_stop(radio)==-1)
362                                 warn("Radio did not respond properly");
363                 } else {
364                         if (dsbr100_start(radio)==-1)
365                                 warn("Radio did not respond properly");
366                 }
367                 return 0;
368         }
369         return -EINVAL;
370 }
371
372 static int vidioc_g_audio(struct file *file, void *priv,
373                                 struct v4l2_audio *a)
374 {
375         if (a->index > 1)
376                 return -EINVAL;
377
378         strcpy(a->name, "Radio");
379         a->capability = V4L2_AUDCAP_STEREO;
380         return 0;
381 }
382
383 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
384 {
385         *i = 0;
386         return 0;
387 }
388
389 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
390 {
391         if (i != 0)
392                 return -EINVAL;
393         return 0;
394 }
395
396 static int vidioc_s_audio(struct file *file, void *priv,
397                                         struct v4l2_audio *a)
398 {
399         if (a->index != 0)
400                 return -EINVAL;
401         return 0;
402 }
403
404 static int usb_dsbr100_open(struct inode *inode, struct file *file)
405 {
406         struct dsbr100_device *radio=video_get_drvdata(video_devdata(file));
407
408         radio->users = 1;
409         radio->muted = 1;
410
411         if (dsbr100_start(radio)<0) {
412                 warn("Radio did not start up properly");
413                 radio->users = 0;
414                 return -EIO;
415         }
416         dsbr100_setfreq(radio, radio->curfreq);
417         return 0;
418 }
419
420 static int usb_dsbr100_close(struct inode *inode, struct file *file)
421 {
422         struct dsbr100_device *radio=video_get_drvdata(video_devdata(file));
423
424         if (!radio)
425                 return -ENODEV;
426         radio->users = 0;
427         if (radio->removed) {
428                 kfree(radio);
429         }
430         return 0;
431 }
432
433 /* File system interface */
434 static const struct file_operations usb_dsbr100_fops = {
435         .owner          = THIS_MODULE,
436         .open           = usb_dsbr100_open,
437         .release        = usb_dsbr100_close,
438         .ioctl          = video_ioctl2,
439         .compat_ioctl   = v4l_compat_ioctl32,
440         .llseek         = no_llseek,
441 };
442
443 /* V4L2 interface */
444 static struct video_device dsbr100_videodev_template =
445 {
446         .owner          = THIS_MODULE,
447         .name           = "D-Link DSB-R 100",
448         .type           = VID_TYPE_TUNER,
449         .fops           = &usb_dsbr100_fops,
450         .release        = video_device_release,
451         .vidioc_querycap    = vidioc_querycap,
452         .vidioc_g_tuner     = vidioc_g_tuner,
453         .vidioc_s_tuner     = vidioc_s_tuner,
454         .vidioc_g_frequency = vidioc_g_frequency,
455         .vidioc_s_frequency = vidioc_s_frequency,
456         .vidioc_queryctrl   = vidioc_queryctrl,
457         .vidioc_g_ctrl      = vidioc_g_ctrl,
458         .vidioc_s_ctrl      = vidioc_s_ctrl,
459         .vidioc_g_audio     = vidioc_g_audio,
460         .vidioc_s_audio     = vidioc_s_audio,
461         .vidioc_g_input     = vidioc_g_input,
462         .vidioc_s_input     = vidioc_s_input,
463 };
464
465 /* check if the device is present and register with v4l and
466 usb if it is */
467 static int usb_dsbr100_probe(struct usb_interface *intf,
468                                 const struct usb_device_id *id)
469 {
470         struct dsbr100_device *radio;
471
472         if (!(radio = kmalloc(sizeof(struct dsbr100_device), GFP_KERNEL)))
473                 return -ENOMEM;
474         if (!(radio->videodev = video_device_alloc())) {
475                 kfree(radio);
476                 return -ENOMEM;
477         }
478         memcpy(radio->videodev, &dsbr100_videodev_template,
479                 sizeof(dsbr100_videodev_template));
480         radio->removed = 0;
481         radio->users = 0;
482         radio->usbdev = interface_to_usbdev(intf);
483         radio->curfreq = FREQ_MIN*FREQ_MUL;
484         video_set_drvdata(radio->videodev, radio);
485         if (video_register_device(radio->videodev, VFL_TYPE_RADIO,radio_nr)) {
486                 warn("Could not register video device");
487                 video_device_release(radio->videodev);
488                 kfree(radio);
489                 return -EIO;
490         }
491         usb_set_intfdata(intf, radio);
492         return 0;
493 }
494
495 static int __init dsbr100_init(void)
496 {
497         int retval = usb_register(&usb_dsbr100_driver);
498         info(DRIVER_VERSION ":" DRIVER_DESC);
499         return retval;
500 }
501
502 static void __exit dsbr100_exit(void)
503 {
504         usb_deregister(&usb_dsbr100_driver);
505 }
506
507 module_init (dsbr100_init);
508 module_exit (dsbr100_exit);
509
510 MODULE_AUTHOR( DRIVER_AUTHOR );
511 MODULE_DESCRIPTION( DRIVER_DESC );
512 MODULE_LICENSE("GPL");