radio-trust.c 10.3 KB
Newer Older
1
/* radio-trust.c - Trust FM Radio card driver for Linux 2.2
L
Linus Torvalds 已提交
2 3 4 5
 * by Eric Lammerts <eric@scintilla.utwente.nl>
 *
 * Based on radio-aztech.c. Original notes:
 *
6
 * Adapted to support the Video for Linux API by
L
Linus Torvalds 已提交
7 8 9 10
 * Russell Kroll <rkroll@exploits.org>.  Based on original tuner code by:
 *
 * Quay Ly
 * Donald Song
11
 * Jason Lewis      (jlewis@twilight.vtc.vsc.edu)
L
Linus Torvalds 已提交
12 13 14
 * Scott McGrath    (smcgrath@twilight.vtc.vsc.edu)
 * William McGrath  (wmcgrath@twilight.vtc.vsc.edu)
 *
15
 * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
L
Linus Torvalds 已提交
16 17 18 19 20 21
 */

#include <stdarg.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/ioport.h>
22
#include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
23
#include <linux/videodev2.h>
24 25
#include <linux/io.h>
#include <media/v4l2-device.h>
26
#include <media/v4l2-ioctl.h>
L
Linus Torvalds 已提交
27

28 29 30
MODULE_AUTHOR("Eric Lammerts, Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
MODULE_DESCRIPTION("A driver for the Trust FM Radio card.");
MODULE_LICENSE("GPL");
31

L
Linus Torvalds 已提交
32 33 34 35 36 37
/* acceptable ports: 0x350 (JP3 shorted), 0x358 (JP3 open) */

#ifndef CONFIG_RADIO_TRUST_PORT
#define CONFIG_RADIO_TRUST_PORT -1
#endif

38
static int io = CONFIG_RADIO_TRUST_PORT;
L
Linus Torvalds 已提交
39
static int radio_nr = -1;
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

module_param(io, int, 0);
MODULE_PARM_DESC(io, "I/O address of the Trust FM Radio card (0x350 or 0x358)");
module_param(radio_nr, int, 0);

#define RADIO_VERSION KERNEL_VERSION(0, 0, 2)

struct trust {
	struct v4l2_device v4l2_dev;
	struct video_device vdev;
	int io;
	int ioval;
	__u16 curvol;
	__u16 curbass;
	__u16 curtreble;
	int muted;
	unsigned long curfreq;
	int curstereo;
	int curmute;
	struct mutex lock;
};

static struct trust trust_card;
L
Linus Torvalds 已提交
63 64 65 66 67

/* i2c addresses */
#define TDA7318_ADDR 0x88
#define TSA6060T_ADDR 0xc4

68 69 70 71 72
#define TR_DELAY do { inb(tr->io); inb(tr->io); inb(tr->io); } while (0)
#define TR_SET_SCL outb(tr->ioval |= 2, tr->io)
#define TR_CLR_SCL outb(tr->ioval &= 0xfd, tr->io)
#define TR_SET_SDA outb(tr->ioval |= 1, tr->io)
#define TR_CLR_SDA outb(tr->ioval &= 0xfe, tr->io)
L
Linus Torvalds 已提交
73

74
static void write_i2c(struct trust *tr, int n, ...)
L
Linus Torvalds 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
{
	unsigned char val, mask;
	va_list args;

	va_start(args, n);

	/* start condition */
	TR_SET_SDA;
	TR_SET_SCL;
	TR_DELAY;
	TR_CLR_SDA;
	TR_CLR_SCL;
	TR_DELAY;

	for(; n; n--) {
		val = va_arg(args, unsigned);
		for(mask = 0x80; mask; mask >>= 1) {
			if(val & mask)
				TR_SET_SDA;
			else
				TR_CLR_SDA;
			TR_SET_SCL;
			TR_DELAY;
			TR_CLR_SCL;
			TR_DELAY;
		}
		/* acknowledge bit */
		TR_SET_SDA;
		TR_SET_SCL;
		TR_DELAY;
		TR_CLR_SCL;
		TR_DELAY;
	}

	/* stop condition */
	TR_CLR_SDA;
	TR_DELAY;
	TR_SET_SCL;
	TR_DELAY;
	TR_SET_SDA;
	TR_DELAY;

	va_end(args);
}

120
static void tr_setvol(struct trust *tr, __u16 vol)
L
Linus Torvalds 已提交
121
{
122 123 124 125
	mutex_lock(&tr->lock);
	tr->curvol = vol / 2048;
	write_i2c(tr, 2, TDA7318_ADDR, tr->curvol ^ 0x1f);
	mutex_unlock(&tr->lock);
L
Linus Torvalds 已提交
126 127 128 129 130 131
}

static int basstreble2chip[15] = {
	0, 1, 2, 3, 4, 5, 6, 7, 14, 13, 12, 11, 10, 9, 8
};

132
static void tr_setbass(struct trust *tr, __u16 bass)
L
Linus Torvalds 已提交
133
{
134 135 136 137
	mutex_lock(&tr->lock);
	tr->curbass = bass / 4370;
	write_i2c(tr, 2, TDA7318_ADDR, 0x60 | basstreble2chip[tr->curbass]);
	mutex_unlock(&tr->lock);
L
Linus Torvalds 已提交
138 139
}

140
static void tr_settreble(struct trust *tr, __u16 treble)
L
Linus Torvalds 已提交
141
{
142 143 144 145
	mutex_lock(&tr->lock);
	tr->curtreble = treble / 4370;
	write_i2c(tr, 2, TDA7318_ADDR, 0x70 | basstreble2chip[tr->curtreble]);
	mutex_unlock(&tr->lock);
L
Linus Torvalds 已提交
146 147
}

148
static void tr_setstereo(struct trust *tr, int stereo)
L
Linus Torvalds 已提交
149
{
150 151 152 153 154
	mutex_lock(&tr->lock);
	tr->curstereo = !!stereo;
	tr->ioval = (tr->ioval & 0xfb) | (!tr->curstereo << 2);
	outb(tr->ioval, tr->io);
	mutex_unlock(&tr->lock);
L
Linus Torvalds 已提交
155 156
}

157
static void tr_setmute(struct trust *tr, int mute)
L
Linus Torvalds 已提交
158
{
159 160 161 162 163
	mutex_lock(&tr->lock);
	tr->curmute = !!mute;
	tr->ioval = (tr->ioval & 0xf7) | (tr->curmute << 3);
	outb(tr->ioval, tr->io);
	mutex_unlock(&tr->lock);
L
Linus Torvalds 已提交
164 165
}

166
static int tr_getsigstr(struct trust *tr)
L
Linus Torvalds 已提交
167 168
{
	int i, v;
169

170 171 172 173 174
	mutex_lock(&tr->lock);
	for (i = 0, v = 0; i < 100; i++)
		v |= inb(tr->io);
	mutex_unlock(&tr->lock);
	return (v & 1) ? 0 : 0xffff;
L
Linus Torvalds 已提交
175 176
}

177
static int tr_getstereo(struct trust *tr)
L
Linus Torvalds 已提交
178 179
{
	/* don't know how to determine it, just return the setting */
180
	return tr->curstereo;
L
Linus Torvalds 已提交
181 182
}

183
static void tr_setfreq(struct trust *tr, unsigned long f)
L
Linus Torvalds 已提交
184
{
185 186
	mutex_lock(&tr->lock);
	tr->curfreq = f;
L
Linus Torvalds 已提交
187
	f /= 160;	/* Convert to 10 kHz units	*/
188 189 190
	f += 1070;	/* Add 10.7 MHz IF		*/
	write_i2c(tr, 5, TSA6060T_ADDR, (f << 1) | 1, f >> 7, 0x60 | ((f >> 15) & 1), 0);
	mutex_unlock(&tr->lock);
L
Linus Torvalds 已提交
191 192
}

193 194
static int vidioc_querycap(struct file *file, void *priv,
				struct v4l2_capability *v)
L
Linus Torvalds 已提交
195
{
196 197
	strlcpy(v->driver, "radio-trust", sizeof(v->driver));
	strlcpy(v->card, "Trust FM Radio", sizeof(v->card));
198
	strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
199
	v->version = RADIO_VERSION;
200
	v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
201 202
	return 0;
}
L
Linus Torvalds 已提交
203

204 205 206
static int vidioc_g_tuner(struct file *file, void *priv,
				struct v4l2_tuner *v)
{
207 208
	struct trust *tr = video_drvdata(file);

209 210
	if (v->index > 0)
		return -EINVAL;
L
Linus Torvalds 已提交
211

212
	strlcpy(v->name, "FM", sizeof(v->name));
213
	v->type = V4L2_TUNER_RADIO;
214 215 216
	v->rangelow = 87.5 * 16000;
	v->rangehigh = 108 * 16000;
	v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
217
	v->capability = V4L2_TUNER_CAP_LOW;
218
	if (tr_getstereo(tr))
219 220 221
		v->audmode = V4L2_TUNER_MODE_STEREO;
	else
		v->audmode = V4L2_TUNER_MODE_MONO;
222
	v->signal = tr_getsigstr(tr);
223 224
	return 0;
}
225

226 227 228
static int vidioc_s_tuner(struct file *file, void *priv,
				struct v4l2_tuner *v)
{
229
	struct trust *tr = video_drvdata(file);
230

231 232 233
	if (v->index)
		return -EINVAL;
	tr_setstereo(tr, v->audmode == V4L2_TUNER_MODE_STEREO);
234 235
	return 0;
}
236

237 238 239
static int vidioc_s_frequency(struct file *file, void *priv,
				struct v4l2_frequency *f)
{
240 241 242
	struct trust *tr = video_drvdata(file);

	tr_setfreq(tr, f->frequency);
243 244
	return 0;
}
245

246 247 248
static int vidioc_g_frequency(struct file *file, void *priv,
				struct v4l2_frequency *f)
{
249 250
	struct trust *tr = video_drvdata(file);

251
	f->type = V4L2_TUNER_RADIO;
252
	f->frequency = tr->curfreq;
253 254 255 256 257 258
	return 0;
}

static int vidioc_queryctrl(struct file *file, void *priv,
				struct v4l2_queryctrl *qc)
{
259 260 261 262 263 264 265 266
	switch (qc->id) {
	case V4L2_CID_AUDIO_MUTE:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
	case V4L2_CID_AUDIO_VOLUME:
		return v4l2_ctrl_query_fill(qc, 0, 65535, 2048, 65535);
	case V4L2_CID_AUDIO_BASS:
	case V4L2_CID_AUDIO_TREBLE:
		return v4l2_ctrl_query_fill(qc, 0, 65535, 4370, 32768);
267 268 269 270 271 272 273
	}
	return -EINVAL;
}

static int vidioc_g_ctrl(struct file *file, void *priv,
				struct v4l2_control *ctrl)
{
274 275
	struct trust *tr = video_drvdata(file);

276 277
	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
278
		ctrl->value = tr->curmute;
279 280
		return 0;
	case V4L2_CID_AUDIO_VOLUME:
281
		ctrl->value = tr->curvol * 2048;
282 283
		return 0;
	case V4L2_CID_AUDIO_BASS:
284
		ctrl->value = tr->curbass * 4370;
285 286
		return 0;
	case V4L2_CID_AUDIO_TREBLE:
287
		ctrl->value = tr->curtreble * 4370;
288 289 290 291
		return 0;
	}
	return -EINVAL;
}
292

