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->tuner != 0 || f->type != V4L2_TUNER_RADIO)
 204                 return -EINVAL;
 205         if (f->frequency < FREQ_LO || f->frequency > FREQ_HI)
 206                 return -EINVAL;
 207         mutex_lock(&dev->lock);
 208         radio_bits_set(dev, FREQ2BITS(f->frequency));
 209         mutex_unlock(&dev->lock);
 210         return 0;
 211 }
 212
 213 static int vidioc_g_frequency(struct file *file, void *priv,
 214                                         struct v4l2_frequency *f)
 215 {
 216         struct maestro *dev = video_drvdata(file);
 217
 218         if (f->tuner != 0)
 219                 return -EINVAL;
 220         f->type = V4L2_TUNER_RADIO;
 221         mutex_lock(&dev->lock);
 222         f->frequency = BITS2FREQ(radio_bits_get(dev));
 223         mutex_unlock(&dev->lock);
 224         return 0;
 225 }
 226
 227 static int vidioc_queryctrl(struct file *file, void *priv,
 228                                         struct v4l2_queryctrl *qc)
 229 {
 230         switch (qc->id) {
 231         case V4L2_CID_AUDIO_MUTE:
 232                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
 233         }
 234         return -EINVAL;
 235 }
 236
 237 static int vidioc_g_ctrl(struct file *file, void *priv,
 238                                         struct v4l2_control *ctrl)
 239 {
 240         struct maestro *dev = video_drvdata(file);
 241
 242         switch (ctrl->id) {
 243         case V4L2_CID_AUDIO_MUTE:
 244                 ctrl->value = dev->muted;
 245                 return 0;
 246         }
 247         return -EINVAL;
 248 }
 249
 250 static int vidioc_s_ctrl(struct file *file, void *priv,
 251                                         struct v4l2_control *ctrl)
 252 {
 253         struct maestro *dev = video_drvdata(file);
 254         u16 io = dev->io;
 255         u16 omask;
 256
 257         switch (ctrl->id) {
 258         case V4L2_CID_AUDIO_MUTE:
 259                 mutex_lock(&dev->lock);
 260                 omask = inw(io + IO_MASK);
 261                 outw(~STR_WREN, io + IO_MASK);
 262                 dev->muted = ctrl->value;
 263                 outw(dev->muted ? STR_WREN : 0, io);
 264                 udelay(4);
 265                 outw(omask, io + IO_MASK);
 266                 msleep(125);
 267                 mutex_unlock(&dev->lock);
 268                 return 0;
 269         }
 270         return -EINVAL;
 271 }
 272
 273 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 274 {
 275         *i = 0;
 276         return 0;
 277 }
 278
 279 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 280 {
 281         return i ? -EINVAL : 0;
 282 }
 283
 284 static int vidioc_g_audio(struct file *file, void *priv,
 285                                         struct v4l2_audio *a)
 286 {
 287         a->index = 0;
 288         strlcpy(a->name, "Radio", sizeof(a->name));
 289         a->capability = V4L2_AUDCAP_STEREO;
 290         return 0;
 291 }
 292
 293 static int vidioc_s_audio(struct file *file, void *priv,
 294                                         struct v4l2_audio *a)
 295 {
 296         return a->index ? -EINVAL : 0;
 297 }
 298
 299 static const struct v4l2_file_operations maestro_fops = {
 300         .owner          = THIS_MODULE,
 301         .ioctl          = video_ioctl2,
 302 };
 303
 304 static const struct v4l2_ioctl_ops maestro_ioctl_ops = {
 305         .vidioc_querycap    = vidioc_querycap,
 306         .vidioc_g_tuner     = vidioc_g_tuner,
 307         .vidioc_s_tuner     = vidioc_s_tuner,
 308         .vidioc_g_audio     = vidioc_g_audio,
 309         .vidioc_s_audio     = vidioc_s_audio,
 310         .vidioc_g_input     = vidioc_g_input,
 311         .vidioc_s_input     = vidioc_s_input,
 312         .vidioc_g_frequency = vidioc_g_frequency,
 313         .vidioc_s_frequency = vidioc_s_frequency,
 314         .vidioc_queryctrl   = vidioc_queryctrl,
 315         .vidioc_g_ctrl      = vidioc_g_ctrl,
 316         .vidioc_s_ctrl      = vidioc_s_ctrl,
 317 };
 318
 319 static u16 __devinit radio_power_on(struct maestro *dev)
 320 {
 321         register u16 io = dev->io;
 322         register u32 ofreq;
 323         u16 omask, odir;
 324
 325         omask = inw(io + IO_MASK);
 326         odir = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
 327         outw(odir & ~STR_WREN, io + IO_DIR);
 328         dev->muted = inw(io) & STR_WREN ? 0 : 1;
 329         outw(odir, io + IO_DIR);
 330         outw(~(STR_WREN | STR_CLK), io + IO_MASK);
 331         outw(dev->muted ? 0 : STR_WREN, io);
 332         udelay(16);
 333         outw(omask, io + IO_MASK);
 334         ofreq = radio_bits_get(dev);
 335
 336         if ((ofreq < FREQ2BITS(FREQ_LO)) || (ofreq > FREQ2BITS(FREQ_HI)))
 337                 ofreq = FREQ2BITS(FREQ_LO);
 338         radio_bits_set(dev, ofreq);
 339
 340         return (ofreq == radio_bits_get(dev));
 341 }
 342
 343 static int __devinit maestro_probe(struct pci_dev *pdev,
 344         const struct pci_device_id *ent)
 345 {
 346         struct maestro *dev;
 347         struct v4l2_device *v4l2_dev;
 348         int retval;
 349
 350         retval = pci_enable_device(pdev);
 351         if (retval) {
 352                 dev_err(&pdev->dev, "enabling pci device failed!\n");
 353                 goto err;
 354         }
 355
 356         retval = -ENOMEM;
 357
 358         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 359         if (dev == NULL) {
 360                 dev_err(&pdev->dev, "not enough memory\n");
 361                 goto err;
 362         }
 363
 364         v4l2_dev = &dev->v4l2_dev;
 365         mutex_init(&dev->lock);
 366         dev->pdev = pdev;
 367
 368         strlcpy(v4l2_dev->name, "maestro", sizeof(v4l2_dev->name));
 369
 370         retval = v4l2_device_register(&pdev->dev, v4l2_dev);
 371         if (retval < 0) {
 372                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
 373                 goto errfr;
 374         }
 375
 376         dev->io = pci_resource_start(pdev, 0) + GPIO_DATA;
 377
 378         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
 379         dev->vdev.v4l2_dev = v4l2_dev;
 380         dev->vdev.fops = &maestro_fops;
 381         dev->vdev.ioctl_ops = &maestro_ioctl_ops;
 382         dev->vdev.release = video_device_release_empty;
 383         video_set_drvdata(&dev->vdev, dev);
 384
 385         retval = video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr);
 386         if (retval) {
 387                 v4l2_err(v4l2_dev, "can't register video device!\n");
 388                 goto errfr1;
 389         }
 390
 391         if (!radio_power_on(dev)) {
 392                 retval = -EIO;
 393                 goto errunr;
 394         }
 395
 396         v4l2_info(v4l2_dev, "version " DRIVER_VERSION "\n");
 397
 398         return 0;
 399 errunr:
 400         video_unregister_device(&dev->vdev);
 401 errfr1:
 402         v4l2_device_unregister(v4l2_dev);
 403 errfr:
 404         kfree(dev);
 405 err:
 406         return retval;
 407
 408 }
 409
 410 static void __devexit maestro_remove(struct pci_dev *pdev)
 411 {
 412         struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
 413         struct maestro *dev = to_maestro(v4l2_dev);
 414
 415         video_unregister_device(&dev->vdev);
 416         v4l2_device_unregister(&dev->v4l2_dev);
 417 }
 418
 419 static struct pci_device_id maestro_r_pci_tbl[] = {
 420         { PCI_DEVICE(PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ESS1968),
 421                 .class = PCI_CLASS_MULTIMEDIA_AUDIO << 8,
 422                 .class_mask = 0xffff00 },
 423         { PCI_DEVICE(PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ESS1978),
 424                 .class = PCI_CLASS_MULTIMEDIA_AUDIO << 8,
 425                 .class_mask = 0xffff00 },
 426         { 0 }
 427 };
 428 MODULE_DEVICE_TABLE(pci, maestro_r_pci_tbl);
 429
 430 static struct pci_driver maestro_r_driver = {
 431         .name           = "maestro_radio",
 432         .id_table       = maestro_r_pci_tbl,
 433         .probe          = maestro_probe,
 434         .remove         = __devexit_p(maestro_remove),
 435 };
 436
 437 static int __init maestro_radio_init(void)
 438 {
 439         int retval = pci_register_driver(&maestro_r_driver);
 440
 441         if (retval)
 442                 printk(KERN_ERR "error during registration pci driver\n");
 443
 444         return retval;
 445 }
 446
 447 static void __exit maestro_radio_exit(void)
 448 {
 449         pci_unregister_driver(&maestro_r_driver);
 450 }
 451
 452 module_init(maestro_radio_init);
 453 module_exit(maestro_radio_exit);