09265d25725e993c7fed2e64f0d4c2749b104c30
[linux-2.6.git] / drivers / media / radio / radio-gemtek-pci.c
1 /*
2  ***************************************************************************
3  *
4  *     radio-gemtek-pci.c - Gemtek PCI Radio driver
5  *     (C) 2001 Vladimir Shebordaev <vshebordaev@mail.ru>
6  *
7  ***************************************************************************
8  *
9  *     This program is free software; you can redistribute it and/or
10  *     modify it under the terms of the GNU General Public License as
11  *     published by the Free Software Foundation; either version 2 of
12  *     the License, or (at your option) any later version.
13  *
14  *     This program is distributed in the hope that it will be useful,
15  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *     GNU General Public License for more details.
18  *
19  *     You should have received a copy of the GNU General Public
20  *     License along with this program; if not, write to the Free
21  *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
22  *     USA.
23  *
24  ***************************************************************************
25  *
26  *     Gemtek Corp still silently refuses to release any specifications
27  *     of their multimedia devices, so the protocol still has to be
28  *     reverse engineered.
29  *
30  *     The v4l code was inspired by Jonas Munsin's  Gemtek serial line
31  *     radio device driver.
32  *
33  *     Please, let me know if this piece of code was useful :)
34  *
35  *     TODO: multiple device support and portability were not tested
36  *
37  *     Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
38  *
39  ***************************************************************************
40  */
41
42 #include <linux/types.h>
43 #include <linux/list.h>
44 #include <linux/module.h>
45 #include <linux/init.h>
46 #include <linux/pci.h>
47 #include <linux/videodev2.h>
48 #include <linux/errno.h>
49 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
50 #include <linux/io.h>
51 #include <media/v4l2-device.h>
52 #include <media/v4l2-ioctl.h>
53
54 MODULE_AUTHOR("Vladimir Shebordaev <vshebordaev@mail.ru>");
55 MODULE_DESCRIPTION("The video4linux driver for the Gemtek PCI Radio Card");
56 MODULE_LICENSE("GPL");
57
58 static int nr_radio = -1;
59 static int mx = 1;
60
61 module_param(mx, bool, 0);
62 MODULE_PARM_DESC(mx, "single digit: 1 - turn off the turner upon module exit (default), 0 - do not");
63 module_param(nr_radio, int, 0);
64 MODULE_PARM_DESC(nr_radio, "video4linux device number to use");
65
66 #define RADIO_VERSION KERNEL_VERSION(0, 0, 2)
67
68 #ifndef PCI_VENDOR_ID_GEMTEK
69 #define PCI_VENDOR_ID_GEMTEK 0x5046
70 #endif
71
72 #ifndef PCI_DEVICE_ID_GEMTEK_PR103
73 #define PCI_DEVICE_ID_GEMTEK_PR103 0x1001
74 #endif
75
76 #ifndef GEMTEK_PCI_RANGE_LOW
77 #define GEMTEK_PCI_RANGE_LOW (87*16000)
78 #endif
79
80 #ifndef GEMTEK_PCI_RANGE_HIGH
81 #define GEMTEK_PCI_RANGE_HIGH (108*16000)
82 #endif
83
84 struct gemtek_pci {
85         struct v4l2_device v4l2_dev;
86         struct video_device vdev;
87         struct mutex lock;
88         struct pci_dev *pdev;
89
90         u32 iobase;
91         u32 length;
92
93         u32 current_frequency;
94         u8  mute;
95 };
96
97 static inline struct gemtek_pci *to_gemtek_pci(struct v4l2_device *v4l2_dev)
98 {
99         return container_of(v4l2_dev, struct gemtek_pci, v4l2_dev);
100 }
101
102 static inline u8 gemtek_pci_out(u16 value, u32 port)
103 {
104         outw(value, port);
105
106         return (u8)value;
107 }
108
109 #define _b0(v) (*((u8 *)&v))
110
111 static void __gemtek_pci_cmd(u16 value, u32 port, u8 *last_byte, int keep)
112 {
113         u8 byte = *last_byte;
114
115         if (!value) {
116                 if (!keep)
117                         value = (u16)port;
118                 byte &= 0xfd;
119         } else
120                 byte |= 2;
121
122         _b0(value) = byte;
123         outw(value, port);
124         byte |= 1;
125         _b0(value) = byte;
126         outw(value, port);
127         byte &= 0xfe;
128         _b0(value) = byte;
129         outw(value, port);
130
131         *last_byte = byte;
132 }
133
134 static inline void gemtek_pci_nil(u32 port, u8 *last_byte)
135 {
136         __gemtek_pci_cmd(0x00, port, last_byte, false);
137 }
138
139 static inline void gemtek_pci_cmd(u16 cmd, u32 port, u8 *last_byte)
140 {
141         __gemtek_pci_cmd(cmd, port, last_byte, true);
142 }
143
144 static void gemtek_pci_setfrequency(struct gemtek_pci *card, unsigned long frequency)
145 {
146         int i;
147         u32 value = frequency / 200 + 856;
148         u16 mask = 0x8000;
149         u8 last_byte;
150         u32 port = card->iobase;
151
152         mutex_lock(&card->lock);
153         card->current_frequency = frequency;
154         last_byte = gemtek_pci_out(0x06, port);
155
156         i = 0;
157         do {
158                 gemtek_pci_nil(port, &last_byte);
159                 i++;
160         } while (i < 9);
161
162         i = 0;
163         do {
164                 gemtek_pci_cmd(value & mask, port, &last_byte);
165                 mask >>= 1;
166                 i++;
167         } while (i < 16);
168
169         outw(0x10, port);
170         mutex_unlock(&card->lock);
171 }
172
173
174 static void gemtek_pci_mute(struct gemtek_pci *card)
175 {
176         mutex_lock(&card->lock);
177         outb(0x1f, card->iobase);
178         card->mute = true;
179         mutex_unlock(&card->lock);
180 }
181
182 static void gemtek_pci_unmute(struct gemtek_pci *card)
183 {
184         mutex_lock(&card->lock);
185         if (card->mute) {
186                 gemtek_pci_setfrequency(card, card->current_frequency);
187                 card->mute = false;
188         }
189         mutex_unlock(&card->lock);
190 }
191
192 static int gemtek_pci_getsignal(struct gemtek_pci *card)
193 {
194         int sig;
195
196         mutex_lock(&card->lock);
197         sig = (inb(card->iobase) & 0x08) ? 0 : 1;
198         mutex_unlock(&card->lock);
199         return sig;
200 }
201
202 static int vidioc_querycap(struct file *file, void *priv,
203                                         struct v4l2_capability *v)
204 {
205         struct gemtek_pci *card = video_drvdata(file);
206
207         strlcpy(v->driver, "radio-gemtek-pci", sizeof(v->driver));
208         strlcpy(v->card, "GemTek PCI Radio", sizeof(v->card));
209         snprintf(v->bus_info, sizeof(v->bus_info), "PCI:%s", pci_name(card->pdev));
210         v->version = RADIO_VERSION;
211         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
212         return 0;
213 }
214
215 static int vidioc_g_tuner(struct file *file, void *priv,
216                                         struct v4l2_tuner *v)
217 {
218         struct gemtek_pci *card = video_drvdata(file);
219
220         if (v->index > 0)
221                 return -EINVAL;
222
223         strlcpy(v->name, "FM", sizeof(v->name));
224         v->type = V4L2_TUNER_RADIO;
225         v->rangelow = GEMTEK_PCI_RANGE_LOW;
226         v->rangehigh = GEMTEK_PCI_RANGE_HIGH;
227         v->rxsubchans = V4L2_TUNER_SUB_MONO;
228         v->capability = V4L2_TUNER_CAP_LOW;
229         v->audmode = V4L2_TUNER_MODE_MONO;
230         v->signal = 0xffff * gemtek_pci_getsignal(card);
231         return 0;
232 }
233
234 static int vidioc_s_tuner(struct file *file, void *priv,
235                                         struct v4l2_tuner *v)
236 {
237         return v->index ? -EINVAL : 0;
238 }
239
240 static int vidioc_s_frequency(struct file *file, void *priv,
241                                         struct v4l2_frequency *f)
242 {
243         struct gemtek_pci *card = video_drvdata(file);
244
245         if (f->frequency < GEMTEK_PCI_RANGE_LOW ||
246             f->frequency > GEMTEK_PCI_RANGE_HIGH)
247                 return -EINVAL;
248         gemtek_pci_setfrequency(card, f->frequency);
249         card->mute = false;
250         return 0;
251 }
252
253 static int vidioc_g_frequency(struct file *file, void *priv,
254                                         struct v4l2_frequency *f)
255 {
256         struct gemtek_pci *card = video_drvdata(file);
257
258         f->type = V4L2_TUNER_RADIO;
259         f->frequency = card->current_frequency;
260         return 0;
261 }
262
263 static int vidioc_queryctrl(struct file *file, void *priv,
264                                         struct v4l2_queryctrl *qc)
265 {
266         switch (qc->id) {
267         case V4L2_CID_AUDIO_MUTE:
268                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
269         case V4L2_CID_AUDIO_VOLUME:
270                 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535, 65535);
271         }
272         return -EINVAL;
273 }
274
275 static int vidioc_g_ctrl(struct file *file, void *priv,
276                                         struct v4l2_control *ctrl)
277 {
278         struct gemtek_pci *card = video_drvdata(file);
279
280         switch (ctrl->id) {
281         case V4L2_CID_AUDIO_MUTE:
282                 ctrl->value = card->mute;
283                 return 0;
284         case V4L2_CID_AUDIO_VOLUME:
285                 if (card->mute)
286                         ctrl->value = 0;
287                 else
288                         ctrl->value = 65535;
289                 return 0;
290         }
291         return -EINVAL;
292 }
293
294 static int vidioc_s_ctrl(struct file *file, void *priv,
295                                         struct v4l2_control *ctrl)
296 {
297         struct gemtek_pci *card = video_drvdata(file);
298
299         switch (ctrl->id) {
300         case V4L2_CID_AUDIO_MUTE:
301                 if (ctrl->value)
302                         gemtek_pci_mute(card);
303                 else
304                         gemtek_pci_unmute(card);
305                 return 0;
306         case V4L2_CID_AUDIO_VOLUME:
307                 if (ctrl->value)
308                         gemtek_pci_unmute(card);
309                 else
310                         gemtek_pci_mute(card);
311                 return 0;
312         }
313         return -EINVAL;
314 }
315
316 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
317 {
318         *i = 0;
319         return 0;
320 }
321
322 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
323 {
324         return i ? -EINVAL : 0;
325 }
326
327 static int vidioc_g_audio(struct file *file, void *priv,
328                                         struct v4l2_audio *a)
329 {
330         a->index = 0;
331         strlcpy(a->name, "Radio", sizeof(a->name));
332         a->capability = V4L2_AUDCAP_STEREO;
333         return 0;
334 }
335
336 static int vidioc_s_audio(struct file *file, void *priv,
337                                         struct v4l2_audio *a)
338 {
339         return a->index ? -EINVAL : 0;
340 }
341
342 enum {
343         GEMTEK_PR103
344 };
345
346 static char *card_names[] __devinitdata = {
347         "GEMTEK_PR103"
348 };
349
350 static struct pci_device_id gemtek_pci_id[] =
351 {
352         { PCI_VENDOR_ID_GEMTEK, PCI_DEVICE_ID_GEMTEK_PR103,
353           PCI_ANY_ID, PCI_ANY_ID, 0, 0, GEMTEK_PR103 },
354         { 0 }
355 };
356
357 MODULE_DEVICE_TABLE(pci, gemtek_pci_id);
358
359 static int gemtek_pci_open(struct file *file)
360 {
361         return 0;
362 }
363
364 static int gemtek_pci_release(struct file *file)
365 {
366         return 0;
367 }
368
369 static const struct v4l2_file_operations gemtek_pci_fops = {
370         .owner          = THIS_MODULE,
371         .open           = gemtek_pci_open,
372         .release        = gemtek_pci_release,
373         .ioctl          = video_ioctl2,
374 };
375
376 static const struct v4l2_ioctl_ops gemtek_pci_ioctl_ops = {
377         .vidioc_querycap    = vidioc_querycap,
378         .vidioc_g_tuner     = vidioc_g_tuner,
379         .vidioc_s_tuner     = vidioc_s_tuner,
380         .vidioc_g_audio     = vidioc_g_audio,
381         .vidioc_s_audio     = vidioc_s_audio,
382         .vidioc_g_input     = vidioc_g_input,
383         .vidioc_s_input     = vidioc_s_input,
384         .vidioc_g_frequency = vidioc_g_frequency,
385         .vidioc_s_frequency = vidioc_s_frequency,
386         .vidioc_queryctrl   = vidioc_queryctrl,
387         .vidioc_g_ctrl      = vidioc_g_ctrl,
388         .vidioc_s_ctrl      = vidioc_s_ctrl,
389 };
390
391 static int __devinit gemtek_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
392 {
393         struct gemtek_pci *card;
394         struct v4l2_device *v4l2_dev;
395         int res;
396
397         card = kzalloc(sizeof(struct gemtek_pci), GFP_KERNEL);
398         if (card == NULL) {
399                 dev_err(&pdev->dev, "out of memory\n");
400                 return -ENOMEM;
401         }
402
403         v4l2_dev = &card->v4l2_dev;
404         mutex_init(&card->lock);
405         card->pdev = pdev;
406
407         strlcpy(v4l2_dev->name, "gemtek_pci", sizeof(v4l2_dev->name));
408
409         res = v4l2_device_register(&pdev->dev, v4l2_dev);
410         if (res < 0) {
411                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
412                 kfree(card);
413                 return res;
414         }
415
416         if (pci_enable_device(pdev))
417                 goto err_pci;
418
419         card->iobase = pci_resource_start(pdev, 0);
420         card->length = pci_resource_len(pdev, 0);
421
422         if (request_region(card->iobase, card->length, card_names[pci_id->driver_data]) == NULL) {
423                 v4l2_err(v4l2_dev, "i/o port already in use\n");
424                 goto err_pci;
425         }
426
427         strlcpy(card->vdev.name, v4l2_dev->name, sizeof(card->vdev.name));
428         card->vdev.v4l2_dev = v4l2_dev;
429         card->vdev.fops = &gemtek_pci_fops;
430         card->vdev.ioctl_ops = &gemtek_pci_ioctl_ops;
431         card->vdev.release = video_device_release_empty;
432         video_set_drvdata(&card->vdev, card);
433
434         if (video_register_device(&card->vdev, VFL_TYPE_RADIO, nr_radio) < 0)
435                 goto err_video;
436
437         gemtek_pci_mute(card);
438
439         v4l2_info(v4l2_dev, "Gemtek PCI Radio (rev. %d) found at 0x%04x-0x%04x.\n",
440                 pdev->revision, card->iobase, card->iobase + card->length - 1);
441
442         return 0;
443
444 err_video:
445         release_region(card->iobase, card->length);
446
447 err_pci:
448         v4l2_device_unregister(v4l2_dev);
449         kfree(card);
450         return -ENODEV;
451 }
452
453 static void __devexit gemtek_pci_remove(struct pci_dev *pdev)
454 {
455         struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
456         struct gemtek_pci *card = to_gemtek_pci(v4l2_dev);
457
458         video_unregister_device(&card->vdev);
459         v4l2_device_unregister(v4l2_dev);
460
461         release_region(card->iobase, card->length);
462
463         if (mx)
464                 gemtek_pci_mute(card);
465
466         kfree(card);
467 }
468
469 static struct pci_driver gemtek_pci_driver = {
470         .name           = "gemtek_pci",
471         .id_table       = gemtek_pci_id,
472         .probe          = gemtek_pci_probe,
473         .remove         = __devexit_p(gemtek_pci_remove),
474 };
475
476 static int __init gemtek_pci_init(void)
477 {
478         return pci_register_driver(&gemtek_pci_driver);
479 }
480
481 static void __exit gemtek_pci_exit(void)
482 {
483         pci_unregister_driver(&gemtek_pci_driver);
484 }
485
486 module_init(gemtek_pci_init);
487 module_exit(gemtek_pci_exit);