1 /* Terratec ActiveRadio ISA Standalone card driver for Linux radio support 2 * (c) 1999 R. Offermanns (rolf@offermanns.de) 3 * based on the aimslab radio driver from M. Kirkwood 4 * many thanks to Michael Becker and Friedhelm Birth (from TerraTec) 5 * 6 * 7 * History: 8 * 1999-05-21 First preview release 9 * 10 * Notes on the hardware: 11 * There are two "main" chips on the card: 12 * - Philips OM5610 (http://www-us.semiconductors.philips.com/acrobat/datasheets/OM5610_2.pdf) 13 * - Philips SAA6588 (http://www-us.semiconductors.philips.com/acrobat/datasheets/SAA6588_1.pdf) 14 * (you can get the datasheet at the above links) 15 * 16 * Frequency control is done digitally -- ie out(port,encodefreq(95.8)); 17 * Volume Control is done digitally 18 * 19 * there is a I2C controlled RDS decoder (SAA6588) onboard, which i would like to support someday 20 * (as soon i have understand how to get started :) 21 * If you can help me out with that, please contact me!! 22 * 23 * 24 * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org> 25 */ 26 27 #include <linux/module.h> /* Modules */ 28 #include <linux/init.h> /* Initdata */ 29 #include <linux/ioport.h> /* request_region */ 30 #include <linux/videodev2.h> /* kernel radio structs */ 31 #include <linux/mutex.h> 32 #include <linux/version.h> /* for KERNEL_VERSION MACRO */ 33 #include <linux/io.h> /* outb, outb_p */ 34 #include <media/v4l2-device.h> 35 #include <media/v4l2-ioctl.h> 36 37 MODULE_AUTHOR("R.OFFERMANNS & others"); 38 MODULE_DESCRIPTION("A driver for the TerraTec ActiveRadio Standalone radio card."); 39 MODULE_LICENSE("GPL"); 40 41 #ifndef CONFIG_RADIO_TERRATEC_PORT 42 #define CONFIG_RADIO_TERRATEC_PORT 0x590 43 #endif 44 45 static int io = CONFIG_RADIO_TERRATEC_PORT; 46 static int radio_nr = -1; 47 48 module_param(io, int, 0); 49 MODULE_PARM_DESC(io, "I/O address of the TerraTec ActiveRadio card (0x590 or 0x591)"); 50 module_param(radio_nr, int, 0); 51 52 #define RADIO_VERSION KERNEL_VERSION(0, 0, 2) 53 54 static struct v4l2_queryctrl radio_qctrl[] = { 55 { 56 .id = V4L2_CID_AUDIO_MUTE, 57 .name = "Mute", 58 .minimum = 0, 59 .maximum = 1, 60 .default_value = 1, 61 .type = V4L2_CTRL_TYPE_BOOLEAN, 62 },{ 63 .id = V4L2_CID_AUDIO_VOLUME, 64 .name = "Volume", 65 .minimum = 0, 66 .maximum = 0xff, 67 .step = 1, 68 .default_value = 0xff, 69 .type = V4L2_CTRL_TYPE_INTEGER, 70 } 71 }; 72 73 #define WRT_DIS 0x00 74 #define CLK_OFF 0x00 75 #define IIC_DATA 0x01 76 #define IIC_CLK 0x02 77 #define DATA 0x04 78 #define CLK_ON 0x08 79 #define WRT_EN 0x10 80 81 struct terratec 82 { 83 struct v4l2_device v4l2_dev; 84 struct video_device vdev; 85 int io; 86 int curvol; 87 unsigned long curfreq; 88 int muted; 89 struct mutex lock; 90 }; 91 92 static struct terratec terratec_card; 93 94 /* local things */ 95 96 static void tt_write_vol(struct terratec *tt, int volume) 97 { 98 int i; 99 100 volume = volume + (volume * 32); /* change both channels */ 101 mutex_lock(&tt->lock); 102 for (i = 0; i < 8; i++) { 103 if (volume & (0x80 >> i)) 104 outb(0x80, tt->io + 1); 105 else 106 outb(0x00, tt->io + 1); 107 } 108 mutex_unlock(&tt->lock); 109 } 110 111 112 113 static void tt_mute(struct terratec *tt) 114 { 115 tt->muted = 1; 116 tt_write_vol(tt, 0); 117 } 118 119 static int tt_setvol(struct terratec *tt, int vol) 120 { 121 if (vol == tt->curvol) { /* requested volume = current */ 122 if (tt->muted) { /* user is unmuting the card */ 123 tt->muted = 0; 124 tt_write_vol(tt, vol); /* enable card */ 125 } 126 return 0; 127 } 128 129 if (vol == 0) { /* volume = 0 means mute the card */ 130 tt_write_vol(tt, 0); /* "turn off card" by setting vol to 0 */ 131 tt->curvol = vol; /* track the volume state! */ 132 return 0; 133 } 134 135 tt->muted = 0; 136 tt_write_vol(tt, vol); 137 tt->curvol = vol; 138 return 0; 139 } 140 141 142 /* this is the worst part in this driver */ 143 /* many more or less strange things are going on here, but hey, it works :) */ 144 145 static int tt_setfreq(struct terratec *tt, unsigned long freq1) 146 { 147 int freq; 148 int i; 149 int p; 150 int temp; 151 long rest; 152 unsigned char buffer[25]; /* we have to bit shift 25 registers */ 153 154 mutex_lock(&tt->lock); 155 156 tt->curfreq = freq1; 157 158 freq = freq1 / 160; /* convert the freq. to a nice to handle value */ 159 memset(buffer, 0, sizeof(buffer)); 160 161 rest = freq * 10 + 10700; /* I once had understood what is going on here */ 162 /* maybe some wise guy (friedhelm?) can comment this stuff */ 163 i = 13; 164 p = 10; 165 temp = 102400; 166 while (rest != 0) { 167 if (rest % temp == rest) 168 buffer[i] = 0; 169 else { 170 buffer[i] = 1; 171 rest = rest - temp; 172 } 173 i--; 174 p--; 175 temp = temp / 2; 176 } 177 178 for (i = 24; i > -1; i--) { /* bit shift the values to the radiocard */ 179 if (buffer[i] == 1) { 180 outb(WRT_EN | DATA, tt->io); 181 outb(WRT_EN | DATA | CLK_ON, tt->io); 182 outb(WRT_EN | DATA, tt->io); 183 } else { 184 outb(WRT_EN | 0x00, tt->io); 185 outb(WRT_EN | 0x00 | CLK_ON, tt->io); 186 } 187 } 188 outb(0x00, tt->io); 189 190 mutex_unlock(&tt->lock); 191 192 return 0; 193 } 194 195 static int tt_getsigstr(struct terratec *tt) 196 { 197 if (inb(tt->io) & 2) /* bit set = no signal present */ 198 return 0; 199 return 1; /* signal present */ 200 } 201 202 static int vidioc_querycap(struct file *file, void *priv, 203 struct v4l2_capability *v) 204 { 205 strlcpy(v->driver, "radio-terratec", sizeof(v->driver)); 206 strlcpy(v->card, "ActiveRadio", sizeof(v->card)); 207 strlcpy(v->bus_info, "ISA", sizeof(v->bus_info)); 208 v->version = RADIO_VERSION; 209 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO; 210 return 0; 211 } 212 213 static int vidioc_g_tuner(struct file *file, void *priv, 214 struct v4l2_tuner *v) 215 { 216 struct terratec *tt = video_drvdata(file); 217 218 if (v->index > 0) 219 return -EINVAL; 220 221 strlcpy(v->name, "FM", sizeof(v->name)); 222 v->type = V4L2_TUNER_RADIO; 223 v->rangelow = 87 * 16000; 224 v->rangehigh = 108 * 16000; 225 v->rxsubchans = V4L2_TUNER_SUB_MONO; 226 v->capability = V4L2_TUNER_CAP_LOW; 227 v->audmode = V4L2_TUNER_MODE_MONO; 228 v->signal = 0xFFFF * tt_getsigstr(tt); 229 return 0; 230 } 231 232 static int vidioc_s_tuner(struct file *file, void *priv, 233 struct v4l2_tuner *v) 234 { 235 return v->index ? -EINVAL : 0; 236 } 237 238 static int vidioc_s_frequency(struct file *file, void *priv, 239 struct v4l2_frequency *f) 240 { 241 struct terratec *tt = video_drvdata(file); 242 243 tt_setfreq(tt, f->frequency); 244 return 0; 245 } 246 247 static int vidioc_g_frequency(struct file *file, void *priv, 248 struct v4l2_frequency *f) 249 { 250 struct terratec *tt = video_drvdata(file); 251 252 f->type = V4L2_TUNER_RADIO; 253 f->frequency = tt->curfreq; 254 return 0; 255 } 256 257 static int vidioc_queryctrl(struct file *file, void *priv, 258 struct v4l2_queryctrl *qc) 259 { 260 int i; 261 262 for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) { 263 if (qc->id && qc->id == radio_qctrl[i].id) { 264 memcpy(qc, &(radio_qctrl[i]), sizeof(*qc)); 265 return 0; 266 } 267 } 268 return -EINVAL; 269 } 270 271 static int vidioc_g_ctrl(struct file *file, void *priv, 272 struct v4l2_control *ctrl) 273 { 274 struct terratec *tt = video_drvdata(file); 275 276 switch (ctrl->id) { 277 case V4L2_CID_AUDIO_MUTE: 278 if (tt->muted) 279 ctrl->value = 1; 280 else 281 ctrl->value = 0; 282 return 0; 283 case V4L2_CID_AUDIO_VOLUME: 284 ctrl->value = tt->curvol * 6554; 285 return 0; 286 } 287 return -EINVAL; 288 } 289 290 static int vidioc_s_ctrl(struct file *file, void *priv, 291 struct v4l2_control *ctrl) 292 { 293 struct terratec *tt = video_drvdata(file); 294 295 switch (ctrl->id) { 296 case V4L2_CID_AUDIO_MUTE: 297 if (ctrl->value) 298 tt_mute(tt); 299 else 300 tt_setvol(tt,tt->curvol); 301 return 0; 302 case V4L2_CID_AUDIO_VOLUME: 303 tt_setvol(tt,ctrl->value); 304 return 0; 305 } 306 return -EINVAL; 307 } 308 309 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i) 310 { 311 *i = 0; 312 return 0; 313 } 314 315 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i) 316 { 317 return i ? -EINVAL : 0; 318 } 319 320 static int vidioc_g_audio(struct file *file, void *priv, 321 struct v4l2_audio *a) 322 { 323 a->index = 0; 324 strlcpy(a->name, "Radio", sizeof(a->name)); 325 a->capability = V4L2_AUDCAP_STEREO; 326 return 0; 327 } 328 329 static int vidioc_s_audio(struct file *file, void *priv, 330 struct v4l2_audio *a) 331 { 332 return a->index ? -EINVAL : 0; 333 } 334 335 static int terratec_open(struct file *file) 336 { 337 return 0; 338 } 339 340 static int terratec_release(struct file *file) 341 { 342 return 0; 343 } 344 345 static const struct v4l2_file_operations terratec_fops = { 346 .owner = THIS_MODULE, 347 .open = terratec_open, 348 .release = terratec_release, 349 .ioctl = video_ioctl2, 350 }; 351 352 static const struct v4l2_ioctl_ops terratec_ioctl_ops = { 353 .vidioc_querycap = vidioc_querycap, 354 .vidioc_g_tuner = vidioc_g_tuner, 355 .vidioc_s_tuner = vidioc_s_tuner, 356 .vidioc_g_frequency = vidioc_g_frequency, 357 .vidioc_s_frequency = vidioc_s_frequency, 358 .vidioc_queryctrl = vidioc_queryctrl, 359 .vidioc_g_ctrl = vidioc_g_ctrl, 360 .vidioc_s_ctrl = vidioc_s_ctrl, 361 .vidioc_g_audio = vidioc_g_audio, 362 .vidioc_s_audio = vidioc_s_audio, 363 .vidioc_g_input = vidioc_g_input, 364 .vidioc_s_input = vidioc_s_input, 365 }; 366 367 static int __init terratec_init(void) 368 { 369 struct terratec *tt = &terratec_card; 370 struct v4l2_device *v4l2_dev = &tt->v4l2_dev; 371 int res; 372 373 strlcpy(v4l2_dev->name, "terratec", sizeof(v4l2_dev->name)); 374 tt->io = io; 375 if (tt->io == -1) { 376 v4l2_err(v4l2_dev, "you must set an I/O address with io=0x590 or 0x591\n"); 377 return -EINVAL; 378 } 379 if (!request_region(tt->io, 2, "terratec")) { 380 v4l2_err(v4l2_dev, "port 0x%x already in use\n", io); 381 return -EBUSY; 382 } 383 384 res = v4l2_device_register(NULL, v4l2_dev); 385 if (res < 0) { 386 release_region(tt->io, 2); 387 v4l2_err(v4l2_dev, "Could not register v4l2_device\n"); 388 return res; 389 } 390 391 strlcpy(tt->vdev.name, v4l2_dev->name, sizeof(tt->vdev.name)); 392 tt->vdev.v4l2_dev = v4l2_dev; 393 tt->vdev.fops = &terratec_fops; 394 tt->vdev.ioctl_ops = &terratec_ioctl_ops; 395 tt->vdev.release = video_device_release_empty; 396 video_set_drvdata(&tt->vdev, tt); 397 398 mutex_init(&tt->lock); 399 400 if (video_register_device(&tt->vdev, VFL_TYPE_RADIO, radio_nr) < 0) { 401 v4l2_device_unregister(&tt->v4l2_dev); 402 release_region(tt->io, 2); 403 return -EINVAL; 404 } 405 406 v4l2_info(v4l2_dev, "TERRATEC ActivRadio Standalone card driver.\n"); 407 408 /* mute card - prevents noisy bootups */ 409 tt_write_vol(tt, 0); 410 return 0; 411 } 412 413 static void __exit terratec_exit(void) 414 { 415 struct terratec *tt = &terratec_card; 416 struct v4l2_device *v4l2_dev = &tt->v4l2_dev; 417 418 video_unregister_device(&tt->vdev); 419 v4l2_device_unregister(&tt->v4l2_dev); 420 release_region(tt->io, 2); 421 v4l2_info(v4l2_dev, "TERRATEC ActivRadio Standalone card driver unloaded.\n"); 422 } 423 424 module_init(terratec_init); 425 module_exit(terratec_exit); 426 427