drivers/media/radio/radio-zoltrix.c

   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         .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         strlcpy(zol->vdev.name, v4l2_dev->name, sizeof(zol->vdev.name));
 428         zol->vdev.v4l2_dev = v4l2_dev;
 429         zol->vdev.fops = &zoltrix_fops;
 430         zol->vdev.ioctl_ops = &zoltrix_ioctl_ops;
 431         zol->vdev.release = video_device_release_empty;
 432         video_set_drvdata(&zol->vdev, zol);
 433
 434         if (video_register_device(&zol->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
 435                 v4l2_device_unregister(v4l2_dev);
 436                 release_region(zol->io, 2);
 437                 return -EINVAL;
 438         }
 439         v4l2_info(v4l2_dev, "Zoltrix Radio Plus card driver.\n");
 440
 441         mutex_init(&zol->lock);
 442
 443         /* mute card - prevents noisy bootups */
 444
 445         /* this ensures that the volume is all the way down  */
 446
 447         outb(0, zol->io);
 448         outb(0, zol->io);
 449         msleep(20);
 450         inb(zol->io + 3);
 451
 452         zol->curvol = 0;
 453         zol->stereo = 1;
 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