293 294 295
static int vidioc_s_ctrl(struct file *file, void *priv,
				struct v4l2_control *ctrl)
{
296 297
	struct trust *tr = video_drvdata(file);

298 299
	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
300
		tr_setmute(tr, ctrl->value);
301 302
		return 0;
	case V4L2_CID_AUDIO_VOLUME:
303
		tr_setvol(tr, ctrl->value);
304 305
		return 0;
	case V4L2_CID_AUDIO_BASS:
306
		tr_setbass(tr, ctrl->value);
307 308
		return 0;
	case V4L2_CID_AUDIO_TREBLE:
309
		tr_settreble(tr, ctrl->value);
310
		return 0;
L
Linus Torvalds 已提交
311
	}
312
	return -EINVAL;
L
Linus Torvalds 已提交
313 314
}

315 316 317 318 319 320 321 322
static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
{
	*i = 0;
	return 0;
}

static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
{
323 324 325 326 327 328 329 330 331
	return i ? -EINVAL : 0;
}

static int vidioc_g_audio(struct file *file, void *priv,
				struct v4l2_audio *a)
{
	a->index = 0;
	strlcpy(a->name, "Radio", sizeof(a->name));
	a->capability = V4L2_AUDCAP_STEREO;
332 333 334 335 336 337
	return 0;
}

