?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
spi-topcliff-pch: supports a spi mode setup and bit order setup by IO control
[zen-stable.git] / drivers / media / radio / radio-zoltrix.c
blobf5613b94820353f1744d4f7fff50c42e9be77a69
1 /* zoltrix radio plus driver for Linux radio support
2 * (c) 1998 C. van Schaik <carl@leg.uct.ac.za>
3 *
4 * BUGS
5 * Due to the inconsistency in reading from the signal flags
6 * it is difficult to get an accurate tuned signal.
7 *
8 * It seems that the card is not linear to 0 volume. It cuts off
9 * at a low volume, and it is not possible (at least I have not found)
10 * to get fine volume control over the low volume range.
11 *
12 * Some code derived from code by Romolo Manfredini
13 * romolo@bicnet.it
14 *
15 * 1999-05-06 - (C. van Schaik)
16 * - Make signal strength and stereo scans
17 * kinder to cpu while in delay
18 * 1999-01-05 - (C. van Schaik)
19 * - Changed tuning to 1/160Mhz accuracy
20 * - Added stereo support
21 * (card defaults to stereo)
22 * (can explicitly force mono on the card)
23 * (can detect if station is in stereo)
24 * - Added unmute function
25 * - Reworked ioctl functions
26 * 2002-07-15 - Fix Stereo typo
27 *
28 * 2006-07-24 - Converted to V4L2 API
29 * by Mauro Carvalho Chehab <mchehab@infradead.org>
30 */
31
32 #include <linux/module.h> /* Modules */
33 #include <linux/init.h> /* Initdata */
34 #include <linux/ioport.h> /* request_region */
35 #include <linux/delay.h> /* udelay, msleep */
36 #include <linux/videodev2.h> /* kernel radio structs */
37 #include <linux/mutex.h>
38 #include <linux/io.h> /* outb, outb_p */
39 #include <media/v4l2-device.h>
40 #include <media/v4l2-ioctl.h>
41
42 MODULE_AUTHOR("C.van Schaik");
43 MODULE_DESCRIPTION("A driver for the Zoltrix Radio Plus.");
44 MODULE_LICENSE("GPL");
45 MODULE_VERSION("0.0.3");
46
47 #ifndef CONFIG_RADIO_ZOLTRIX_PORT
48 #define CONFIG_RADIO_ZOLTRIX_PORT -1
49 #endif
50
51 static int io = CONFIG_RADIO_ZOLTRIX_PORT;
52 static int radio_nr = -1;
53
54 module_param(io, int, 0);
55 MODULE_PARM_DESC(io, "I/O address of the Zoltrix Radio Plus (0x20c or 0x30c)");
56 module_param(radio_nr, int, 0);
57
58 struct zoltrix {
59 struct v4l2_device v4l2_dev;
60 struct video_device vdev;
61 int io;
62 int curvol;
63 unsigned long curfreq;
64 int muted;
65 unsigned int stereo;
66 struct mutex lock;
67 };
68
69 static struct zoltrix zoltrix_card;
70
71 static int zol_setvol(struct zoltrix *zol, int vol)
72 {
73 zol->curvol = vol;
74 if (zol->muted)
75 return 0;
76
77 mutex_lock(&zol->lock);
78 if (vol == 0) {
79 outb(0, zol->io);
80 outb(0, zol->io);
81 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
82 mutex_unlock(&zol->lock);
83 return 0;
84 }
85
86 outb(zol->curvol-1, zol->io);
87 msleep(10);
88 inb(zol->io + 2);
89 mutex_unlock(&zol->lock);
90 return 0;
91 }
92
93 static void zol_mute(struct zoltrix *zol)
94 {
95 zol->muted = 1;
96 mutex_lock(&zol->lock);
97 outb(0, zol->io);
98 outb(0, zol->io);
99 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
100 mutex_unlock(&zol->lock);
101 }
102
103 static void zol_unmute(struct zoltrix *zol)
104 {
105 zol->muted = 0;
106 zol_setvol(zol, zol->curvol);
107 }
108
109 static int zol_setfreq(struct zoltrix *zol, unsigned long freq)
110 {
111 /* tunes the radio to the desired frequency */
112 struct v4l2_device *v4l2_dev = &zol->v4l2_dev;
113 unsigned long long bitmask, f, m;
114 unsigned int stereo = zol->stereo;
115 int i;
116
117 if (freq == 0) {
118 v4l2_warn(v4l2_dev, "cannot set a frequency of 0.\n");
119 return -EINVAL;
120 }
121
122 m = (freq / 160 - 8800) * 2;
123 f = (unsigned long long)m + 0x4d1c;
124
125 bitmask = 0xc480402c10080000ull;
126 i = 45;
127
128 mutex_lock(&zol->lock);
129
130 zol->curfreq = freq;
131
132 outb(0, zol->io);
133 outb(0, zol->io);
134 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
135
136 outb(0x40, zol->io);
137 outb(0xc0, zol->io);
138
139 bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ (stereo << 31));
140 while (i--) {
141 if ((bitmask & 0x8000000000000000ull) != 0) {
142 outb(0x80, zol->io);
143 udelay(50);
144 outb(0x00, zol->io);
145 udelay(50);
146 outb(0x80, zol->io);
147 udelay(50);
148 } else {
149 outb(0xc0, zol->io);
150 udelay(50);
151 outb(0x40, zol->io);
152 udelay(50);
153 outb(0xc0, zol->io);
154 udelay(50);
155 }
156 bitmask *= 2;
157 }
158 /* termination sequence */
159 outb(0x80, zol->io);
160 outb(0xc0, zol->io);
161 outb(0x40, zol->io);
162 udelay(1000);
163 inb(zol->io + 2);
164
165 udelay(1000);
166
167 if (zol->muted) {
168 outb(0, zol->io);
169 outb(0, zol->io);
170 inb(zol->io + 3);
171 udelay(1000);
172 }
173
174 mutex_unlock(&zol->lock);
175
176 if (!zol->muted)
177 zol_setvol(zol, zol->curvol);
178 return 0;
179 }
180
181 /* Get signal strength */
182 static int zol_getsigstr(struct zoltrix *zol)
183 {
184 int a, b;
185
186 mutex_lock(&zol->lock);
187 outb(0x00, zol->io); /* This stuff I found to do nothing */
188 outb(zol->curvol, zol->io);
189 msleep(20);
190
191 a = inb(zol->io);
192 msleep(10);
193 b = inb(zol->io);
194
195 mutex_unlock(&zol->lock);
196
197 if (a != b)
198 return 0;
199
200 /* I found this out by playing with a binary scanner on the card io */
201 return a == 0xcf || a == 0xdf || a == 0xef;
202 }
203
204 static int zol_is_stereo(struct zoltrix *zol)
205 {
206 int x1, x2;
207
208 mutex_lock(&zol->lock);
209
210 outb(0x00, zol->io);
211 outb(zol->curvol, zol->io);
212 msleep(20);
213
214 x1 = inb(zol->io);
215 msleep(10);
216 x2 = inb(zol->io);
217
218 mutex_unlock(&zol->lock);
219
220 return x1 == x2 && x1 == 0xcf;
221 }
222
223 static int vidioc_querycap(struct file *file, void *priv,
224 struct v4l2_capability *v)
225 {
226 strlcpy(v->driver, "radio-zoltrix", sizeof(v->driver));
227 strlcpy(v->card, "Zoltrix Radio", sizeof(v->card));
228 strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
229 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
230 return 0;
231 }
232
233 static int vidioc_g_tuner(struct file *file, void *priv,
234 struct v4l2_tuner *v)
235 {
236 struct zoltrix *zol = video_drvdata(file);
237
238 if (v->index > 0)
239 return -EINVAL;
240
241 strlcpy(v->name, "FM", sizeof(v->name));
242 v->type = V4L2_TUNER_RADIO;
243 v->rangelow = 88 * 16000;
244 v->rangehigh = 108 * 16000;
245 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
246 v->capability = V4L2_TUNER_CAP_LOW;
247 if (zol_is_stereo(zol))
248 v->audmode = V4L2_TUNER_MODE_STEREO;
249 else
250 v->audmode = V4L2_TUNER_MODE_MONO;
251 v->signal = 0xFFFF * zol_getsigstr(zol);
252 return 0;
253 }
254
255 static int vidioc_s_tuner(struct file *file, void *priv,
256 struct v4l2_tuner *v)
257 {
258 return v->index ? -EINVAL : 0;
259 }
260
261 static int vidioc_s_frequency(struct file *file, void *priv,
262 struct v4l2_frequency *f)
263 {
264 struct zoltrix *zol = video_drvdata(file);
265
266 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
267 return -EINVAL;
268 if (zol_setfreq(zol, f->frequency) != 0)
269 return -EINVAL;
270 return 0;
271 }
272
273 static int vidioc_g_frequency(struct file *file, void *priv,
274 struct v4l2_frequency *f)
275 {
276 struct zoltrix *zol = video_drvdata(file);
277
278 if (f->tuner != 0)
279 return -EINVAL;
280 f->type = V4L2_TUNER_RADIO;
281 f->frequency = zol->curfreq;
282 return 0;
283 }
284
285 static int vidioc_queryctrl(struct file *file, void *priv,
286 struct v4l2_queryctrl *qc)
287 {
288 switch (qc->id) {
289 case V4L2_CID_AUDIO_MUTE:
290 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
291 case V4L2_CID_AUDIO_VOLUME:
292 return v4l2_ctrl_query_fill(qc, 0, 65535, 4096, 65535);
293 }
294 return -EINVAL;
295 }
296
297 static int vidioc_g_ctrl(struct file *file, void *priv,
298 struct v4l2_control *ctrl)
299 {
300 struct zoltrix *zol = video_drvdata(file);
301
302 switch (ctrl->id) {
303 case V4L2_CID_AUDIO_MUTE:
304 ctrl->value = zol->muted;
305 return 0;
306 case V4L2_CID_AUDIO_VOLUME:
307 ctrl->value = zol->curvol * 4096;
308 return 0;
309 }
310 return -EINVAL;
311 }
312
313 static int vidioc_s_ctrl(struct file *file, void *priv,
314 struct v4l2_control *ctrl)
315 {
316 struct zoltrix *zol = video_drvdata(file);
317
318 switch (ctrl->id) {
319 case V4L2_CID_AUDIO_MUTE:
320 if (ctrl->value)
321 zol_mute(zol);
322 else {
323 zol_unmute(zol);
324 zol_setvol(zol, zol->curvol);
325 }
326 return 0;
327 case V4L2_CID_AUDIO_VOLUME:
328 zol_setvol(zol, ctrl->value / 4096);
329 return 0;
330 }
331 zol->stereo = 1;
332 if (zol_setfreq(zol, zol->curfreq) != 0)
333 return -EINVAL;
334 #if 0
335 /* FIXME: Implement stereo/mono switch on V4L2 */
336 if (v->mode & VIDEO_SOUND_STEREO) {
337 zol->stereo = 1;
338 zol_setfreq(zol, zol->curfreq);
339 }
340 if (v->mode & VIDEO_SOUND_MONO) {
341 zol->stereo = 0;
342 zol_setfreq(zol, zol->curfreq);
343 }
344 #endif
345 return -EINVAL;
346 }
347
348 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
349 {
350 *i = 0;
351 return 0;
352 }
353
354 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
355 {
356 return i ? -EINVAL : 0;
357 }
358
359 static int vidioc_g_audio(struct file *file, void *priv,
360 struct v4l2_audio *a)
361 {
362 a->index = 0;
363 strlcpy(a->name, "Radio", sizeof(a->name));
364 a->capability = V4L2_AUDCAP_STEREO;
365 return 0;
366 }
367
368 static int vidioc_s_audio(struct file *file, void *priv,
369 struct v4l2_audio *a)
370 {
371 return a->index ? -EINVAL : 0;
372 }
373
374 static const struct v4l2_file_operations zoltrix_fops =
375 {
376 .owner = THIS_MODULE,
377 .unlocked_ioctl = video_ioctl2,
378 };
379
380 static const struct v4l2_ioctl_ops zoltrix_ioctl_ops = {
381 .vidioc_querycap = vidioc_querycap,
382 .vidioc_g_tuner = vidioc_g_tuner,
383 .vidioc_s_tuner = vidioc_s_tuner,
384 .vidioc_g_audio = vidioc_g_audio,
385 .vidioc_s_audio = vidioc_s_audio,
386 .vidioc_g_input = vidioc_g_input,
387 .vidioc_s_input = vidioc_s_input,
388 .vidioc_g_frequency = vidioc_g_frequency,
389 .vidioc_s_frequency = vidioc_s_frequency,
390 .vidioc_queryctrl = vidioc_queryctrl,
391 .vidioc_g_ctrl = vidioc_g_ctrl,
392 .vidioc_s_ctrl = vidioc_s_ctrl,
393 };
394
395 static int __init zoltrix_init(void)
396 {
397 struct zoltrix *zol = &zoltrix_card;
398 struct v4l2_device *v4l2_dev = &zol->v4l2_dev;
399 int res;
400
401 strlcpy(v4l2_dev->name, "zoltrix", sizeof(v4l2_dev->name));
402 zol->io = io;
403 if (zol->io == -1) {
404 v4l2_err(v4l2_dev, "You must set an I/O address with io=0x20c or 0x30c\n");
405 return -EINVAL;
406 }
407 if (zol->io != 0x20c && zol->io != 0x30c) {
408 v4l2_err(v4l2_dev, "invalid port, try 0x20c or 0x30c\n");
409 return -ENXIO;
410 }
411
412 if (!request_region(zol->io, 2, "zoltrix")) {
413 v4l2_err(v4l2_dev, "port 0x%x already in use\n", zol->io);
414 return -EBUSY;
415 }
416
417 res = v4l2_device_register(NULL, v4l2_dev);
418 if (res < 0) {
419 release_region(zol->io, 2);
420 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
421 return res;
422 }
423
424 mutex_init(&zol->lock);
425
426 /* mute card - prevents noisy bootups */
427
428 /* this ensures that the volume is all the way down */
429
430 outb(0, zol->io);
431 outb(0, zol->io);
432 msleep(20);
433 inb(zol->io + 3);
434
435 zol->curvol = 0;
436 zol->stereo = 1;
437
438 strlcpy(zol->vdev.name, v4l2_dev->name, sizeof(zol->vdev.name));
439 zol->vdev.v4l2_dev = v4l2_dev;
440 zol->vdev.fops = &zoltrix_fops;
441 zol->vdev.ioctl_ops = &zoltrix_ioctl_ops;
442 zol->vdev.release = video_device_release_empty;
443 video_set_drvdata(&zol->vdev, zol);
444
445 if (video_register_device(&zol->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
446 v4l2_device_unregister(v4l2_dev);
447 release_region(zol->io, 2);
448 return -EINVAL;
449 }
450 v4l2_info(v4l2_dev, "Zoltrix Radio Plus card driver.\n");
451
452 return 0;
453 }
454
455 static void __exit zoltrix_exit(void)
456 {
457 struct zoltrix *zol = &zoltrix_card;
458
459 video_unregister_device(&zol->vdev);
460 v4l2_device_unregister(&zol->v4l2_dev);
461 release_region(zol->io, 2);
462 }
463
464 module_init(zoltrix_init);
465 module_exit(zoltrix_exit);
466