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 <asm/io.h> /* outb, outb_p */ 37 #include <asm/uaccess.h> /* copy to/from user */ 38 #include <linux/videodev2.h> /* kernel radio structs */ 39 #include <media/v4l2-common.h> 40 #include <media/v4l2-ioctl.h> 41 42 #include <linux/version.h> /* for KERNEL_VERSION MACRO */ 43 #define RADIO_VERSION KERNEL_VERSION(0,0,2) 44 45 static struct v4l2_queryctrl radio_qctrl[] = { 46 { 47 .id = V4L2_CID_AUDIO_MUTE, 48 .name = "Mute", 49 .minimum = 0, 50 .maximum = 1, 51 .default_value = 1, 52 .type = V4L2_CTRL_TYPE_BOOLEAN, 53 },{ 54 .id = V4L2_CID_AUDIO_VOLUME, 55 .name = "Volume", 56 .minimum = 0, 57 .maximum = 65535, 58 .step = 4096, 59 .default_value = 0xff, 60 .type = V4L2_CTRL_TYPE_INTEGER, 61 } 62 }; 63 64 #ifndef CONFIG_RADIO_ZOLTRIX_PORT 65 #define CONFIG_RADIO_ZOLTRIX_PORT -1 66 #endif 67 68 static int io = CONFIG_RADIO_ZOLTRIX_PORT; 69 static int radio_nr = -1; 70 71 struct zol_device { 72 int port; 73 int curvol; 74 unsigned long curfreq; 75 int muted; 76 unsigned int stereo; 77 struct mutex lock; 78 }; 79 80 static int zol_setvol(struct zol_device *dev, int vol) 81 { 82 dev->curvol = vol; 83 if (dev->muted) 84 return 0; 85 86 mutex_lock(&dev->lock); 87 if (vol == 0) { 88 outb(0, io); 89 outb(0, io); 90 inb(io + 3); /* Zoltrix needs to be read to confirm */ 91 mutex_unlock(&dev->lock); 92 return 0; 93 } 94 95 outb(dev->curvol-1, io); 96 msleep(10); 97 inb(io + 2); 98 mutex_unlock(&dev->lock); 99 return 0; 100 } 101 102 static void zol_mute(struct zol_device *dev) 103 { 104 dev->muted = 1; 105 mutex_lock(&dev->lock); 106 outb(0, io); 107 outb(0, io); 108 inb(io + 3); /* Zoltrix needs to be read to confirm */ 109 mutex_unlock(&dev->lock); 110 } 111 112 static void zol_unmute(struct zol_device *dev) 113 { 114 dev->muted = 0; 115 zol_setvol(dev, dev->curvol); 116 } 117 118 static int zol_setfreq(struct zol_device *dev, unsigned long freq) 119 { 120 /* tunes the radio to the desired frequency */ 121 unsigned long long bitmask, f, m; 122 unsigned int stereo = dev->stereo; 123 int i; 124 125 if (freq == 0) 126 return 1; 127 m = (freq / 160 - 8800) * 2; 128 f = (unsigned long long) m + 0x4d1c; 129 130 bitmask = 0xc480402c10080000ull; 131 i = 45; 132 133 mutex_lock(&dev->lock); 134 135 outb(0, io); 136 outb(0, io); 137 inb(io + 3); /* Zoltrix needs to be read to confirm */ 138 139 outb(0x40, io); 140 outb(0xc0, io); 141 142 bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ ( stereo << 31)); 143 while (i--) { 144 if ((bitmask & 0x8000000000000000ull) != 0) { 145 outb(0x80, io); 146 udelay(50); 147 outb(0x00, io); 148 udelay(50); 149 outb(0x80, io); 150 udelay(50); 151 } else { 152 outb(0xc0, io); 153 udelay(50); 154 outb(0x40, io); 155 udelay(50); 156 outb(0xc0, io); 157 udelay(50); 158 } 159 bitmask *= 2; 160 } 161 /* termination sequence */ 162 outb(0x80, io); 163 outb(0xc0, io); 164 outb(0x40, io); 165 udelay(1000); 166 inb(io+2); 167 168 udelay(1000); 169 170 if (dev->muted) 171 { 172 outb(0, io); 173 outb(0, io); 174 inb(io + 3); 175 udelay(1000); 176 } 177 178 mutex_unlock(&dev->lock); 179 180 if(!dev->muted) 181 { 182 zol_setvol(dev, dev->curvol); 183 } 184 return 0; 185 } 186 187 /* Get signal strength */ 188 189 static int zol_getsigstr(struct zol_device *dev) 190 { 191 int a, b; 192 193 mutex_lock(&dev->lock); 194 outb(0x00, io); /* This stuff I found to do nothing */ 195 outb(dev->curvol, io); 196 msleep(20); 197 198 a = inb(io); 199 msleep(10); 200 b = inb(io); 201 202 mutex_unlock(&dev->lock); 203 204 if (a != b) 205 return (0); 206 207 if ((a == 0xcf) || (a == 0xdf) /* I found this out by playing */ 208 || (a == 0xef)) /* with a binary scanner on the card io */ 209 return (1); 210 return (0); 211 } 212 213 static int zol_is_stereo (struct zol_device *dev) 214 { 215 int x1, x2; 216 217 mutex_lock(&dev->lock); 218 219 outb(0x00, io); 220 outb(dev->curvol, io); 221 msleep(20); 222 223 x1 = inb(io); 224 msleep(10); 225 x2 = inb(io); 226 227 mutex_unlock(&dev->lock); 228 229 if ((x1 == x2) && (x1 == 0xcf)) 230 return 1; 231 return 0; 232 } 233 234 static int vidioc_querycap(struct file *file, void *priv, 235 struct v4l2_capability *v) 236 { 237 strlcpy(v->driver, "radio-zoltrix", sizeof(v->driver)); 238 strlcpy(v->card, "Zoltrix Radio", sizeof(v->card)); 239 sprintf(v->bus_info, "ISA"); 240 v->version = RADIO_VERSION; 241 v->capabilities = V4L2_CAP_TUNER; 242 return 0; 243 } 244 245 static int vidioc_g_tuner(struct file *file, void *priv, 246 struct v4l2_tuner *v) 247 { 248 struct video_device *dev = video_devdata(file); 249 struct zol_device *zol = dev->priv; 250 251 if (v->index > 0) 252 return -EINVAL; 253 254 strcpy(v->name, "FM"); 255 v->type = V4L2_TUNER_RADIO; 256 v->rangelow = (88*16000); 257 v->rangehigh = (108*16000); 258 v->rxsubchans = V4L2_TUNER_SUB_MONO|V4L2_TUNER_SUB_STEREO; 259 v->capability = V4L2_TUNER_CAP_LOW; 260 if (zol_is_stereo(zol)) 261 v->audmode = V4L2_TUNER_MODE_STEREO; 262 else 263 v->audmode = V4L2_TUNER_MODE_MONO; 264 v->signal = 0xFFFF*zol_getsigstr(zol); 265 return 0; 266 } 267 268 static int vidioc_s_tuner(struct file *file, void *priv, 269 struct v4l2_tuner *v) 270 { 271 if (v->index > 0) 272 return -EINVAL; 273 return 0; 274 } 275 276 static int vidioc_s_frequency(struct file *file, void *priv, 277 struct v4l2_frequency *f) 278 { 279 struct video_device *dev = video_devdata(file); 280 struct zol_device *zol = dev->priv; 281 282 zol->curfreq = f->frequency; 283 zol_setfreq(zol, zol->curfreq); 284 return 0; 285 } 286 287 static int vidioc_g_frequency(struct file *file, void *priv, 288 struct v4l2_frequency *f) 289 { 290 struct video_device *dev = video_devdata(file); 291 struct zol_device *zol = dev->priv; 292 293 f->type = V4L2_TUNER_RADIO; 294 f->frequency = zol->curfreq; 295 return 0; 296 } 297 298 static int vidioc_queryctrl(struct file *file, void *priv, 299 struct v4l2_queryctrl *qc) 300 { 301 int i; 302 303 for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) { 304 if (qc->id && qc->id == radio_qctrl[i].id) { 305 memcpy(qc, &(radio_qctrl[i]), 306 sizeof(*qc)); 307 return 0; 308 } 309 } 310 return -EINVAL; 311 } 312 313 static int vidioc_g_ctrl(struct file *file, void *priv, 314 struct v4l2_control *ctrl) 315 { 316 struct video_device *dev = video_devdata(file); 317 struct zol_device *zol = dev->priv; 318 319 switch (ctrl->id) { 320 case V4L2_CID_AUDIO_MUTE: 321 ctrl->value = zol->muted; 322 return 0; 323 case V4L2_CID_AUDIO_VOLUME: 324 ctrl->value = zol->curvol * 4096; 325 return 0; 326 } 327 return -EINVAL; 328 } 329 330 static int vidioc_s_ctrl(struct file *file, void *priv, 331 struct v4l2_control *ctrl) 332 { 333 struct video_device *dev = video_devdata(file); 334 struct zol_device *zol = dev->priv; 335 336 switch (ctrl->id) { 337 case V4L2_CID_AUDIO_MUTE: 338 if (ctrl->value) 339 zol_mute(zol); 340 else { 341 zol_unmute(zol); 342 zol_setvol(zol,zol->curvol); 343 } 344 return 0; 345 case V4L2_CID_AUDIO_VOLUME: 346 zol_setvol(zol,ctrl->value/4096); 347 return 0; 348 } 349 zol->stereo = 1; 350 zol_setfreq(zol, zol->curfreq); 351 #if 0 352 /* FIXME: Implement stereo/mono switch on V4L2 */ 353 if (v->mode & VIDEO_SOUND_STEREO) { 354 zol->stereo = 1; 355 zol_setfreq(zol, zol->curfreq); 356 } 357 if (v->mode & VIDEO_SOUND_MONO) { 358 zol->stereo = 0; 359 zol_setfreq(zol, zol->curfreq); 360 } 361 #endif 362 return -EINVAL; 363 } 364 365 static int vidioc_g_audio(struct file *file, void *priv, 366 struct v4l2_audio *a) 367 { 368 if (a->index > 1) 369 return -EINVAL; 370 371 strcpy(a->name, "Radio"); 372 a->capability = V4L2_AUDCAP_STEREO; 373 return 0; 374 } 375 376 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i) 377 { 378 *i = 0; 379 return 0; 380 } 381 382 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i) 383 { 384 if (i != 0) 385 return -EINVAL; 386 return 0; 387 } 388 389 static int vidioc_s_audio(struct file *file, void *priv, 390 struct v4l2_audio *a) 391 { 392 if (a->index != 0) 393 return -EINVAL; 394 return 0; 395 } 396 397 static struct zol_device zoltrix_unit; 398 399 static const struct file_operations zoltrix_fops = 400 { 401 .owner = THIS_MODULE, 402 .open = video_exclusive_open, 403 .release = video_exclusive_release, 404 .ioctl = video_ioctl2, 405 #ifdef CONFIG_COMPAT 406 .compat_ioctl = v4l_compat_ioctl32, 407 #endif 408 .llseek = no_llseek, 409 }; 410 411 static struct video_device zoltrix_radio = 412 { 413 .owner = THIS_MODULE, 414 .name = "Zoltrix Radio Plus", 415 .type = VID_TYPE_TUNER, 416 .fops = &zoltrix_fops, 417 .vidioc_querycap = vidioc_querycap, 418 .vidioc_g_tuner = vidioc_g_tuner, 419 .vidioc_s_tuner = vidioc_s_tuner, 420 .vidioc_g_audio = vidioc_g_audio, 421 .vidioc_s_audio = vidioc_s_audio, 422 .vidioc_g_input = vidioc_g_input, 423 .vidioc_s_input = vidioc_s_input, 424 .vidioc_g_frequency = vidioc_g_frequency, 425 .vidioc_s_frequency = vidioc_s_frequency, 426 .vidioc_queryctrl = vidioc_queryctrl, 427 .vidioc_g_ctrl = vidioc_g_ctrl, 428 .vidioc_s_ctrl = vidioc_s_ctrl, 429 }; 430 431 static int __init zoltrix_init(void) 432 { 433 if (io == -1) { 434 printk(KERN_ERR "You must set an I/O address with io=0x???\n"); 435 return -EINVAL; 436 } 437 if ((io != 0x20c) && (io != 0x30c)) { 438 printk(KERN_ERR "zoltrix: invalid port, try 0x20c or 0x30c\n"); 439 return -ENXIO; 440 } 441 442 zoltrix_radio.priv = &zoltrix_unit; 443 if (!request_region(io, 2, "zoltrix")) { 444 printk(KERN_ERR "zoltrix: port 0x%x already in use\n", io); 445 return -EBUSY; 446 } 447 448 if (video_register_device(&zoltrix_radio, VFL_TYPE_RADIO, radio_nr) == -1) 449 { 450 release_region(io, 2); 451 return -EINVAL; 452 } 453 printk(KERN_INFO "Zoltrix Radio Plus card driver.\n"); 454 455 mutex_init(&zoltrix_unit.lock); 456 457 /* mute card - prevents noisy bootups */ 458 459 /* this ensures that the volume is all the way down */ 460 461 outb(0, io); 462 outb(0, io); 463 msleep(20); 464 inb(io + 3); 465 466 zoltrix_unit.curvol = 0; 467 zoltrix_unit.stereo = 1; 468 469 return 0; 470 } 471 472 MODULE_AUTHOR("C.van Schaik"); 473 MODULE_DESCRIPTION("A driver for the Zoltrix Radio Plus."); 474 MODULE_LICENSE("GPL"); 475 476 module_param(io, int, 0); 477 MODULE_PARM_DESC(io, "I/O address of the Zoltrix Radio Plus (0x20c or 0x30c)"); 478 module_param(radio_nr, int, 0); 479 480 static void __exit zoltrix_cleanup_module(void) 481 { 482 video_unregister_device(&zoltrix_radio); 483 release_region(io, 2); 484 } 485 486 module_init(zoltrix_init); 487 module_exit(zoltrix_cleanup_module); 488 489