Merge branch 'iommu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip...
[linux-2.6] / drivers / media / radio / radio-maestro.c
1 /* Maestro PCI sound card radio driver for Linux support
2  * (c) 2000 A. Tlalka, atlka@pg.gda.pl
3  * Notes on the hardware
4  *
5  *  + Frequency control is done digitally
6  *  + No volume control - only mute/unmute - you have to use Aux line volume
7  *  control on Maestro card to set the volume
8  *  + Radio status (tuned/not_tuned and stereo/mono) is valid some time after
9  *  frequency setting (>100ms) and only when the radio is unmuted.
10  *  version 0.02
11  *  + io port is automatically detected - only the first radio is used
12  *  version 0.03
13  *  + thread access locking additions
14  *  version 0.04
15  * + code improvements
16  * + VIDEO_TUNER_LOW is permanent
17  *
18  * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
19  */
20
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/ioport.h>
24 #include <linux/delay.h>
25 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
26 #include <linux/pci.h>
27 #include <linux/videodev2.h>
28 #include <linux/io.h>
29 #include <media/v4l2-device.h>
30 #include <media/v4l2-ioctl.h>
31
32 MODULE_AUTHOR("Adam Tlalka, atlka@pg.gda.pl");
33 MODULE_DESCRIPTION("Radio driver for the Maestro PCI sound card radio.");
34 MODULE_LICENSE("GPL");
35
36 static int radio_nr = -1;
37 module_param(radio_nr, int, 0);
38
39 #define RADIO_VERSION KERNEL_VERSION(0, 0, 6)
40 #define DRIVER_VERSION  "0.06"
41
42 #define GPIO_DATA       0x60   /* port offset from ESS_IO_BASE */
43
44 #define IO_MASK         4      /* mask      register offset from GPIO_DATA
45                                 bits 1=unmask write to given bit */
46 #define IO_DIR          8      /* direction register offset from GPIO_DATA
47                                 bits 0/1=read/write direction */
48
49 #define GPIO6           0x0040 /* mask bits for GPIO lines */
50 #define GPIO7           0x0080
51 #define GPIO8           0x0100
52 #define GPIO9           0x0200
53
54 #define STR_DATA        GPIO6  /* radio TEA5757 pins and GPIO bits */
55 #define STR_CLK         GPIO7
56 #define STR_WREN        GPIO8
57 #define STR_MOST        GPIO9
58
59 #define FREQ_LO          50*16000
60 #define FREQ_HI         150*16000
61
62 #define FREQ_IF         171200 /* 10.7*16000   */
63 #define FREQ_STEP       200    /* 12.5*16      */
64
65 #define FREQ2BITS(x)    ((((unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1))\
66                         /(FREQ_STEP<<2))<<2) /* (x==fmhz*16*1000) -> bits */
67
68 #define BITS2FREQ(x)    ((x) * FREQ_STEP - FREQ_IF)
69
70 struct maestro {
71         struct v4l2_device v4l2_dev;
72         struct video_device vdev;
73         struct pci_dev *pdev;
74         struct mutex lock;
75
76         u16     io;     /* base of Maestro card radio io (GPIO_DATA)*/
77         u16     muted;  /* VIDEO_AUDIO_MUTE */
78         u16     stereo; /* VIDEO_TUNER_STEREO_ON */
79         u16     tuned;  /* signal strength (0 or 0xffff) */
80 };
81
82 static inline struct maestro *to_maestro(struct v4l2_device *v4l2_dev)
83 {
84         return container_of(v4l2_dev, struct maestro, v4l2_dev);
85 }
86
87 static u32 radio_bits_get(struct maestro *dev)
88 {
89         u16 io = dev->io, l, rdata;
90         u32 data = 0;
91         u16 omask;
92
93         omask = inw(io + IO_MASK);
94         outw(~(STR_CLK | STR_WREN), io + IO_MASK);
95         outw(0, io);
96         udelay(16);
97
98         for (l = 24; l--;) {
99                 outw(STR_CLK, io);              /* HI state */
100                 udelay(2);
101                 if (!l)
102                         dev->tuned = inw(io) & STR_MOST ? 0 : 0xffff;
103                 outw(0, io);                    /* LO state */
104                 udelay(2);
105                 data <<= 1;                     /* shift data */
106                 rdata = inw(io);
107                 if (!l)
108                         dev->stereo = (rdata & STR_MOST) ?  0 : 1;
109                 else if (rdata & STR_DATA)
110                         data++;
111                 udelay(2);
112         }
113
114         if (dev->muted)
115                 outw(STR_WREN, io);
116
117         udelay(4);
118         outw(omask, io + IO_MASK);
119
120         return data & 0x3ffe;
121 }
122
123 static void radio_bits_set(struct maestro *dev, u32 data)
124 {
125         u16 io = dev->io, l, bits;
126         u16 omask, odir;
127
128         omask = inw(io + IO_MASK);
129         odir = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
130         outw(odir | STR_DATA, io + IO_DIR);
131         outw(~(STR_DATA | STR_CLK | STR_WREN), io + IO_MASK);
132         udelay(16);
133         for (l = 25; l; l--) {
134                 bits = ((data >> 18) & STR_DATA) | STR_WREN;
135                 data <<= 1;                     /* shift data */
136                 outw(bits, io);                 /* start strobe */
137                 udelay(2);
138                 outw(bits | STR_CLK, io);       /* HI level */
139                 udelay(2);
140                 outw(bits, io);                 /* LO level */
141                 udelay(4);
142         }
143
144         if (!dev->muted)
145                 outw(0, io);
146
147         udelay(4);
148         outw(omask, io + IO_MASK);
149         outw(odir, io + IO_DIR);
150         msleep(125);
151 }
152
153 static int vidioc_querycap(struct file *file, void  *priv,
154                                         struct v4l2_capability *v)
155 {
156         struct maestro *dev = video_drvdata(file);
157
158         strlcpy(v->driver, "radio-maestro", sizeof(v->driver));
159         strlcpy(v->card, "Maestro Radio", sizeof(v->card));
160         snprintf(v->bus_info, sizeof(v->bus_info), "PCI:%s", pci_name(dev->pdev));
161         v->version = RADIO_VERSION;
162         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
163         return 0;
164 }
165
166 static int vidioc_g_tuner(struct file *file, void *priv,
167                                         struct v4l2_tuner *v)
168 {
169         struct maestro *dev = video_drvdata(file);
170
171         if (v->index > 0)
172                 return -EINVAL;
173
174         mutex_lock(&dev->lock);
175         radio_bits_get(dev);
176
177         strlcpy(v->name, "FM", sizeof(v->name));
178         v->type = V4L2_TUNER_RADIO;
179         v->rangelow = FREQ_LO;
180         v->rangehigh = FREQ_HI;
181         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
182         v->capability = V4L2_TUNER_CAP_LOW;
183         if (dev->stereo)
184                 v->audmode = V4L2_TUNER_MODE_STEREO;
185         else
186                 v->audmode = V4L2_TUNER_MODE_MONO;
187         v->signal = dev->tuned;
188         mutex_unlock(&dev->lock);
189         return 0;
190 }
191
192 static int vidioc_s_tuner(struct file *file, void *priv,
193                                         struct v4l2_tuner *v)
194 {
195         return v->index ? -EINVAL : 0;
196 }
197
198 static int vidioc_s_frequency(struct file *file, void *priv,
199                                         struct v4l2_frequency *f)
200 {
201         struct maestro *dev = video_drvdata(file);
202
203         if (f->frequency < FREQ_LO || f->frequency > FREQ_HI)
204                 return -EINVAL;
205         mutex_lock(&dev->lock);
206         radio_bits_set(dev, FREQ2BITS(f->frequency));
207         mutex_unlock(&dev->lock);
208         return 0;
209 }
210
211 static int vidioc_g_frequency(struct file *file, void *priv,
212                                         struct v4l2_frequency *f)
213 {
214         struct maestro *dev = video_drvdata(file);
215
216         f->type = V4L2_TUNER_RADIO;
217         mutex_lock(&dev->lock);
218         f->frequency = BITS2FREQ(radio_bits_get(dev));
219         mutex_unlock(&dev->lock);
220         return 0;
221 }
222
223 static int vidioc_queryctrl(struct file *file, void *priv,
224                                         struct v4l2_queryctrl *qc)
225 {
226         switch (qc->id) {
227         case V4L2_CID_AUDIO_MUTE:
228                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
229         }
230         return -EINVAL;
231 }
232
233 static int vidioc_g_ctrl(struct file *file, void *priv,
234                                         struct v4l2_control *ctrl)
235 {
236         struct maestro *dev = video_drvdata(file);
237
238         switch (ctrl->id) {
239         case V4L2_CID_AUDIO_MUTE:
240                 ctrl->value = dev->muted;
241                 return 0;
242         }
243         return -EINVAL;
244 }
245
246 static int vidioc_s_ctrl(struct file *file, void *priv,
247                                         struct v4l2_control *ctrl)
248 {
249         struct maestro *dev = video_drvdata(file);
250         u16 io = dev->io;
251         u16 omask;
252
253         switch (ctrl->id) {
254         case V4L2_CID_AUDIO_MUTE:
255                 mutex_lock(&dev->lock);
256                 omask = inw(io + IO_MASK);
257                 outw(~STR_WREN, io + IO_MASK);
258                 dev->muted = ctrl->value;
259                 outw(dev->muted ? STR_WREN : 0, io);
260                 udelay(4);
261                 outw(omask, io + IO_MASK);
262                 msleep(125);
263                 mutex_unlock(&dev->lock);
264                 return 0;
265         }
266         return -EINVAL;
267 }
268
269 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
270 {
271         *i = 0;
272         return 0;
273 }
274
275 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
276 {
277         return i ? -EINVAL : 0;
278 }
279
280 static int vidioc_g_audio(struct file *file, void *priv,
281                                         struct v4l2_audio *a)
282 {
283         a->index = 0;
284         strlcpy(a->name, "Radio", sizeof(a->name));
285         a->capability = V4L2_AUDCAP_STEREO;
286         return 0;
287 }
288
289 static int vidioc_s_audio(struct file *file, void *priv,
290                                         struct v4l2_audio *a)
291 {
292         return a->index ? -EINVAL : 0;
293 }
294
295 static int maestro_open(struct file *file)
296 {
297         return 0;
298 }
299
300 static int maestro_release(struct file *file)
301 {
302         return 0;
303 }
304
305 static const struct v4l2_file_operations maestro_fops = {
306         .owner          = THIS_MODULE,
307         .open           = maestro_open,
308         .release        = maestro_release,
309         .ioctl          = video_ioctl2,
310 };
311
312 static const struct v4l2_ioctl_ops maestro_ioctl_ops = {
313         .vidioc_querycap    = vidioc_querycap,
314         .vidioc_g_tuner     = vidioc_g_tuner,
315         .vidioc_s_tuner     = vidioc_s_tuner,
316         .vidioc_g_audio     = vidioc_g_audio,
317         .vidioc_s_audio     = vidioc_s_audio,
318         .vidioc_g_input     = vidioc_g_input,
319         .vidioc_s_input     = vidioc_s_input,
320         .vidioc_g_frequency = vidioc_g_frequency,
321         .vidioc_s_frequency = vidioc_s_frequency,
322         .vidioc_queryctrl   = vidioc_queryctrl,
323         .vidioc_g_ctrl      = vidioc_g_ctrl,
324         .vidioc_s_ctrl      = vidioc_s_ctrl,
325 };
326
327 static u16 __devinit radio_power_on(struct maestro *dev)
328 {
329         register u16 io = dev->io;
330         register u32 ofreq;
331         u16 omask, odir;
332
333         omask = inw(io + IO_MASK);
334         odir = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
335         outw(odir & ~STR_WREN, io + IO_DIR);
336         dev->muted = inw(io) & STR_WREN ? 0 : 1;
337         outw(odir, io + IO_DIR);
338         outw(~(STR_WREN | STR_CLK), io + IO_MASK);
339         outw(dev->muted ? 0 : STR_WREN, io);
340         udelay(16);
341         outw(omask, io + IO_MASK);
342         ofreq = radio_bits_get(dev);
343
344         if ((ofreq < FREQ2BITS(FREQ_LO)) || (ofreq > FREQ2BITS(FREQ_HI)))
345                 ofreq = FREQ2BITS(FREQ_LO);
346         radio_bits_set(dev, ofreq);
347
348         return (ofreq == radio_bits_get(dev));
349 }
350
351 static int __devinit maestro_probe(struct pci_dev *pdev,
352         const struct pci_device_id *ent)
353 {
354         struct maestro *dev;
355         struct v4l2_device *v4l2_dev;
356         int retval;
357
358         retval = pci_enable_device(pdev);
359         if (retval) {
360                 dev_err(&pdev->dev, "enabling pci device failed!\n");
361                 goto err;
362         }
363
364         retval = -ENOMEM;
365
366         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
367         if (dev == NULL) {
368                 dev_err(&pdev->dev, "not enough memory\n");
369                 goto err;
370         }
371
372         v4l2_dev = &dev->v4l2_dev;
373         mutex_init(&dev->lock);
374         dev->pdev = pdev;
375
376         strlcpy(v4l2_dev->name, "maestro", sizeof(v4l2_dev->name));
377
378         retval = v4l2_device_register(&pdev->dev, v4l2_dev);
379         if (retval < 0) {
380                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
381                 goto errfr;
382         }
383
384         dev->io = pci_resource_start(pdev, 0) + GPIO_DATA;
385
386         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
387         dev->vdev.v4l2_dev = v4l2_dev;
388         dev->vdev.fops = &maestro_fops;
389         dev->vdev.ioctl_ops = &maestro_ioctl_ops;
390         dev->vdev.release = video_device_release_empty;
391         video_set_drvdata(&dev->vdev, dev);
392
393         retval = video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr);
394         if (retval) {
395                 v4l2_err(v4l2_dev, "can't register video device!\n");
396                 goto errfr1;
397         }
398
399         if (!radio_power_on(dev)) {
400                 retval = -EIO;
401                 goto errunr;
402         }
403
404         v4l2_info(v4l2_dev, "version " DRIVER_VERSION "\n");
405
406         return 0;
407 errunr:
408         video_unregister_device(&dev->vdev);
409 errfr1:
410         v4l2_device_unregister(v4l2_dev);
411 errfr:
412         kfree(dev);
413 err:
414         return retval;
415
416 }
417
418 static void __devexit maestro_remove(struct pci_dev *pdev)
419 {
420         struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
421         struct maestro *dev = to_maestro(v4l2_dev);
422
423         video_unregister_device(&dev->vdev);
424         v4l2_device_unregister(&dev->v4l2_dev);
425 }
426
427 static struct pci_device_id maestro_r_pci_tbl[] = {
428         { PCI_DEVICE(PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ESS1968),
429                 .class = PCI_CLASS_MULTIMEDIA_AUDIO << 8,
430                 .class_mask = 0xffff00 },
431         { PCI_DEVICE(PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ESS1978),
432                 .class = PCI_CLASS_MULTIMEDIA_AUDIO << 8,
433                 .class_mask = 0xffff00 },
434         { 0 }
435 };
436 MODULE_DEVICE_TABLE(pci, maestro_r_pci_tbl);
437
438 static struct pci_driver maestro_r_driver = {
439         .name           = "maestro_radio",
440         .id_table       = maestro_r_pci_tbl,
441         .probe          = maestro_probe,
442         .remove         = __devexit_p(maestro_remove),
443 };
444
445 static int __init maestro_radio_init(void)
446 {
447         int retval = pci_register_driver(&maestro_r_driver);
448
449         if (retval)
450                 printk(KERN_ERR "error during registration pci driver\n");
451
452         return retval;
453 }
454
455 static void __exit maestro_radio_exit(void)
456 {
457         pci_unregister_driver(&maestro_r_driver);
458 }
459
460 module_init(maestro_radio_init);
461 module_exit(maestro_radio_exit);