static int vidioc_s_audio(struct file *file, void *priv,
				struct v4l2_audio *a)
{
338
	return a->index ? -EINVAL : 0;
L
Linus Torvalds 已提交
339 340
}

341
static int trust_open(struct file *file)
342
{
343
	return 0;
344 345
}

346
static int trust_release(struct file *file)
347 348 349 350
{
	return 0;
}

351
static const struct v4l2_file_operations trust_fops = {
L
Linus Torvalds 已提交
352
	.owner		= THIS_MODULE,
353 354
	.open           = trust_open,
	.release        = trust_release,
355
	.ioctl		= video_ioctl2,
L
Linus Torvalds 已提交
356 357
};

358
static const struct v4l2_ioctl_ops trust_ioctl_ops = {
359 360 361 362 363 364 365 366 367 368 369 370
	.vidioc_querycap    = vidioc_querycap,
	.vidioc_g_tuner     = vidioc_g_tuner,
	.vidioc_s_tuner     = vidioc_s_tuner,
	.vidioc_g_frequency = vidioc_g_frequency,
	.vidioc_s_frequency = vidioc_s_frequency,
	.vidioc_queryctrl   = vidioc_queryctrl,
	.vidioc_g_ctrl      = vidioc_g_ctrl,
	.vidioc_s_ctrl      = vidioc_s_ctrl,
	.vidioc_g_audio     = vidioc_g_audio,
	.vidioc_s_audio     = vidioc_s_audio,
	.vidioc_g_input     = vidioc_g_input,
	.vidioc_s_input     = vidioc_s_input,
L
Linus Torvalds 已提交
371 372 373 374
};

