1 /* Maestro PCI sound card radio driver for Linux support
2 * (c) 2000 A. Tlalka, atlka@pg.gda.pl
3 * Notes on the hardware
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.
11 * + io port is automatically detected - only the first radio is used
13 * + thread access locking additions
16 * + VIDEO_TUNER_LOW is permanent
18 * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/ioport.h>
24 #include <linux/delay.h>
26 #include <asm/uaccess.h>
27 #include <linux/pci.h>
28 #include <linux/videodev2.h>
29 #include <media/v4l2-common.h>
31 #include <linux/version.h> /* for KERNEL_VERSION MACRO */
32 #define RADIO_VERSION KERNEL_VERSION(0,0,6)
33 #define DRIVER_VERSION "0.06"
35 static struct v4l2_queryctrl radio_qctrl
[] = {
37 .id
= V4L2_CID_AUDIO_MUTE
,
42 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
46 #define GPIO_DATA 0x60 /* port offset from ESS_IO_BASE */
48 #define IO_MASK 4 /* mask register offset from GPIO_DATA
49 bits 1=unmask write to given bit */
50 #define IO_DIR 8 /* direction register offset from GPIO_DATA
51 bits 0/1=read/write direction */
53 #define GPIO6 0x0040 /* mask bits for GPIO lines */
58 #define STR_DATA GPIO6 /* radio TEA5757 pins and GPIO bits */
60 #define STR_WREN GPIO8
61 #define STR_MOST GPIO9
63 #define FREQ_LO 50*16000
64 #define FREQ_HI 150*16000
66 #define FREQ_IF 171200 /* 10.7*16000 */
67 #define FREQ_STEP 200 /* 12.5*16 */
69 #define FREQ2BITS(x) ((((unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1))\
70 /(FREQ_STEP<<2))<<2) /* (x==fmhz*16*1000) -> bits */
72 #define BITS2FREQ(x) ((x) * FREQ_STEP - FREQ_IF)
74 static int radio_nr
= -1;
75 module_param(radio_nr
, int, 0);
77 static int maestro_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
);
78 static void maestro_remove(struct pci_dev
*pdev
);
80 static struct pci_device_id maestro_r_pci_tbl
[] = {
81 { PCI_DEVICE(PCI_VENDOR_ID_ESS
, PCI_DEVICE_ID_ESS_ESS1968
),
82 .class = PCI_CLASS_MULTIMEDIA_AUDIO
<< 8,
83 .class_mask
= 0xffff00 },
84 { PCI_DEVICE(PCI_VENDOR_ID_ESS
, PCI_DEVICE_ID_ESS_ESS1978
),
85 .class = PCI_CLASS_MULTIMEDIA_AUDIO
<< 8,
86 .class_mask
= 0xffff00 },
89 MODULE_DEVICE_TABLE(pci
, maestro_r_pci_tbl
);
91 static struct pci_driver maestro_r_driver
= {
92 .name
= "maestro_radio",
93 .id_table
= maestro_r_pci_tbl
,
94 .probe
= maestro_probe
,
95 .remove
= __devexit_p(maestro_remove
),
98 static const struct file_operations maestro_fops
= {
100 .open
= video_exclusive_open
,
101 .release
= video_exclusive_release
,
102 .ioctl
= video_ioctl2
,
103 .compat_ioctl
= v4l_compat_ioctl32
,
107 struct radio_device
{
108 u16 io
, /* base of Maestro card radio io (GPIO_DATA)*/
109 muted
, /* VIDEO_AUDIO_MUTE */
110 stereo
, /* VIDEO_TUNER_STEREO_ON */
111 tuned
; /* signal strength (0 or 0xffff) */
114 static u32
radio_bits_get(struct radio_device
*dev
)
116 register u16 io
=dev
->io
, l
, rdata
;
120 omask
= inw(io
+ IO_MASK
);
121 outw(~(STR_CLK
| STR_WREN
), io
+ IO_MASK
);
126 outw(STR_CLK
, io
); /* HI state */
129 dev
->tuned
= inw(io
) & STR_MOST
? 0 : 0xffff;
130 outw(0, io
); /* LO state */
132 data
<<= 1; /* shift data */
135 dev
->stereo
= rdata
& STR_MOST
?
147 outw(omask
, io
+ IO_MASK
);
149 return data
& 0x3ffe;
152 static void radio_bits_set(struct radio_device
*dev
, u32 data
)
154 register u16 io
=dev
->io
, l
, bits
;
157 omask
= inw(io
+ IO_MASK
);
158 odir
= (inw(io
+ IO_DIR
) & ~STR_DATA
) | (STR_CLK
| STR_WREN
);
159 outw(odir
| STR_DATA
, io
+ IO_DIR
);
160 outw(~(STR_DATA
| STR_CLK
| STR_WREN
), io
+ IO_MASK
);
163 bits
= ((data
>> 18) & STR_DATA
) | STR_WREN
;
164 data
<<= 1; /* shift data */
165 outw(bits
, io
); /* start strobe */
167 outw(bits
| STR_CLK
, io
); /* HI level */
169 outw(bits
, io
); /* LO level */
177 outw(omask
, io
+ IO_MASK
);
178 outw(odir
, io
+ IO_DIR
);
182 static int vidioc_querycap(struct file
*file
, void *priv
,
183 struct v4l2_capability
*v
)
185 strlcpy(v
->driver
, "radio-maestro", sizeof(v
->driver
));
186 strlcpy(v
->card
, "Maestro Radio", sizeof(v
->card
));
187 sprintf(v
->bus_info
, "PCI");
188 v
->version
= RADIO_VERSION
;
189 v
->capabilities
= V4L2_CAP_TUNER
;
193 static int vidioc_g_tuner(struct file
*file
, void *priv
,
194 struct v4l2_tuner
*v
)
196 struct video_device
*dev
= video_devdata(file
);
197 struct radio_device
*card
= video_get_drvdata(dev
);
202 (void)radio_bits_get(card
);
204 strcpy(v
->name
, "FM");
205 v
->type
= V4L2_TUNER_RADIO
;
206 v
->rangelow
= FREQ_LO
;
207 v
->rangehigh
= FREQ_HI
;
208 v
->rxsubchans
= V4L2_TUNER_SUB_MONO
|V4L2_TUNER_SUB_STEREO
;
209 v
->capability
= V4L2_TUNER_CAP_LOW
;
211 v
->audmode
= V4L2_TUNER_MODE_STEREO
;
213 v
->audmode
= V4L2_TUNER_MODE_MONO
;
214 v
->signal
= card
->tuned
;
218 static int vidioc_s_tuner(struct file
*file
, void *priv
,
219 struct v4l2_tuner
*v
)
226 static int vidioc_s_frequency(struct file
*file
, void *priv
,
227 struct v4l2_frequency
*f
)
229 struct video_device
*dev
= video_devdata(file
);
230 struct radio_device
*card
= video_get_drvdata(dev
);
232 if (f
->frequency
< FREQ_LO
|| f
->frequency
> FREQ_HI
)
234 radio_bits_set(card
, FREQ2BITS(f
->frequency
));
238 static int vidioc_g_frequency(struct file
*file
, void *priv
,
239 struct v4l2_frequency
*f
)
241 struct video_device
*dev
= video_devdata(file
);
242 struct radio_device
*card
= video_get_drvdata(dev
);
244 f
->type
= V4L2_TUNER_RADIO
;
245 f
->frequency
= BITS2FREQ(radio_bits_get(card
));
249 static int vidioc_queryctrl(struct file
*file
, void *priv
,
250 struct v4l2_queryctrl
*qc
)
254 for (i
= 0; i
< ARRAY_SIZE(radio_qctrl
); i
++) {
255 if (qc
->id
&& qc
->id
== radio_qctrl
[i
].id
) {
256 memcpy(qc
, &(radio_qctrl
[i
]),
264 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
265 struct v4l2_control
*ctrl
)
267 struct video_device
*dev
= video_devdata(file
);
268 struct radio_device
*card
= video_get_drvdata(dev
);
271 case V4L2_CID_AUDIO_MUTE
:
272 ctrl
->value
= card
->muted
;
278 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
279 struct v4l2_control
*ctrl
)
281 struct video_device
*dev
= video_devdata(file
);
282 struct radio_device
*card
= video_get_drvdata(dev
);
283 register u16 io
= card
->io
;
284 register u16 omask
= inw(io
+ IO_MASK
);
287 case V4L2_CID_AUDIO_MUTE
:
288 outw(~STR_WREN
, io
+ IO_MASK
);
289 outw((card
->muted
= ctrl
->value
) ?
292 outw(omask
, io
+ IO_MASK
);
299 static int vidioc_g_audio(struct file
*file
, void *priv
,
300 struct v4l2_audio
*a
)
305 strcpy(a
->name
, "Radio");
306 a
->capability
= V4L2_AUDCAP_STEREO
;
310 static int vidioc_g_input(struct file
*filp
, void *priv
, unsigned int *i
)
316 static int vidioc_s_input(struct file
*filp
, void *priv
, unsigned int i
)
323 static int vidioc_s_audio(struct file
*file
, void *priv
,
324 struct v4l2_audio
*a
)
331 static u16 __devinit
radio_power_on(struct radio_device
*dev
)
333 register u16 io
= dev
->io
;
337 omask
= inw(io
+ IO_MASK
);
338 odir
= (inw(io
+ IO_DIR
) & ~STR_DATA
) | (STR_CLK
| STR_WREN
);
339 outw(odir
& ~STR_WREN
, io
+ IO_DIR
);
340 dev
->muted
= inw(io
) & STR_WREN
? 0 : 1;
341 outw(odir
, io
+ IO_DIR
);
342 outw(~(STR_WREN
| STR_CLK
), io
+ IO_MASK
);
343 outw(dev
->muted
? 0 : STR_WREN
, io
);
345 outw(omask
, io
+ IO_MASK
);
346 ofreq
= radio_bits_get(dev
);
348 if ((ofreq
< FREQ2BITS(FREQ_LO
)) || (ofreq
> FREQ2BITS(FREQ_HI
)))
349 ofreq
= FREQ2BITS(FREQ_LO
);
350 radio_bits_set(dev
, ofreq
);
352 return (ofreq
== radio_bits_get(dev
));
355 static struct video_device maestro_radio
= {
356 .name
= "Maestro radio",
357 .type
= VID_TYPE_TUNER
,
358 .fops
= &maestro_fops
,
359 .vidioc_querycap
= vidioc_querycap
,
360 .vidioc_g_tuner
= vidioc_g_tuner
,
361 .vidioc_s_tuner
= vidioc_s_tuner
,
362 .vidioc_g_audio
= vidioc_g_audio
,
363 .vidioc_s_audio
= vidioc_s_audio
,
364 .vidioc_g_input
= vidioc_g_input
,
365 .vidioc_s_input
= vidioc_s_input
,
366 .vidioc_g_frequency
= vidioc_g_frequency
,
367 .vidioc_s_frequency
= vidioc_s_frequency
,
368 .vidioc_queryctrl
= vidioc_queryctrl
,
369 .vidioc_g_ctrl
= vidioc_g_ctrl
,
370 .vidioc_s_ctrl
= vidioc_s_ctrl
,
373 static int __devinit
maestro_probe(struct pci_dev
*pdev
,
374 const struct pci_device_id
*ent
)
376 struct radio_device
*radio_unit
;
377 struct video_device
*maestro_radio_inst
;
380 retval
= pci_enable_device(pdev
);
382 dev_err(&pdev
->dev
, "enabling pci device failed!\n");
388 radio_unit
= kzalloc(sizeof(*radio_unit
), GFP_KERNEL
);
389 if (radio_unit
== NULL
) {
390 dev_err(&pdev
->dev
, "not enough memory\n");
394 radio_unit
->io
= pci_resource_start(pdev
, 0) + GPIO_DATA
;
396 maestro_radio_inst
= video_device_alloc();
397 if (maestro_radio_inst
== NULL
) {
398 dev_err(&pdev
->dev
, "not enough memory\n");
402 memcpy(maestro_radio_inst
, &maestro_radio
, sizeof(maestro_radio
));
403 video_set_drvdata(maestro_radio_inst
, radio_unit
);
404 pci_set_drvdata(pdev
, maestro_radio_inst
);
406 retval
= video_register_device(maestro_radio_inst
, VFL_TYPE_RADIO
,
409 printk(KERN_ERR
"can't register video device!\n");
413 if (!radio_power_on(radio_unit
)) {
418 dev_info(&pdev
->dev
, "version " DRIVER_VERSION
" time " __TIME__
" "
420 dev_info(&pdev
->dev
, "radio chip initialized\n");
424 video_unregister_device(maestro_radio_inst
);
426 kfree(maestro_radio_inst
);
434 static void __devexit
maestro_remove(struct pci_dev
*pdev
)
436 struct video_device
*vdev
= pci_get_drvdata(pdev
);
438 video_unregister_device(vdev
);
441 static int __init
maestro_radio_init(void)
443 int retval
= pci_register_driver(&maestro_r_driver
);
446 printk(KERN_ERR
"error during registration pci driver\n");
451 static void __exit
maestro_radio_exit(void)
453 pci_unregister_driver(&maestro_r_driver
);
456 module_init(maestro_radio_init
);
457 module_exit(maestro_radio_exit
);
459 MODULE_AUTHOR("Adam Tlalka, atlka@pg.gda.pl");
460 MODULE_DESCRIPTION("Radio driver for the Maestro PCI sound card radio.");
461 MODULE_LICENSE("GPL");