1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <linux/module.h>
37#include <linux/init.h>
38#include <linux/ioport.h>
39#include <linux/delay.h>
40#include <asm/io.h>
41#include <asm/uaccess.h>
42#include <linux/mutex.h>
43
44#include <linux/pci.h>
45#include <linux/videodev2.h>
46#include <media/v4l2-common.h>
47#include <media/v4l2-ioctl.h>
48
49#define DRIVER_VERSION "0.77"
50
51#include <linux/version.h>
52#define RADIO_VERSION KERNEL_VERSION(0,7,7)
53
54static struct video_device maxiradio_radio;
55
56#define dprintk(num, fmt, arg...) \
57 do { \
58 if (maxiradio_radio.debug >= num) \
59 printk(KERN_DEBUG "%s: " fmt, \
60 maxiradio_radio.name, ## arg); } while (0)
61
62static struct v4l2_queryctrl radio_qctrl[] = {
63 {
64 .id = V4L2_CID_AUDIO_MUTE,
65 .name = "Mute",
66 .minimum = 0,
67 .maximum = 1,
68 .default_value = 1,
69 .type = V4L2_CTRL_TYPE_BOOLEAN,
70 }
71};
72
73#ifndef PCI_VENDOR_ID_GUILLEMOT
74#define PCI_VENDOR_ID_GUILLEMOT 0x5046
75#endif
76
77#ifndef PCI_DEVICE_ID_GUILLEMOT
78#define PCI_DEVICE_ID_GUILLEMOT_MAXIRADIO 0x1001
79#endif
80
81
82
83static const int clk = 1, data = 2, wren = 4, mo_st = 8, power = 16 ;
84
85static int radio_nr = -1;
86module_param(radio_nr, int, 0);
87
88static unsigned long in_use;
89
90#define FREQ_LO 50*16000
91#define FREQ_HI 150*16000
92
93#define FREQ_IF 171200
94#define FREQ_STEP 200
95
96
97#define FREQ2BITS(x) ((( (unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1)) \
98 /(FREQ_STEP<<2))<<2)
99
100#define BITS2FREQ(x) ((x) * FREQ_STEP - FREQ_IF)
101
102
103static int maxiradio_exclusive_open(struct inode *inode, struct file *file)
104{
105 return test_and_set_bit(0, &in_use) ? -EBUSY : 0;
106}
107
108static int maxiradio_exclusive_release(struct inode *inode, struct file *file)
109{
110 clear_bit(0, &in_use);
111 return 0;
112}
113
114static const struct file_operations maxiradio_fops = {
115 .owner = THIS_MODULE,
116 .open = maxiradio_exclusive_open,
117 .release = maxiradio_exclusive_release,
118 .ioctl = video_ioctl2,
119#ifdef CONFIG_COMPAT
120 .compat_ioctl = v4l_compat_ioctl32,
121#endif
122 .llseek = no_llseek,
123};
124
125static struct radio_device
126{
127 __u16 io,
128 muted,
129 stereo,
130 tuned;
131
132 unsigned long freq;
133
134 struct mutex lock;
135} radio_unit = {
136 .muted =1,
137 .freq = FREQ_LO,
138};
139
140static void outbit(unsigned long bit, __u16 io)
141{
142 if (bit != 0)
143 {
144 outb( power|wren|data ,io); udelay(4);
145 outb( power|wren|data|clk ,io); udelay(4);
146 outb( power|wren|data ,io); udelay(4);
147 }
148 else
149 {
150 outb( power|wren ,io); udelay(4);
151 outb( power|wren|clk ,io); udelay(4);
152 outb( power|wren ,io); udelay(4);
153 }
154}
155
156static void turn_power(__u16 io, int p)
157{
158 if (p != 0) {
159 dprintk(1, "Radio powered on\n");
160 outb(power, io);
161 } else {
162 dprintk(1, "Radio powered off\n");
163 outb(0,io);
164 }
165}
166
167static void set_freq(__u16 io, __u32 freq)
168{
169 unsigned long int si;
170 int bl;
171 int val = FREQ2BITS(freq);
172
173
174
175 outbit(0, io);
176 outbit(1, io);
177
178 outbit(0, io);
179
180 outbit(0, io);
181 outbit(0, io);
182
183 outbit(0, io);
184 outbit(0, io);
185
186 outbit(0, io);
187 outbit(0, io);
188
189 si = 0x8000;
190 for (bl = 1; bl <= 16; bl++) {
191 outbit(val & si, io);
192 si >>= 1;
193 }
194
195 dprintk(1, "Radio freq set to %d.%02d MHz\n",
196 freq / 16000,
197 freq % 16000 * 100 / 16000);
198
199 turn_power(io, 1);
200}
201
202static int get_stereo(__u16 io)
203{
204 outb(power,io);
205 udelay(4);
206
207 return !(inb(io) & mo_st);
208}
209
210static int get_tune(__u16 io)
211{
212 outb(power+clk,io);
213 udelay(4);
214
215 return !(inb(io) & mo_st);
216}
217
218
219static int vidioc_querycap (struct file *file, void *priv,
220 struct v4l2_capability *v)
221{
222 strlcpy(v->driver, "radio-maxiradio", sizeof (v->driver));
223 strlcpy(v->card, "Maxi Radio FM2000 radio", sizeof (v->card));
224 sprintf(v->bus_info,"ISA");
225 v->version = RADIO_VERSION;
226 v->capabilities = V4L2_CAP_TUNER;
227
228 return 0;
229}
230
231static int vidioc_g_tuner (struct file *file, void *priv,
232 struct v4l2_tuner *v)
233{
234 struct radio_device *card = video_drvdata(file);
235
236 if (v->index > 0)
237 return -EINVAL;
238
239 memset(v,0,sizeof(*v));
240 strcpy(v->name, "FM");
241 v->type = V4L2_TUNER_RADIO;
242
243 v->rangelow=FREQ_LO;
244 v->rangehigh=FREQ_HI;
245 v->rxsubchans =V4L2_TUNER_SUB_MONO|V4L2_TUNER_SUB_STEREO;
246 v->capability=V4L2_TUNER_CAP_LOW;
247 if(get_stereo(card->io))
248 v->audmode = V4L2_TUNER_MODE_STEREO;
249 else
250 v->audmode = V4L2_TUNER_MODE_MONO;
251 v->signal=0xffff*get_tune(card->io);
252
253 return 0;
254}
255
256static int vidioc_s_tuner (struct file *file, void *priv,
257 struct v4l2_tuner *v)
258{
259 if (v->index > 0)
260 return -EINVAL;
261
262 return 0;
263}
264
265static int vidioc_g_audio (struct file *file, void *priv,
266 struct v4l2_audio *a)
267{
268 if (a->index > 1)
269 return -EINVAL;
270
271 strcpy(a->name, "FM");
272 a->capability = V4L2_AUDCAP_STEREO;
273 return 0;
274}
275
276static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
277{
278 *i = 0;
279
280 return 0;
281}
282
283static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
284{
285 if (i != 0)
286 return -EINVAL;
287
288 return 0;
289}
290
291
292static int vidioc_s_audio (struct file *file, void *priv,
293 struct v4l2_audio *a)
294{
295 if (a->index != 0)
296 return -EINVAL;
297
298 return 0;
299}
300
301static int vidioc_s_frequency (struct file *file, void *priv,
302 struct v4l2_frequency *f)
303{
304 struct radio_device *card = video_drvdata(file);
305
306 if (f->frequency < FREQ_LO || f->frequency > FREQ_HI) {
307 dprintk(1, "radio freq (%d.%02d MHz) out of range (%d-%d)\n",
308 f->frequency / 16000,
309 f->frequency % 16000 * 100 / 16000,
310 FREQ_LO / 16000, FREQ_HI / 16000);
311
312 return -EINVAL;
313 }
314
315 card->freq = f->frequency;
316 set_freq(card->io, card->freq);
317 msleep(125);
318
319 return 0;
320}
321
322static int vidioc_g_frequency (struct file *file, void *priv,
323 struct v4l2_frequency *f)
324{
325 struct radio_device *card = video_drvdata(file);
326
327 f->type = V4L2_TUNER_RADIO;
328 f->frequency = card->freq;
329
330 dprintk(4, "radio freq is %d.%02d MHz",
331 f->frequency / 16000,
332 f->frequency % 16000 * 100 / 16000);
333
334 return 0;
335}
336
337static int vidioc_queryctrl (struct file *file, void *priv,
338 struct v4l2_queryctrl *qc)
339{
340 int i;
341
342 for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
343 if (qc->id && qc->id == radio_qctrl[i].id) {
344 memcpy(qc, &(radio_qctrl[i]), sizeof(*qc));
345 return (0);
346 }
347 }
348
349 return -EINVAL;
350}
351
352static int vidioc_g_ctrl (struct file *file, void *priv,
353 struct v4l2_control *ctrl)
354{
355 struct radio_device *card = video_drvdata(file);
356
357 switch (ctrl->id) {
358 case V4L2_CID_AUDIO_MUTE:
359 ctrl->value=card->muted;
360 return (0);
361 }
362
363 return -EINVAL;
364}
365
366static int vidioc_s_ctrl (struct file *file, void *priv,
367 struct v4l2_control *ctrl)
368{
369 struct radio_device *card = video_drvdata(file);
370
371 switch (ctrl->id) {
372 case V4L2_CID_AUDIO_MUTE:
373 card->muted = ctrl->value;
374 if(card->muted)
375 turn_power(card->io, 0);
376 else
377 set_freq(card->io, card->freq);
378 return 0;
379 }
380
381 return -EINVAL;
382}
383
384static const struct v4l2_ioctl_ops maxiradio_ioctl_ops = {
385 .vidioc_querycap = vidioc_querycap,
386 .vidioc_g_tuner = vidioc_g_tuner,
387 .vidioc_s_tuner = vidioc_s_tuner,
388 .vidioc_g_audio = vidioc_g_audio,
389 .vidioc_s_audio = vidioc_s_audio,
390 .vidioc_g_input = vidioc_g_input,
391 .vidioc_s_input = vidioc_s_input,
392 .vidioc_g_frequency = vidioc_g_frequency,
393 .vidioc_s_frequency = vidioc_s_frequency,
394 .vidioc_queryctrl = vidioc_queryctrl,
395 .vidioc_g_ctrl = vidioc_g_ctrl,
396 .vidioc_s_ctrl = vidioc_s_ctrl,
397};
398
399static struct video_device maxiradio_radio = {
400 .name = "Maxi Radio FM2000 radio",
401 .fops = &maxiradio_fops,
402 .ioctl_ops = &maxiradio_ioctl_ops,
403 .release = video_device_release_empty,
404};
405
406static int __devinit maxiradio_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
407{
408 if(!request_region(pci_resource_start(pdev, 0),
409 pci_resource_len(pdev, 0), "Maxi Radio FM 2000")) {
410 printk(KERN_ERR "radio-maxiradio: can't reserve I/O ports\n");
411 goto err_out;
412 }
413
414 if (pci_enable_device(pdev))
415 goto err_out_free_region;
416
417 radio_unit.io = pci_resource_start(pdev, 0);
418 mutex_init(&radio_unit.lock);
419 video_set_drvdata(&maxiradio_radio, &radio_unit);
420
421 if (video_register_device(&maxiradio_radio, VFL_TYPE_RADIO, radio_nr) < 0) {
422 printk("radio-maxiradio: can't register device!");
423 goto err_out_free_region;
424 }
425
426 printk(KERN_INFO "radio-maxiradio: version "
427 DRIVER_VERSION
428 " time "
429 __TIME__ " "
430 __DATE__
431 "\n");
432
433 printk(KERN_INFO "radio-maxiradio: found Guillemot MAXI Radio device (io = 0x%x)\n",
434 radio_unit.io);
435 return 0;
436
437err_out_free_region:
438 release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
439err_out:
440 return -ENODEV;
441}
442
443static void __devexit maxiradio_remove_one(struct pci_dev *pdev)
444{
445 video_unregister_device(&maxiradio_radio);
446 release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
447}
448
449static struct pci_device_id maxiradio_pci_tbl[] = {
450 { PCI_VENDOR_ID_GUILLEMOT, PCI_DEVICE_ID_GUILLEMOT_MAXIRADIO,
451 PCI_ANY_ID, PCI_ANY_ID, },
452 { 0,}
453};
454
455MODULE_DEVICE_TABLE(pci, maxiradio_pci_tbl);
456
457static struct pci_driver maxiradio_driver = {
458 .name = "radio-maxiradio",
459 .id_table = maxiradio_pci_tbl,
460 .probe = maxiradio_init_one,
461 .remove = __devexit_p(maxiradio_remove_one),
462};
463
464static int __init maxiradio_radio_init(void)
465{
466 return pci_register_driver(&maxiradio_driver);
467}
468
469static void __exit maxiradio_radio_exit(void)
470{
471 pci_unregister_driver(&maxiradio_driver);
472}
473
474module_init(maxiradio_radio_init);
475module_exit(maxiradio_radio_exit);
476
477MODULE_AUTHOR("Dimitromanolakis Apostolos, apdim@grecian.net");
478MODULE_DESCRIPTION("Radio driver for the Guillemot Maxi Radio FM2000 radio.");
479MODULE_LICENSE("GPL");
480
481module_param_named(debug,maxiradio_radio.debug, int, 0644);
482MODULE_PARM_DESC(debug,"activates debug info");
483
