drivers/media/radio/radio-maestro.c

   1 /* Maestro PCI sound card radio driver for Linux support
   2  * (c) 2000 A. Tlalka, atlka@pg.gda.pl
   3  * Notes on the hardware
   4  *
   5  *  + Frequency control is done digitally
   6  *  + No volume control - only mute/unmute - you have to use Aux line volume
   7  *  control on Maestro card to set the volume
   8  *  + Radio status (tuned/not_tuned and stereo/mono) is valid some time after
   9  *  frequency setting (>100ms) and only when the radio is unmuted.
  10  *  version 0.02
  11  *  + io port is automatically detected - only the first radio is used
  12  *  version 0.03
  13  *  + thread access locking additions
  14  *  version 0.04
  15  * + code improvements
  16  * + VIDEO_TUNER_LOW is permanent
  17  *
  18  * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/init.h>
  23 #include <linux/ioport.h>
  24 #include <linux/delay.h>
  25 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
  26 #include <linux/pci.h>
  27 #include <linux/videodev2.h>
  28 #include <linux/io.h>
  29 #include <media/v4l2-device.h>
  30 #include <media/v4l2-ioctl.h>
  31
  32 MODULE_AUTHOR("Adam Tlalka, atlka@pg.gda.pl");
  33 MODULE_DESCRIPTION("Radio driver for the Maestro PCI sound card radio.");
  34 MODULE_LICENSE("GPL");
  35
  36 static int radio_nr = -1;
  37 module_param(radio_nr, int, 0);
  38
  39 #define RADIO_VERSION KERNEL_VERSION(0, 0, 6)
  40 #define DRIVER_VERSION  "0.06"
  41
  42 #define GPIO_DATA       0x60   /* port offset from ESS_IO_BASE */
  43
  44 #define IO_MASK         4      /* mask      register offset from GPIO_DATA
  45                                 bits 1=unmask write to given bit */
  46 #define IO_DIR          8      /* direction register offset from GPIO_DATA
  47                                 bits 0/1=read/write direction */
  48
  49 #define GPIO6           0x0040 /* mask bits for GPIO lines */
  50 #define GPIO7           0x0080
  51 #define GPIO8           0x0100
  52 #define GPIO9           0x0200
  53
  54 #define STR_DATA        GPIO6  /* radio TEA5757 pins and GPIO bits */
  55 #define STR_CLK         GPIO7
  56 #define STR_WREN        GPIO8
  57 #define STR_MOST        GPIO9
  58
  59 #define FREQ_LO          50*16000
  60 #define FREQ_HI         150*16000
  61
  62 #define FREQ_IF         171200 /* 10.7*16000   */
  63 #define FREQ_STEP       200    /* 12.5*16      */
  64
  65 #define FREQ2BITS(x)    ((((unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1))\
  66                         /(FREQ_STEP<<2))<<2) /* (x==fmhz*16*1000) -> bits */
  67
  68 #define BITS2FREQ(x)    ((x) * FREQ_STEP - FREQ_IF)
  69
  70 struct maestro {
  71         struct v4l2_device v4l2_dev;
  72         struct video_device vdev;
  73         struct pci_dev *pdev;
  74         struct mutex lock;
  75
  76         u16     io;     /* base of Maestro card radio io (GPIO_DATA)*/
  77         u16     muted;  /* VIDEO_AUDIO_MUTE */
  78         u16     stereo; /* VIDEO_TUNER_STEREO_ON */
  79         u16     tuned;  /* signal strength (0 or 0xffff) */
  80 };
  81
  82 static inline struct maestro *to_maestro(struct v4l2_device *v4l2_dev)
  83 {
  84         return container_of(v4l2_dev, struct maestro, v4l2_dev);
  85 }
  86
  87 static u32 radio_bits_get(struct maestro *dev)
  88 {
  89         u16 io = dev->io, l, rdata;
  90         u32 data = 0;
  91         u16 omask;
  92
  93         omask = inw(io + IO_MASK);
  94         outw(~(STR_CLK | STR_WREN), io + IO_MASK);
  95         outw(0, io);
  96         udelay(16);
  97
  98         for (l = 24; l--;) {
  99                 outw(STR_CLK, io);              /* HI state */
 100                 udelay(2);
 101                 if (!l)
 102                         dev->tuned = inw(io) & STR_MOST ? 0 : 0xffff;
 103                 outw(0, io);                    /* LO state */
 104                 udelay(2);
 105                 data <<= 1;                     /* shift data */
 106                 rdata = inw(io);
 107                 if (!l)
 108                         dev->stereo = (rdata & STR_MOST) ?  0 : 1;
 109                 else if (rdata & STR_DATA)
 110                         data++;
 111                 udelay(2);
 112         }
 113
 114         if (dev->muted)
 115                 outw(STR_WREN, io);
 116
 117         udelay(4);
 118         outw(omask, io + IO_MASK);
 119
 120         return data & 0x3ffe;
 121 }
 122
 123 static void radio_bits_set(struct maestro *dev, u32 data)
 124 {
 125         u16 io = dev->io, l, bits;
 126         u16 omask, odir;
 127
 128         omask = inw(io + IO_MASK);
 129         odir = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
 130         outw(odir | STR_DATA, io + IO_DIR);
 131         outw(~(STR_DATA | STR_CLK | STR_WREN), io + IO_MASK);
 132         udelay(16);
 133         for (l = 25; l; l--) {
 134                 bits = ((data >> 18) & STR_DATA) | STR_WREN;
 135                 data <<= 1;                     /* shift data */
 136                 outw(bits, io);                 /* start strobe */
 137                 udelay(2);
 138                 outw(bits | STR_CLK, io);       /* HI level */
 139                 udelay(2);
 140                 outw(bits, io);                 /* LO level */
 141                 udelay(4);
 142         }
 143
 144         if (!dev->muted)
 145                 outw(0, io);
 146
 147         udelay(4);
 148         outw(omask, io + IO_MASK);
 149         outw(odir, io + IO_DIR);
 150         msleep(125);
 151 }
 152
 153 static int vidioc_querycap(struct file *file, void  *priv,
 154                                         struct v4l2_capability *v)
 155 {
 156         struct maestro *dev = video_drvdata(file);
 157
 158         strlcpy(v->driver, "radio-maestro", sizeof(v->driver));
 159         strlcpy(v->card, "Maestro Radio", sizeof(v->card));
 160         snprintf(v->bus_info, sizeof(v->bus_info), "PCI:%s", pci_name(dev->pdev));
 161         v->version = RADIO_VERSION;
 162         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
 163         return 0;
 164 }
 165
 166 static int vidioc_g_tuner(struct file *file, void *priv,
 167                                         struct v4l2_tuner *v)
 168 {
 169         struct maestro *dev = video_drvdata(file);
 170
 171         if (v->index > 0)
 172                 return -EINVAL;
 173
 174         mutex_lock(&dev->lock);
 175         radio_bits_get(dev);
 176
 177         strlcpy(v->name, "FM", sizeof(v->name));
 178         v->type = V4L2_TUNER_RADIO;
 179         v->rangelow = FREQ_LO;
 180         v->rangehigh = FREQ_HI;
 181         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 182         v->capability = V4L2_TUNER_CAP_LOW;
 183         if (dev->stereo)
 184                 v->audmode = V4L2_TUNER_MODE_STEREO;
 185         else
 186                 v->audmode = V4L2_TUNER_MODE_MONO;
 187         v->signal = dev->tuned;
 188         mutex_unlock(&dev->lock);
 189         return 0;
 190 }
 191
 192 static int vidioc_s_tuner(struct file *file, void *priv,
 193                                         struct v4l2_tuner *v)
 194 {
 195         return v->index ? -EINVAL : 0;
 196 }
 197
 198 static int vidioc_s_frequency(struct file *file, void *priv,
 199                                         struct v4l2_frequency *f)
 200 {
 201         struct maestro *dev = video_drvdata(file);
 202
 203         if (f->frequency < FREQ_LO || f->frequency > FREQ_HI)
 204                 return -EINVAL;
 205         mutex_lock(&dev->lock);
 206         radio_bits_set(dev, FREQ2BITS(f->frequency));
 207         mutex_unlock(&dev->lock);
 208         return 0;
 209 }
 210
 211 static int vidioc_g_frequency(struct file *file, void *priv,
 212                                         struct v4l2_frequency *f)
 213 {
 214         struct maestro *dev = video_drvdata(file);
 215
 216         f->type = V4L2_TUNER_RADIO;
 217         mutex_lock(&dev->lock);
 218         f->frequency = BITS2FREQ(radio_bits_get(dev));
 219         mutex_unlock(&dev->lock);
 220         return 0;
 221 }
 222
 223 static int vidioc_queryctrl(struct file *file, void *priv,
 224                                         struct v4l2_queryctrl *qc)
 225 {
 226         switch (qc->id) {
 227         case V4L2_CID_AUDIO_MUTE:
 228                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
 229         }
 230         return -EINVAL;
 231 }
 232
 233 static int vidioc_g_ctrl(struct file *file, void *priv,
 234                                         struct v4l2_control *ctrl)
 235 {
 236         struct maestro *dev = video_drvdata(file);
 237
 238         switch (ctrl->id) {
 239         case V4L2_CID_AUDIO_MUTE:
 240                 ctrl->value = dev->muted;
 241                 return 0;
 242         }
 243         return -EINVAL;
 244 }
 245
 246 static int vidioc_s_ctrl(struct file *file, void *priv,
 247                                         struct v4l2_control *ctrl)
 248 {
 249         struct maestro *dev = video_drvdata(file);
 250         u16 io = dev->io;
 251         u16 omask;
 252
 253         switch (ctrl->id) {
 254         case V4L2_CID_AUDIO_MUTE:
 255                 mutex_lock(&dev->lock);
 256                 omask = inw(io + IO_MASK);
 257                 outw(~STR_WREN, io + IO_MASK);
 258                 dev->muted = ctrl->value;
 259                 outw(dev->muted ? STR_WREN : 0, io);
 260                 udelay(4);
 261                 outw(omask, io + IO_MASK);
 262                 msleep(125);
 263                 mutex_unlock(&dev->lock);
 264                 return 0;
 265         }
 266         return -EINVAL;
 267 }
 268
 269 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 270 {
 271         *i = 0;
 272         return 0;
 273 }
 274
 275 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 276 {
 277         return i ? -EINVAL : 0;
 278 }
 279
 280 static int vidioc_g_audio(struct file *file, void *priv,
 281                                         struct v4l2_audio *a)
 282 {
 283         a->index = 0;
 284         strlcpy(a->name, "Radio", sizeof(a->name));
 285         a->capability = V4L2_AUDCAP_STEREO;
 286         return 0;
 287 }
 288
 289 static int vidioc_s_audio(struct file *file, void *priv,
 290                                         struct v4l2_audio *a)
 291 {
 292         return a->index ? -EINVAL : 0;
 293 }
 294
 295 static int maestro_open(struct file *file)
 296 {
 297         return 0;
 298 }
 299
 300 static int maestro_release(struct file *file)
 301 {
 302         return 0;
 303 }
 304
 305 static const struct v4l2_file_operations maestro_fops = {
 306         .owner          = THIS_MODULE,
 307         .open           = maestro_open,
 308         .release        = maestro_release,
 309         .ioctl          = video_ioctl2,
 310 };
 311
 312 static const struct v4l2_ioctl_ops maestro_ioctl_ops = {
 313         .vidioc_querycap    = vidioc_querycap,
 314         .vidioc_g_tuner     = vidioc_g_tuner,
 315         .vidioc_s_tuner     = vidioc_s_tuner,
 316         .vidioc_g_audio     = vidioc_g_audio,
 317         .vidioc_s_audio     = vidioc_s_audio,
 318         .vidioc_g_input     = vidioc_g_input,
 319         .vidioc_s_input     = vidioc_s_input,
 320         .vidioc_g_frequency = vidioc_g_frequency,
 321         .vidioc_s_frequency = vidioc_s_frequency,
 322         .vidioc_queryctrl   = vidioc_queryctrl,
 323         .vidioc_g_ctrl      = vidioc_g_ctrl,
 324         .vidioc_s_ctrl      = vidioc_s_ctrl,
 325 };
 326
 327 static u16 __devinit radio_power_on(struct maestro *dev)
 328 {
 329         register u16 io = dev->io;
 330         register u32 ofreq;
 331         u16 omask, odir;
 332
 333         omask = inw(io + IO_MASK);
 334         odir = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
 335         outw(odir & ~STR_WREN, io + IO_DIR);
 336         dev->muted = inw(io) & STR_WREN ? 0 : 1;
 337         outw(odir, io + IO_DIR);
 338         outw(~(STR_WREN | STR_CLK), io + IO_MASK);
 339         outw(dev->muted ? 0 : STR_WREN, io);
 340         udelay(16);
 341         outw(omask, io + IO_MASK);
 342         ofreq = radio_bits_get(dev);
 343
 344         if ((ofreq < FREQ2BITS(FREQ_LO)) || (ofreq > FREQ2BITS(FREQ_HI)))
 345                 ofreq = FREQ2BITS(FREQ_LO);
 346         radio_bits_set(dev, ofreq);
 347
 348         return (ofreq == radio_bits_get(dev));
 349 }
 350
 351 static int __devinit maestro_probe(struct pci_dev *pdev,
 352         const struct pci_device_id *ent)
 353 {
 354         struct maestro *dev;
 355         struct v4l2_device *v4l2_dev;
 356         int retval;
 357
 358         retval = pci_enable_device(pdev);
 359         if (retval) {
 360                 dev_err(&pdev->dev, "enabling pci device failed!\n");
 361                 goto err;
 362         }
 363
 364         retval = -ENOMEM;
 365
 366         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 367         if (dev == NULL) {
 368                 dev_err(&pdev->dev, "not enough memory\n");
 369                 goto err;
 370         }
 371
 372         v4l2_dev = &dev->v4l2_dev;
 373         mutex_init(&dev->lock);
 374         dev->pdev = pdev;
 375
 376         strlcpy(v4l2_dev->name, "maestro", sizeof(v4l2_dev->name));
 377
 378         retval = v4l2_device_register(&pdev->dev, v4l2_dev);
 379         if (retval < 0) {
 380                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
 381                 goto errfr;
 382         }
 383
 384         dev->io = pci_resource_start(pdev, 0) + GPIO_DATA;
 385
 386         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
 387         dev->vdev.v4l2_dev = v4l2_dev;
 388         dev->vdev.fops = &maestro_fops;
 389         dev->vdev.ioctl_ops = &maestro_ioctl_ops;
 390         dev->vdev.release = video_device_release_empty;
 391         video_set_drvdata(&dev->vdev, dev);
 392
 393         retval = video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr);
 394         if (retval) {
 395                 v4l2_err(v4l2_dev, "can't register video device!\n");
 396                 goto errfr1;
 397         }
 398
 399         if (!radio_power_on(dev)) {
 400                 retval = -EIO;
 401                 goto errunr;
 402         }
 403
 404         v4l2_info(v4l2_dev, "version " DRIVER_VERSION "\n");
 405
 406         return 0;
 407 errunr:
 408         video_unregister_device(&dev->vdev);
 409 errfr1:
 410         v4l2_device_unregister(v4l2_dev);
 411 errfr:
 412         kfree(dev);
 413 err:
 414         return retval;
 415
 416 }
 417
 418 static void __devexit maestro_remove(struct pci_dev *pdev)
 419 {
 420         struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
 421         struct maestro *dev = to_maestro(v4l2_dev);
 422
 423         video_unregister_device(&dev->vdev);
 424         v4l2_device_unregister(&dev->v4l2_dev);
 425 }
 426
 427 static struct pci_device_id maestro_r_pci_tbl[] = {
 428         { PCI_DEVICE(PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ESS1968),
 429                 .class = PCI_CLASS_MULTIMEDIA_AUDIO << 8,
 430                 .class_mask = 0xffff00 },
 431         { PCI_DEVICE(PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ESS1978),
 432                 .class = PCI_CLASS_MULTIMEDIA_AUDIO << 8,
 433                 .class_mask = 0xffff00 },
 434         { 0 }
 435 };
 436 MODULE_DEVICE_TABLE(pci, maestro_r_pci_tbl);
 437
 438 static struct pci_driver maestro_r_driver = {
 439         .name           = "maestro_radio",
 440         .id_table       = maestro_r_pci_tbl,
 441         .probe          = maestro_probe,
 442         .remove         = __devexit_p(maestro_remove),
 443 };
 444
 445 static int __init maestro_radio_init(void)
 446 {
 447         int retval = pci_register_driver(&maestro_r_driver);
 448
 449         if (retval)
 450                 printk(KERN_ERR "error during registration pci driver\n");
 451
 452         return retval;
 453 }
 454
 455 static void __exit maestro_radio_exit(void)
 456 {
 457         pci_unregister_driver(&maestro_r_driver);
 458 }
 459
 460 module_init(maestro_radio_init);
 461 module_exit(maestro_radio_exit);