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