mfd: mfd_cell is now implicitly available to timberdale drivers
[linux-2.6.git] / drivers / media / radio / radio-miropcm20.c
1 /* Miro PCM20 radio driver for Linux radio support
2  * (c) 1998 Ruurd Reitsma <R.A.Reitsma@wbmt.tudelft.nl>
3  * Thanks to Norberto Pellici for the ACI device interface specification
4  * The API part is based on the radiotrack driver by M. Kirkwood
5  * This driver relies on the aci mixer provided by the snd-miro
6  * ALSA driver.
7  * Look there for further info...
8  */
9
10 /* What ever you think about the ACI, version 0x07 is not very well!
11  * I can't get frequency, 'tuner status', 'tuner flags' or mute/mono
12  * conditions...                Robert
13  */
14
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/videodev2.h>
18 #include <media/v4l2-device.h>
19 #include <media/v4l2-ioctl.h>
20 #include <sound/aci.h>
21
22 static int radio_nr = -1;
23 module_param(radio_nr, int, 0);
24 MODULE_PARM_DESC(radio_nr, "Set radio device number (/dev/radioX).  Default: -1 (autodetect)");
25
26 static int mono;
27 module_param(mono, bool, 0);
28 MODULE_PARM_DESC(mono, "Force tuner into mono mode.");
29
30 struct pcm20 {
31         struct v4l2_device v4l2_dev;
32         struct video_device vdev;
33         unsigned long freq;
34         int muted;
35         struct snd_miro_aci *aci;
36         struct mutex lock;
37 };
38
39 static struct pcm20 pcm20_card = {
40         .freq   = 87*16000,
41         .muted  = 1,
42 };
43
44 static int pcm20_mute(struct pcm20 *dev, unsigned char mute)
45 {
46         dev->muted = mute;
47         return snd_aci_cmd(dev->aci, ACI_SET_TUNERMUTE, mute, -1);
48 }
49
50 static int pcm20_stereo(struct pcm20 *dev, unsigned char stereo)
51 {
52         return snd_aci_cmd(dev->aci, ACI_SET_TUNERMONO, !stereo, -1);
53 }
54
55 static int pcm20_setfreq(struct pcm20 *dev, unsigned long freq)
56 {
57         unsigned char freql;
58         unsigned char freqh;
59         struct snd_miro_aci *aci = dev->aci;
60
61         dev->freq = freq;
62
63         freq /= 160;
64         if (!(aci->aci_version == 0x07 || aci->aci_version >= 0xb0))
65                 freq /= 10;  /* I don't know exactly which version
66                               * needs this hack */
67         freql = freq & 0xff;
68         freqh = freq >> 8;
69
70         pcm20_stereo(dev, !mono);
71         return snd_aci_cmd(aci, ACI_WRITE_TUNE, freql, freqh);
72 }
73
74 static const struct v4l2_file_operations pcm20_fops = {
75         .owner          = THIS_MODULE,
76         .unlocked_ioctl = video_ioctl2,
77 };
78
79 static int vidioc_querycap(struct file *file, void *priv,
80                                 struct v4l2_capability *v)
81 {
82         strlcpy(v->driver, "Miro PCM20", sizeof(v->driver));
83         strlcpy(v->card, "Miro PCM20", sizeof(v->card));
84         strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
85         v->version = 0x1;
86         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
87         return 0;
88 }
89
90 static int vidioc_g_tuner(struct file *file, void *priv,
91                                 struct v4l2_tuner *v)
92 {
93         if (v->index)   /* Only 1 tuner */
94                 return -EINVAL;
95         strlcpy(v->name, "FM", sizeof(v->name));
96         v->type = V4L2_TUNER_RADIO;
97         v->rangelow = 87*16000;
98         v->rangehigh = 108*16000;
99         v->signal = 0xffff;
100         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
101         v->capability = V4L2_TUNER_CAP_LOW;
102         v->audmode = V4L2_TUNER_MODE_MONO;
103         return 0;
104 }
105
106 static int vidioc_s_tuner(struct file *file, void *priv,
107                                 struct v4l2_tuner *v)
108 {
109         return v->index ? -EINVAL : 0;
110 }
111
112 static int vidioc_g_frequency(struct file *file, void *priv,
113                                 struct v4l2_frequency *f)
114 {
115         struct pcm20 *dev = video_drvdata(file);
116
117         if (f->tuner != 0)
118                 return -EINVAL;
119
120         f->type = V4L2_TUNER_RADIO;
121         f->frequency = dev->freq;
122         return 0;
123 }
124
125
126 static int vidioc_s_frequency(struct file *file, void *priv,
127                                 struct v4l2_frequency *f)
128 {
129         struct pcm20 *dev = video_drvdata(file);
130
131         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
132                 return -EINVAL;
133
134         dev->freq = f->frequency;
135         pcm20_setfreq(dev, f->frequency);
136         return 0;
137 }
138
139 static int vidioc_queryctrl(struct file *file, void *priv,
140                                 struct v4l2_queryctrl *qc)
141 {
142         switch (qc->id) {
143         case V4L2_CID_AUDIO_MUTE:
144                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
145         }
146         return -EINVAL;
147 }
148
149 static int vidioc_g_ctrl(struct file *file, void *priv,
150                                 struct v4l2_control *ctrl)
151 {
152         struct pcm20 *dev = video_drvdata(file);
153
154         switch (ctrl->id) {
155         case V4L2_CID_AUDIO_MUTE:
156                 ctrl->value = dev->muted;
157                 break;
158         default:
159                 return -EINVAL;
160         }
161         return 0;
162 }
163
164 static int vidioc_s_ctrl(struct file *file, void *priv,
165                                 struct v4l2_control *ctrl)
166 {
167         struct pcm20 *dev = video_drvdata(file);
168
169         switch (ctrl->id) {
170         case V4L2_CID_AUDIO_MUTE:
171                 pcm20_mute(dev, ctrl->value);
172                 break;
173         default:
174                 return -EINVAL;
175         }
176         return 0;
177 }
178
179 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
180 {
181         *i = 0;
182         return 0;
183 }
184
185 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
186 {
187         return i ? -EINVAL : 0;
188 }
189
190 static int vidioc_g_audio(struct file *file, void *priv,
191                                 struct v4l2_audio *a)
192 {
193         a->index = 0;
194         strlcpy(a->name, "Radio", sizeof(a->name));
195         a->capability = V4L2_AUDCAP_STEREO;
196         return 0;
197 }
198
199 static int vidioc_s_audio(struct file *file, void *priv,
200                                 struct v4l2_audio *a)
201 {
202         return a->index ? -EINVAL : 0;
203 }
204
205 static const struct v4l2_ioctl_ops pcm20_ioctl_ops = {
206         .vidioc_querycap    = vidioc_querycap,
207         .vidioc_g_tuner     = vidioc_g_tuner,
208         .vidioc_s_tuner     = vidioc_s_tuner,
209         .vidioc_g_frequency = vidioc_g_frequency,
210         .vidioc_s_frequency = vidioc_s_frequency,
211         .vidioc_queryctrl   = vidioc_queryctrl,
212         .vidioc_g_ctrl      = vidioc_g_ctrl,
213         .vidioc_s_ctrl      = vidioc_s_ctrl,
214         .vidioc_g_audio     = vidioc_g_audio,
215         .vidioc_s_audio     = vidioc_s_audio,
216         .vidioc_g_input     = vidioc_g_input,
217         .vidioc_s_input     = vidioc_s_input,
218 };
219
220 static int __init pcm20_init(void)
221 {
222         struct pcm20 *dev = &pcm20_card;
223         struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
224         int res;
225
226         dev->aci = snd_aci_get_aci();
227         if (dev->aci == NULL) {
228                 v4l2_err(v4l2_dev,
229                          "you must load the snd-miro driver first!\n");
230                 return -ENODEV;
231         }
232         strlcpy(v4l2_dev->name, "miropcm20", sizeof(v4l2_dev->name));
233         mutex_init(&dev->lock);
234
235         res = v4l2_device_register(NULL, v4l2_dev);
236         if (res < 0) {
237                 v4l2_err(v4l2_dev, "could not register v4l2_device\n");
238                 return -EINVAL;
239         }
240
241         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
242         dev->vdev.v4l2_dev = v4l2_dev;
243         dev->vdev.fops = &pcm20_fops;
244         dev->vdev.ioctl_ops = &pcm20_ioctl_ops;
245         dev->vdev.release = video_device_release_empty;
246         dev->vdev.lock = &dev->lock;
247         video_set_drvdata(&dev->vdev, dev);
248
249         if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0)
250                 goto fail;
251
252         v4l2_info(v4l2_dev, "Mirosound PCM20 Radio tuner\n");
253         return 0;
254 fail:
255         v4l2_device_unregister(v4l2_dev);
256         return -EINVAL;
257 }
258
259 MODULE_AUTHOR("Ruurd Reitsma, Krzysztof Helt");
260 MODULE_DESCRIPTION("A driver for the Miro PCM20 radio card.");
261 MODULE_LICENSE("GPL");
262
263 static void __exit pcm20_cleanup(void)
264 {
265         struct pcm20 *dev = &pcm20_card;
266
267         video_unregister_device(&dev->vdev);
268         v4l2_device_unregister(&dev->v4l2_dev);
269 }
270
271 module_init(pcm20_init);
272 module_exit(pcm20_cleanup);