1 /* radio-aztech.c - Aztech radio card driver for Linux 2.2
2 *
3 * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
4 * Adapted to support the Video for Linux API by
5 * Russell Kroll <rkroll@exploits.org>. Based on original tuner code by:
6 *
7 * Quay Ly
8 * Donald Song
9 * Jason Lewis (jlewis@twilight.vtc.vsc.edu)
10 * Scott McGrath (smcgrath@twilight.vtc.vsc.edu)
11 * William McGrath (wmcgrath@twilight.vtc.vsc.edu)
12 *
13 * The basis for this code may be found at http://bigbang.vtc.vsc.edu/fmradio/
14 * along with more information on the card itself.
15 *
16 * History:
17 * 1999-02-24 Russell Kroll <rkroll@exploits.org>
18 * Fine tuning/VIDEO_TUNER_LOW
19 * Range expanded to 87-108 MHz (from 87.9-107.8)
20 *
21 * Notable changes from the original source:
22 * - includes stripped down to the essentials
23 * - for loops used as delays replaced with udelay()
24 * - #defines removed, changed to static values
25 * - tuning structure changed - no more character arrays, other changes
26 */
27
28 #include <linux/module.h> /* Modules */
29 #include <linux/init.h> /* Initdata */
30 #include <linux/ioport.h> /* request_region */
31 #include <linux/delay.h> /* udelay */
32 #include <linux/videodev2.h> /* kernel radio structs */
33 #include <linux/io.h> /* outb, outb_p */
34 #include <media/v4l2-device.h>
35 #include <media/v4l2-ioctl.h>
36
37 MODULE_AUTHOR("Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
38 MODULE_DESCRIPTION("A driver for the Aztech radio card.");
39 MODULE_LICENSE("GPL");
40 MODULE_VERSION("0.0.3");
41
42 /* acceptable ports: 0x350 (JP3 shorted), 0x358 (JP3 open) */
43
44 #ifndef CONFIG_RADIO_AZTECH_PORT
45 #define CONFIG_RADIO_AZTECH_PORT -1
46 #endif
47
48 static int io = CONFIG_RADIO_AZTECH_PORT;
49 static int radio_nr = -1;
50 static int radio_wait_time = 1000;
51
52 module_param(io, int, 0);
53 module_param(radio_nr, int, 0);
54 MODULE_PARM_DESC(io, "I/O address of the Aztech card (0x350 or 0x358)");
55
56 struct aztech
57 {
58 struct v4l2_device v4l2_dev;
59 struct video_device vdev;
60 int io;
61 int curvol;
62 unsigned long curfreq;
63 int stereo;
64 struct mutex lock;
65 };
66
67 static struct aztech aztech_card;
68
volconvert(int level)69 static int volconvert(int level)
70 {
71 level >>= 14; /* Map 16bits down to 2 bit */
72 level &= 3;
73
74 /* convert to card-friendly values */
75 switch (level) {
76 case 0:
77 return 0;
78 case 1:
79 return 1;
80 case 2:
81 return 4;
82 case 3:
83 return 5;
84 }
85 return 0; /* Quieten gcc */
86 }
87
send_0_byte(struct aztech * az)88 static void send_0_byte(struct aztech *az)
89 {
90 udelay(radio_wait_time);
91 outb_p(2 + volconvert(az->curvol), az->io);
92 outb_p(64 + 2 + volconvert(az->curvol), az->io);
93 }
94
send_1_byte(struct aztech * az)95 static void send_1_byte(struct aztech *az)
96 {
97 udelay (radio_wait_time);
98 outb_p(128 + 2 + volconvert(az->curvol), az->io);
99 outb_p(128 + 64 + 2 + volconvert(az->curvol), az->io);
100 }
101
az_setvol(struct aztech * az,int vol)102 static int az_setvol(struct aztech *az, int vol)
103 {
104 mutex_lock(&az->lock);
105 outb(volconvert(vol), az->io);
106 mutex_unlock(&az->lock);
107 return 0;
108 }
109
110 /* thanks to Michael Dwyer for giving me a dose of clues in
111 * the signal strength department..
112 *
113 * This card has a stereo bit - bit 0 set = mono, not set = stereo
114 * It also has a "signal" bit - bit 1 set = bad signal, not set = good
115 *
116 */
117
az_getsigstr(struct aztech * az)118 static int az_getsigstr(struct aztech *az)
119 {
120 int sig = 1;
121
122 mutex_lock(&az->lock);
123 if (inb(az->io) & 2) /* bit set = no signal present */
124 sig = 0;
125 mutex_unlock(&az->lock);
126 return sig;
127 }
128
az_getstereo(struct aztech * az)129 static int az_getstereo(struct aztech *az)
130 {
131 int stereo = 1;
132
133 mutex_lock(&az->lock);
134 if (inb(az->io) & 1) /* bit set = mono */
135 stereo = 0;
136 mutex_unlock(&az->lock);
137 return stereo;
138 }
139
az_setfreq(struct aztech * az,unsigned long frequency)140 static int az_setfreq(struct aztech *az, unsigned long frequency)
141 {
142 int i;
143
144 mutex_lock(&az->lock);
145
146 az->curfreq = frequency;
147 frequency += 171200; /* Add 10.7 MHz IF */
148 frequency /= 800; /* Convert to 50 kHz units */
149
150 send_0_byte(az); /* 0: LSB of frequency */
151
152 for (i = 0; i < 13; i++) /* : frequency bits (1-13) */
153 if (frequency & (1 << i))
154 send_1_byte(az);
155 else
156 send_0_byte(az);
157
158 send_0_byte(az); /* 14: test bit - always 0 */
159 send_0_byte(az); /* 15: test bit - always 0 */
160 send_0_byte(az); /* 16: band data 0 - always 0 */
161 if (az->stereo) /* 17: stereo (1 to enable) */
162 send_1_byte(az);
163 else
164 send_0_byte(az);
165
166 send_1_byte(az); /* 18: band data 1 - unknown */
167 send_0_byte(az); /* 19: time base - always 0 */
168 send_0_byte(az); /* 20: spacing (0 = 25 kHz) */
169 send_1_byte(az); /* 21: spacing (1 = 25 kHz) */
170 send_0_byte(az); /* 22: spacing (0 = 25 kHz) */
171 send_1_byte(az); /* 23: AM/FM (FM = 1, always) */
172
173 /* latch frequency */
174
175 udelay(radio_wait_time);
176 outb_p(128 + 64 + volconvert(az->curvol), az->io);
177
178 mutex_unlock(&az->lock);
179
180 return 0;
181 }
182
vidioc_querycap(struct file * file,void * priv,struct v4l2_capability * v)183 static int vidioc_querycap(struct file *file, void *priv,
184 struct v4l2_capability *v)
185 {
186 strlcpy(v->driver, "radio-aztech", sizeof(v->driver));
187 strlcpy(v->card, "Aztech Radio", sizeof(v->card));
188 strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
189 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
190 return 0;
191 }
192
vidioc_g_tuner(struct file * file,void * priv,struct v4l2_tuner * v)193 static int vidioc_g_tuner(struct file *file, void *priv,
194 struct v4l2_tuner *v)
195 {
196 struct aztech *az = video_drvdata(file);
197
198 if (v->index > 0)
199 return -EINVAL;
200
201 strlcpy(v->name, "FM", sizeof(v->name));
202 v->type = V4L2_TUNER_RADIO;
203
204 v->rangelow = 87 * 16000;
205 v->rangehigh = 108 * 16000;
206 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
207 v->capability = V4L2_TUNER_CAP_LOW;
208 if (az_getstereo(az))
209 v->audmode = V4L2_TUNER_MODE_STEREO;
210 else
211 v->audmode = V4L2_TUNER_MODE_MONO;
212 v->signal = 0xFFFF * az_getsigstr(az);
213
214 return 0;
215 }
216
vidioc_s_tuner(struct file * file,void * priv,struct v4l2_tuner * v)217 static int vidioc_s_tuner(struct file *file, void *priv,
218 struct v4l2_tuner *v)
219 {
220 return v->index ? -EINVAL : 0;
221 }
222
vidioc_g_input(struct file * filp,void * priv,unsigned int * i)223 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
224 {
225 *i = 0;
226 return 0;
227 }
228
vidioc_s_input(struct file * filp,void * priv,unsigned int i)229 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
230 {
231 return i ? -EINVAL : 0;
232 }
233
vidioc_g_audio(struct file * file,void * priv,struct v4l2_audio * a)234 static int vidioc_g_audio(struct file *file, void *priv,
235 struct v4l2_audio *a)
236 {
237 a->index = 0;
238 strlcpy(a->name, "Radio", sizeof(a->name));
239 a->capability = V4L2_AUDCAP_STEREO;
240 return 0;
241 }
242
vidioc_s_audio(struct file * file,void * priv,struct v4l2_audio * a)243 static int vidioc_s_audio(struct file *file, void *priv,
244 struct v4l2_audio *a)
245 {
246 return a->index ? -EINVAL : 0;
247 }
248
vidioc_s_frequency(struct file * file,void * priv,struct v4l2_frequency * f)249 static int vidioc_s_frequency(struct file *file, void *priv,
250 struct v4l2_frequency *f)
251 {
252 struct aztech *az = video_drvdata(file);
253
254 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
255 return -EINVAL;
256 az_setfreq(az, f->frequency);
257 return 0;
258 }
259
vidioc_g_frequency(struct file * file,void * priv,struct v4l2_frequency * f)260 static int vidioc_g_frequency(struct file *file, void *priv,
261 struct v4l2_frequency *f)
262 {
263 struct aztech *az = video_drvdata(file);
264
265 if (f->tuner != 0)
266 return -EINVAL;
267 f->type = V4L2_TUNER_RADIO;
268 f->frequency = az->curfreq;
269 return 0;
270 }
271
vidioc_queryctrl(struct file * file,void * priv,struct v4l2_queryctrl * qc)272 static int vidioc_queryctrl(struct file *file, void *priv,
273 struct v4l2_queryctrl *qc)
274 {
275 switch (qc->id) {
276 case V4L2_CID_AUDIO_MUTE:
277 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
278 case V4L2_CID_AUDIO_VOLUME:
279 return v4l2_ctrl_query_fill(qc, 0, 0xff, 1, 0xff);
280 }
281 return -EINVAL;
282 }
283
vidioc_g_ctrl(struct file * file,void * priv,struct v4l2_control * ctrl)284 static int vidioc_g_ctrl(struct file *file, void *priv,
285 struct v4l2_control *ctrl)
286 {
287 struct aztech *az = video_drvdata(file);
288
289 switch (ctrl->id) {
290 case V4L2_CID_AUDIO_MUTE:
291 if (az->curvol == 0)
292 ctrl->value = 1;
293 else
294 ctrl->value = 0;
295 return 0;
296 case V4L2_CID_AUDIO_VOLUME:
297 ctrl->value = az->curvol * 6554;
298 return 0;
299 }
300 return -EINVAL;
301 }
302
vidioc_s_ctrl(struct file * file,void * priv,struct v4l2_control * ctrl)303 static int vidioc_s_ctrl(struct file *file, void *priv,
304 struct v4l2_control *ctrl)
305 {
306 struct aztech *az = video_drvdata(file);
307
308 switch (ctrl->id) {
309 case V4L2_CID_AUDIO_MUTE:
310 if (ctrl->value)
311 az_setvol(az, 0);
312 else
313 az_setvol(az, az->curvol);
314 return 0;
315 case V4L2_CID_AUDIO_VOLUME:
316 az_setvol(az, ctrl->value);
317 return 0;
318 }
319 return -EINVAL;
320 }
321
322 static const struct v4l2_file_operations aztech_fops = {
323 .owner = THIS_MODULE,
324 .unlocked_ioctl = video_ioctl2,
325 };
326
327 static const struct v4l2_ioctl_ops aztech_ioctl_ops = {
328 .vidioc_querycap = vidioc_querycap,
329 .vidioc_g_tuner = vidioc_g_tuner,
330 .vidioc_s_tuner = vidioc_s_tuner,
331 .vidioc_g_audio = vidioc_g_audio,
332 .vidioc_s_audio = vidioc_s_audio,
333 .vidioc_g_input = vidioc_g_input,
334 .vidioc_s_input = vidioc_s_input,
335 .vidioc_g_frequency = vidioc_g_frequency,
336 .vidioc_s_frequency = vidioc_s_frequency,
337 .vidioc_queryctrl = vidioc_queryctrl,
338 .vidioc_g_ctrl = vidioc_g_ctrl,
339 .vidioc_s_ctrl = vidioc_s_ctrl,
340 };
341
aztech_init(void)342 static int __init aztech_init(void)
343 {
344 struct aztech *az = &aztech_card;
345 struct v4l2_device *v4l2_dev = &az->v4l2_dev;
346 int res;
347
348 strlcpy(v4l2_dev->name, "aztech", sizeof(v4l2_dev->name));
349 az->io = io;
350
351 if (az->io == -1) {
352 v4l2_err(v4l2_dev, "you must set an I/O address with io=0x350 or 0x358\n");
353 return -EINVAL;
354 }
355
356 if (!request_region(az->io, 2, "aztech")) {
357 v4l2_err(v4l2_dev, "port 0x%x already in use\n", az->io);
358 return -EBUSY;
359 }
360
361 res = v4l2_device_register(NULL, v4l2_dev);
362 if (res < 0) {
363 release_region(az->io, 2);
364 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
365 return res;
366 }
367
368 mutex_init(&az->lock);
369 strlcpy(az->vdev.name, v4l2_dev->name, sizeof(az->vdev.name));
370 az->vdev.v4l2_dev = v4l2_dev;
371 az->vdev.fops = &aztech_fops;
372 az->vdev.ioctl_ops = &aztech_ioctl_ops;
373 az->vdev.release = video_device_release_empty;
374 video_set_drvdata(&az->vdev, az);
375 /* mute card - prevents noisy bootups */
376 outb(0, az->io);
377
378 if (video_register_device(&az->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
379 v4l2_device_unregister(v4l2_dev);
380 release_region(az->io, 2);
381 return -EINVAL;
382 }
383
384 v4l2_info(v4l2_dev, "Aztech radio card driver v1.00/19990224 rkroll@exploits.org\n");
385 return 0;
386 }
387
aztech_exit(void)388 static void __exit aztech_exit(void)
389 {
390 struct aztech *az = &aztech_card;
391
392 video_unregister_device(&az->vdev);
393 v4l2_device_unregister(&az->v4l2_dev);
394 release_region(az->io, 2);
395 }
396
397 module_init(aztech_init);
398 module_exit(aztech_exit);
399