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