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