]> git.karo-electronics.de Git - mv-sheeva.git/blob - drivers/media/radio/radio-gemtek-pci.c
Merge branch 'for-linus' of git://git390.marist.edu/pub/scm/linux-2.6
[mv-sheeva.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         if (card->mute) {
185                 gemtek_pci_setfrequency(card, card->current_frequency);
186                 card->mute = false;
187         }
188 }
189
190 static int gemtek_pci_getsignal(struct gemtek_pci *card)
191 {
192         int sig;
193
194         mutex_lock(&card->lock);
195         sig = (inb(card->iobase) & 0x08) ? 0 : 1;
196         mutex_unlock(&card->lock);
197         return sig;
198 }
199
200 static int vidioc_querycap(struct file *file, void *priv,
201                                         struct v4l2_capability *v)
202 {
203         struct gemtek_pci *card = video_drvdata(file);
204
205         strlcpy(v->driver, "radio-gemtek-pci", sizeof(v->driver));
206         strlcpy(v->card, "GemTek PCI Radio", sizeof(v->card));
207         snprintf(v->bus_info, sizeof(v->bus_info), "PCI:%s", pci_name(card->pdev));
208         v->version = RADIO_VERSION;
209         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
210         return 0;
211 }
212
213 static int vidioc_g_tuner(struct file *file, void *priv,
214                                         struct v4l2_tuner *v)
215 {
216         struct gemtek_pci *card = video_drvdata(file);
217
218         if (v->index > 0)
219                 return -EINVAL;
220
221         strlcpy(v->name, "FM", sizeof(v->name));
222         v->type = V4L2_TUNER_RADIO;
223         v->rangelow = GEMTEK_PCI_RANGE_LOW;
224         v->rangehigh = GEMTEK_PCI_RANGE_HIGH;
225         v->rxsubchans = V4L2_TUNER_SUB_MONO;
226         v->capability = V4L2_TUNER_CAP_LOW;
227         v->audmode = V4L2_TUNER_MODE_MONO;
228         v->signal = 0xffff * gemtek_pci_getsignal(card);
229         return 0;
230 }
231
232 static int vidioc_s_tuner(struct file *file, void *priv,
233                                         struct v4l2_tuner *v)
234 {
235         return v->index ? -EINVAL : 0;
236 }
237
238 static int vidioc_s_frequency(struct file *file, void *priv,
239                                         struct v4l2_frequency *f)
240 {
241         struct gemtek_pci *card = video_drvdata(file);
242
243         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
244                 return -EINVAL;
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         if (f->tuner != 0)
259                 return -EINVAL;
260         f->type = V4L2_TUNER_RADIO;
261         f->frequency = card->current_frequency;
262         return 0;
263 }
264
265 static int vidioc_queryctrl(struct file *file, void *priv,
266                                         struct v4l2_queryctrl *qc)
267 {
268         switch (qc->id) {
269         case V4L2_CID_AUDIO_MUTE:
270                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
271         case V4L2_CID_AUDIO_VOLUME:
272                 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535, 65535);
273         }
274         return -EINVAL;
275 }
276
277 static int vidioc_g_ctrl(struct file *file, void *priv,
278                                         struct v4l2_control *ctrl)
279 {
280         struct gemtek_pci *card = video_drvdata(file);
281
282         switch (ctrl->id) {
283         case V4L2_CID_AUDIO_MUTE:
284                 ctrl->value = card->mute;
285                 return 0;
286         case V4L2_CID_AUDIO_VOLUME:
287                 if (card->mute)
288                         ctrl->value = 0;
289                 else
290                         ctrl->value = 65535;
291                 return 0;
292         }
293         return -EINVAL;
294 }
295
296 static int vidioc_s_ctrl(struct file *file, void *priv,
297                                         struct v4l2_control *ctrl)
298 {
299         struct gemtek_pci *card = video_drvdata(file);
300
301         switch (ctrl->id) {
302         case V4L2_CID_AUDIO_MUTE:
303                 if (ctrl->value)
304                         gemtek_pci_mute(card);
305                 else
306                         gemtek_pci_unmute(card);
307                 return 0;
308         case V4L2_CID_AUDIO_VOLUME:
309                 if (ctrl->value)
310                         gemtek_pci_unmute(card);
311                 else
312                         gemtek_pci_mute(card);
313                 return 0;
314         }
315         return -EINVAL;
316 }
317
318 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
319 {
320         *i = 0;
321         return 0;
322 }
323
324 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
325 {
326         return i ? -EINVAL : 0;
327 }
328
329 static int vidioc_g_audio(struct file *file, void *priv,
330                                         struct v4l2_audio *a)
331 {
332         a->index = 0;
333         strlcpy(a->name, "Radio", sizeof(a->name));
334         a->capability = V4L2_AUDCAP_STEREO;
335         return 0;
336 }
337
338 static int vidioc_s_audio(struct file *file, void *priv,
339                                         struct v4l2_audio *a)
340 {
341         return a->index ? -EINVAL : 0;
342 }
343
344 enum {
345         GEMTEK_PR103
346 };
347
348 static char *card_names[] __devinitdata = {
349         "GEMTEK_PR103"
350 };
351
352 static struct pci_device_id gemtek_pci_id[] =
353 {
354         { PCI_VENDOR_ID_GEMTEK, PCI_DEVICE_ID_GEMTEK_PR103,
355           PCI_ANY_ID, PCI_ANY_ID, 0, 0, GEMTEK_PR103 },
356         { 0 }
357 };
358
359 MODULE_DEVICE_TABLE(pci, gemtek_pci_id);
360
361 static const struct v4l2_file_operations gemtek_pci_fops = {
362         .owner          = THIS_MODULE,
363         .ioctl          = video_ioctl2,
364 };
365
366 static const struct v4l2_ioctl_ops gemtek_pci_ioctl_ops = {
367         .vidioc_querycap    = vidioc_querycap,
368         .vidioc_g_tuner     = vidioc_g_tuner,
369         .vidioc_s_tuner     = vidioc_s_tuner,
370         .vidioc_g_audio     = vidioc_g_audio,
371         .vidioc_s_audio     = vidioc_s_audio,
372         .vidioc_g_input     = vidioc_g_input,
373         .vidioc_s_input     = vidioc_s_input,
374         .vidioc_g_frequency = vidioc_g_frequency,
375         .vidioc_s_frequency = vidioc_s_frequency,
376         .vidioc_queryctrl   = vidioc_queryctrl,
377         .vidioc_g_ctrl      = vidioc_g_ctrl,
378         .vidioc_s_ctrl      = vidioc_s_ctrl,
379 };
380
381 static int __devinit gemtek_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
382 {
383         struct gemtek_pci *card;
384         struct v4l2_device *v4l2_dev;
385         int res;
386
387         card = kzalloc(sizeof(struct gemtek_pci), GFP_KERNEL);
388         if (card == NULL) {
389                 dev_err(&pdev->dev, "out of memory\n");
390                 return -ENOMEM;
391         }
392
393         v4l2_dev = &card->v4l2_dev;
394         mutex_init(&card->lock);
395         card->pdev = pdev;
396
397         strlcpy(v4l2_dev->name, "gemtek_pci", sizeof(v4l2_dev->name));
398
399         res = v4l2_device_register(&pdev->dev, v4l2_dev);
400         if (res < 0) {
401                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
402                 kfree(card);
403                 return res;
404         }
405
406         if (pci_enable_device(pdev))
407                 goto err_pci;
408
409         card->iobase = pci_resource_start(pdev, 0);
410         card->length = pci_resource_len(pdev, 0);
411
412         if (request_region(card->iobase, card->length, card_names[pci_id->driver_data]) == NULL) {
413                 v4l2_err(v4l2_dev, "i/o port already in use\n");
414                 goto err_pci;
415         }
416
417         strlcpy(card->vdev.name, v4l2_dev->name, sizeof(card->vdev.name));
418         card->vdev.v4l2_dev = v4l2_dev;
419         card->vdev.fops = &gemtek_pci_fops;
420         card->vdev.ioctl_ops = &gemtek_pci_ioctl_ops;
421         card->vdev.release = video_device_release_empty;
422         video_set_drvdata(&card->vdev, card);
423
424         if (video_register_device(&card->vdev, VFL_TYPE_RADIO, nr_radio) < 0)
425                 goto err_video;
426
427         gemtek_pci_mute(card);
428
429         v4l2_info(v4l2_dev, "Gemtek PCI Radio (rev. %d) found at 0x%04x-0x%04x.\n",
430                 pdev->revision, card->iobase, card->iobase + card->length - 1);
431
432         return 0;
433
434 err_video:
435         release_region(card->iobase, card->length);
436
437 err_pci:
438         v4l2_device_unregister(v4l2_dev);
439         kfree(card);
440         return -ENODEV;
441 }
442
443 static void __devexit gemtek_pci_remove(struct pci_dev *pdev)
444 {
445         struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
446         struct gemtek_pci *card = to_gemtek_pci(v4l2_dev);
447
448         video_unregister_device(&card->vdev);
449         v4l2_device_unregister(v4l2_dev);
450
451         release_region(card->iobase, card->length);
452
453         if (mx)
454                 gemtek_pci_mute(card);
455
456         kfree(card);
457 }
458
459 static struct pci_driver gemtek_pci_driver = {
460         .name           = "gemtek_pci",
461         .id_table       = gemtek_pci_id,
462         .probe          = gemtek_pci_probe,
463         .remove         = __devexit_p(gemtek_pci_remove),
464 };
465
466 static int __init gemtek_pci_init(void)
467 {
468         return pci_register_driver(&gemtek_pci_driver);
469 }
470
471 static void __exit gemtek_pci_exit(void)
472 {
473         pci_unregister_driver(&gemtek_pci_driver);
474 }
475
476 module_init(gemtek_pci_init);
477 module_exit(gemtek_pci_exit);