static int __init trust_init(void)
{
375 376 377 378 379 380 381 382 383 384
	struct trust *tr = &trust_card;
	struct v4l2_device *v4l2_dev = &tr->v4l2_dev;
	int res;

	strlcpy(v4l2_dev->name, "trust", sizeof(v4l2_dev->name));
	tr->io = io;
	tr->ioval = 0xf;
	mutex_init(&tr->lock);

	if (tr->io == -1) {
385
		v4l2_err(v4l2_dev, "You must set an I/O address with io=0x0x350 or 0x358\n");
L
Linus Torvalds 已提交
386 387
		return -EINVAL;
	}
388 389
	if (!request_region(tr->io, 2, "Trust FM Radio")) {
		v4l2_err(v4l2_dev, "port 0x%x already in use\n", tr->io);
L
Linus Torvalds 已提交
390 391
		return -EBUSY;
	}
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409

	res = v4l2_device_register(NULL, v4l2_dev);
	if (res < 0) {
		release_region(tr->io, 2);
		v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
		return res;
	}

	strlcpy(tr->vdev.name, v4l2_dev->name, sizeof(tr->vdev.name));
	tr->vdev.v4l2_dev = v4l2_dev;
	tr->vdev.fops = &trust_fops;
	tr->vdev.ioctl_ops = &trust_ioctl_ops;
	tr->vdev.release = video_device_release_empty;
	video_set_drvdata(&tr->vdev, tr);

	if (video_register_device(&tr->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
		v4l2_device_unregister(v4l2_dev);
		release_region(tr->io, 2);
L
Linus Torvalds 已提交
410 411 412
		return -EINVAL;
	}

413
	v4l2_info(v4l2_dev, "Trust FM Radio card driver v1.0.\n");
L
Linus Torvalds 已提交
414

415 416 417 418 419
	write_i2c(tr, 2, TDA7318_ADDR, 0x80);	/* speaker att. LF = 0 dB */
	write_i2c(tr, 2, TDA7318_ADDR, 0xa0);	/* speaker att. RF = 0 dB */
	write_i2c(tr, 2, TDA7318_ADDR, 0xc0);	/* speaker att. LR = 0 dB */
	write_i2c(tr, 2, TDA7318_ADDR, 0xe0);	/* speaker att. RR = 0 dB */
	write_i2c(tr, 2, TDA7318_ADDR, 0x40);	/* stereo 1 input, gain = 18.75 dB */
L
Linus Torvalds 已提交
420

421 422 423 424
	tr_setvol(tr, 0xffff);
	tr_setbass(tr, 0x8000);
	tr_settreble(tr, 0x8000);
	tr_setstereo(tr, 1);
L
Linus Torvalds 已提交
425 426

	/* mute card - prevents noisy bootups */
427
	tr_setmute(tr, 1);
L
Linus Torvalds 已提交
428 429 430 431 432 433

	return 0;
}

static void __exit cleanup_trust_module(void)
{
434 435 436 437 438
	struct trust *tr = &trust_card;

	video_unregister_device(&tr->vdev);
	v4l2_device_unregister(&tr->v4l2_dev);
	release_region(tr->io, 2);
L
Linus Torvalds 已提交
439 440 441 442
}

module_init(trust_init);
module_exit(cleanup_trust_module);