drivers/media/radio/radio-sf16fmr2.c

   1 /* SF16FMR2 radio driver for Linux radio support
   2  * heavily based on fmi driver...
   3  * (c) 2000-2002 Ziglio Frediano, freddy77@angelfire.com
   4  *
   5  * Notes on the hardware
   6  *
   7  *  Frequency control is done digitally -- ie out(port,encodefreq(95.8));
   8  *  No volume control - only mute/unmute - you have to use line volume
   9  *
  10  *  For read stereo/mono you must wait 0.1 sec after set frequency and
  11  *  card unmuted so I set frequency on unmute
  12  *  Signal handling seem to work only on autoscanning (not implemented)
  13  *
  14  *  Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
  15  */
  16
  17 #include <linux/module.h>       /* Modules                      */
  18 #include <linux/init.h>         /* Initdata                     */
  19 #include <linux/ioport.h>       /* request_region               */
  20 #include <linux/delay.h>        /* udelay                       */
  21 #include <asm/io.h>             /* outb, outb_p                 */
  22 #include <asm/uaccess.h>        /* copy to/from user            */
  23 #include <linux/videodev2.h>    /* kernel radio structs         */
  24 #include <media/v4l2-common.h>
  25 #include <media/v4l2-ioctl.h>
  26 #include <linux/mutex.h>
  27
  28 static struct mutex lock;
  29
  30 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
  31 #define RADIO_VERSION KERNEL_VERSION(0,0,2)
  32
  33 #define AUD_VOL_INDEX 1
  34
  35 static struct v4l2_queryctrl radio_qctrl[] = {
  36         {
  37                 .id            = V4L2_CID_AUDIO_MUTE,
  38                 .name          = "Mute",
  39                 .minimum       = 0,
  40                 .maximum       = 1,
  41                 .default_value = 1,
  42                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
  43         },
  44         [AUD_VOL_INDEX] = {
  45                 .id            = V4L2_CID_AUDIO_VOLUME,
  46                 .name          = "Volume",
  47                 .minimum       = 0,
  48                 .maximum       = 15,
  49                 .step          = 1,
  50                 .default_value = 0,
  51                 .type          = V4L2_CTRL_TYPE_INTEGER,
  52         }
  53 };
  54
  55 #undef DEBUG
  56 //#define DEBUG 1
  57
  58 #ifdef DEBUG
  59 # define  debug_print(s) printk s
  60 #else
  61 # define  debug_print(s)
  62 #endif
  63
  64 /* this should be static vars for module size */
  65 struct fmr2_device
  66 {
  67         int port;
  68         int curvol; /* 0-15 */
  69         int mute;
  70         int stereo; /* card is producing stereo audio */
  71         unsigned long curfreq; /* freq in kHz */
  72         int card_type;
  73         __u32 flags;
  74 };
  75
  76 static int io = 0x384;
  77 static int radio_nr = -1;
  78
  79 /* hw precision is 12.5 kHz
  80  * It is only useful to give freq in intervall of 200 (=0.0125Mhz),
  81  * other bits will be truncated
  82  */
  83 #define RSF16_ENCODE(x) ((x)/200+856)
  84 #define RSF16_MINFREQ 87*16000
  85 #define RSF16_MAXFREQ 108*16000
  86
  87 static inline void wait(int n,int port)
  88 {
  89         for (;n;--n) inb(port);
  90 }
  91
  92 static void outbits(int bits, unsigned int data, int nWait, int port)
  93 {
  94         int bit;
  95         for(;--bits>=0;) {
  96                 bit = (data>>bits) & 1;
  97                 outb(bit,port);
  98                 wait(nWait,port);
  99                 outb(bit|2,port);
 100                 wait(nWait,port);
 101                 outb(bit,port);
 102                 wait(nWait,port);
 103         }
 104 }
 105
 106 static inline void fmr2_mute(int port)
 107 {
 108         outb(0x00, port);
 109         wait(4,port);
 110 }
 111
 112 static inline void fmr2_unmute(int port)
 113 {
 114         outb(0x04, port);
 115         wait(4,port);
 116 }
 117
 118 static inline int fmr2_stereo_mode(int port)
 119 {
 120         int n = inb(port);
 121         outb(6,port);
 122         inb(port);
 123         n = ((n>>3)&1)^1;
 124         debug_print((KERN_DEBUG "stereo: %d\n", n));
 125         return n;
 126 }
 127
 128 static int fmr2_product_info(struct fmr2_device *dev)
 129 {
 130         int n = inb(dev->port);
 131         n &= 0xC1;
 132         if (n == 0)
 133         {
 134                 /* this should support volume set */
 135                 dev->card_type = 12;
 136                 return 0;
 137         }
 138         /* not volume (mine is 11) */
 139         dev->card_type = (n==128)?11:0;
 140         return n;
 141 }
 142
 143 static inline int fmr2_getsigstr(struct fmr2_device *dev)
 144 {
 145         /* !!! work only if scanning freq */
 146         int port = dev->port, res = 0xffff;
 147         outb(5,port);
 148         wait(4,port);
 149         if (!(inb(port)&1)) res = 0;
 150         debug_print((KERN_DEBUG "signal: %d\n", res));
 151         return res;
 152 }
 153
 154 /* set frequency and unmute card */
 155 static int fmr2_setfreq(struct fmr2_device *dev)
 156 {
 157         int port = dev->port;
 158         unsigned long freq = dev->curfreq;
 159
 160         fmr2_mute(port);
 161
 162         /* 0x42 for mono output
 163          * 0x102 forward scanning
 164          * 0x182 scansione avanti
 165          */
 166         outbits(9,0x2,3,port);
 167         outbits(16,RSF16_ENCODE(freq),2,port);
 168
 169         fmr2_unmute(port);
 170
 171         /* wait 0.11 sec */
 172         msleep(110);
 173
 174         /* NOTE if mute this stop radio
 175            you must set freq on unmute */
 176         dev->stereo = fmr2_stereo_mode(port);
 177         return 0;
 178 }
 179
 180 /* !!! not tested, in my card this does't work !!! */
 181 static int fmr2_setvolume(struct fmr2_device *dev)
 182 {
 183         int vol[16] = { 0x021, 0x084, 0x090, 0x104,
 184                         0x110, 0x204, 0x210, 0x402,
 185                         0x404, 0x408, 0x410, 0x801,
 186                         0x802, 0x804, 0x808, 0x810 };
 187         int i, a, port = dev->port;
 188         int n = vol[dev->curvol & 0x0f];
 189
 190         if (dev->card_type != 11)
 191                 return 1;
 192
 193         for (i = 12; --i >= 0; ) {
 194                 a = ((n >> i) & 1) << 6; /* if (a=0) a= 0; else a= 0x40; */
 195                 outb(a | 4, port);
 196                 wait(4, port);
 197                 outb(a | 0x24, port);
 198                 wait(4, port);
 199                 outb(a | 4, port);
 200                 wait(4, port);
 201         }
 202         for (i = 6; --i >= 0; ) {
 203                 a = ((0x18 >> i) & 1) << 6;
 204                 outb(a | 4, port);
 205                 wait(4,port);
 206                 outb(a | 0x24, port);
 207                 wait(4,port);
 208                 outb(a|4, port);
 209                 wait(4,port);
 210         }
 211         wait(4, port);
 212         outb(0x14, port);
 213
 214         return 0;
 215 }
 216
 217 static int vidioc_querycap(struct file *file, void  *priv,
 218                                         struct v4l2_capability *v)
 219 {
 220         strlcpy(v->driver, "radio-sf16fmr2", sizeof(v->driver));
 221         strlcpy(v->card, "SF16-FMR2 radio", sizeof(v->card));
 222         sprintf(v->bus_info, "ISA");
 223         v->version = RADIO_VERSION;
 224         v->capabilities = V4L2_CAP_TUNER;
 225         return 0;
 226 }
 227
 228 static int vidioc_g_tuner(struct file *file, void *priv,
 229                                         struct v4l2_tuner *v)
 230 {
 231         int mult;
 232         struct video_device *dev = video_devdata(file);
 233         struct fmr2_device *fmr2 = dev->priv;
 234
 235         if (v->index > 0)
 236                 return -EINVAL;
 237
 238         strcpy(v->name, "FM");
 239         v->type = V4L2_TUNER_RADIO;
 240
 241         mult = (fmr2->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000;
 242         v->rangelow = RSF16_MINFREQ/mult;
 243         v->rangehigh = RSF16_MAXFREQ/mult;
 244         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_MODE_STEREO;
 245         v->capability = fmr2->flags&V4L2_TUNER_CAP_LOW;
 246         v->audmode = fmr2->stereo ? V4L2_TUNER_MODE_STEREO:
 247                                 V4L2_TUNER_MODE_MONO;
 248         mutex_lock(&lock);
 249         v->signal = fmr2_getsigstr(fmr2);
 250         mutex_unlock(&lock);
 251         return 0;
 252 }
 253
 254 static int vidioc_s_tuner(struct file *file, void *priv,
 255                                         struct v4l2_tuner *v)
 256 {
 257         if (v->index > 0)
 258                 return -EINVAL;
 259         return 0;
 260 }
 261
 262 static int vidioc_s_frequency(struct file *file, void *priv,
 263                                         struct v4l2_frequency *f)
 264 {
 265         struct video_device *dev = video_devdata(file);
 266         struct fmr2_device *fmr2 = dev->priv;
 267
 268         if (!(fmr2->flags & V4L2_TUNER_CAP_LOW))
 269                 f->frequency *= 1000;
 270         if (f->frequency < RSF16_MINFREQ ||
 271                         f->frequency > RSF16_MAXFREQ )
 272                 return -EINVAL;
 273         /*rounding in steps of 200 to match th freq
 274         that will be used */
 275         fmr2->curfreq = (f->frequency/200)*200;
 276
 277         /* set card freq (if not muted) */
 278         if (fmr2->curvol && !fmr2->mute) {
 279                 mutex_lock(&lock);
 280                 fmr2_setfreq(fmr2);
 281                 mutex_unlock(&lock);
 282         }
 283         return 0;
 284 }
 285
 286 static int vidioc_g_frequency(struct file *file, void *priv,
 287                                         struct v4l2_frequency *f)
 288 {
 289         struct video_device *dev = video_devdata(file);
 290         struct fmr2_device *fmr2 = dev->priv;
 291
 292         f->type = V4L2_TUNER_RADIO;
 293         f->frequency = fmr2->curfreq;
 294         if (!(fmr2->flags & V4L2_TUNER_CAP_LOW))
 295                 f->frequency /= 1000;
 296         return 0;
 297 }
 298
 299 static int vidioc_queryctrl(struct file *file, void *priv,
 300                                         struct v4l2_queryctrl *qc)
 301 {
 302         int i;
 303
 304         for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
 305                 if (qc->id && qc->id == radio_qctrl[i].id) {
 306                         memcpy(qc, &radio_qctrl[i], sizeof(*qc));
 307                         return 0;
 308                 }
 309         }
 310         return -EINVAL;
 311 }
 312
 313 static int vidioc_g_ctrl(struct file *file, void *priv,
 314                                         struct v4l2_control *ctrl)
 315 {
 316         struct video_device *dev = video_devdata(file);
 317         struct fmr2_device *fmr2 = dev->priv;
 318
 319         switch (ctrl->id) {
 320         case V4L2_CID_AUDIO_MUTE:
 321                 ctrl->value = fmr2->mute;
 322                 return 0;
 323         case V4L2_CID_AUDIO_VOLUME:
 324                 ctrl->value = fmr2->curvol;
 325                 return 0;
 326         }
 327         return -EINVAL;
 328 }
 329
 330 static int vidioc_s_ctrl(struct file *file, void *priv,
 331                                         struct v4l2_control *ctrl)
 332 {
 333         struct video_device *dev = video_devdata(file);
 334         struct fmr2_device *fmr2 = dev->priv;
 335
 336         switch (ctrl->id) {
 337         case V4L2_CID_AUDIO_MUTE:
 338                 fmr2->mute = ctrl->value;
 339                 break;
 340         case V4L2_CID_AUDIO_VOLUME:
 341                 if (ctrl->value > radio_qctrl[AUD_VOL_INDEX].maximum)
 342                         fmr2->curvol = radio_qctrl[AUD_VOL_INDEX].maximum;
 343                 else
 344                         fmr2->curvol = ctrl->value;
 345
 346                 break;
 347         default:
 348                 return -EINVAL;
 349         }
 350
 351 #ifdef DEBUG
 352         if (fmr2->curvol && !fmr2->mute)
 353                 printk(KERN_DEBUG "unmute\n");
 354         else
 355                 printk(KERN_DEBUG "mute\n");
 356 #endif
 357
 358         mutex_lock(&lock);
 359         if (fmr2->curvol && !fmr2->mute) {
 360                 fmr2_setvolume(fmr2);
 361                 /* Set frequency and unmute card */
 362                 fmr2_setfreq(fmr2);
 363         } else
 364                 fmr2_mute(fmr2->port);
 365         mutex_unlock(&lock);
 366         return 0;
 367 }
 368
 369 static int vidioc_g_audio(struct file *file, void *priv,
 370                                         struct v4l2_audio *a)
 371 {
 372         if (a->index > 1)
 373                 return -EINVAL;
 374
 375         strcpy(a->name, "Radio");
 376         a->capability = V4L2_AUDCAP_STEREO;
 377         return 0;
 378 }
 379
 380 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 381 {
 382         *i = 0;
 383         return 0;
 384 }
 385
 386 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 387 {
 388         if (i != 0)
 389                 return -EINVAL;
 390         return 0;
 391 }
 392
 393 static int vidioc_s_audio(struct file *file, void *priv,
 394                                         struct v4l2_audio *a)
 395 {
 396         if (a->index != 0)
 397                 return -EINVAL;
 398         return 0;
 399 }
 400
 401 static struct fmr2_device fmr2_unit;
 402
 403 static const struct file_operations fmr2_fops = {
 404         .owner          = THIS_MODULE,
 405         .open           = video_exclusive_open,
 406         .release        = video_exclusive_release,
 407         .ioctl          = video_ioctl2,
 408 #ifdef CONFIG_COMPAT
 409         .compat_ioctl   = v4l_compat_ioctl32,
 410 #endif
 411         .llseek         = no_llseek,
 412 };
 413
 414 static const struct v4l2_ioctl_ops fmr2_ioctl_ops = {
 415         .vidioc_querycap    = vidioc_querycap,
 416         .vidioc_g_tuner     = vidioc_g_tuner,
 417         .vidioc_s_tuner     = vidioc_s_tuner,
 418         .vidioc_g_audio     = vidioc_g_audio,
 419         .vidioc_s_audio     = vidioc_s_audio,
 420         .vidioc_g_input     = vidioc_g_input,
 421         .vidioc_s_input     = vidioc_s_input,
 422         .vidioc_g_frequency = vidioc_g_frequency,
 423         .vidioc_s_frequency = vidioc_s_frequency,
 424         .vidioc_queryctrl   = vidioc_queryctrl,
 425         .vidioc_g_ctrl      = vidioc_g_ctrl,
 426         .vidioc_s_ctrl      = vidioc_s_ctrl,
 427 };
 428
 429 static struct video_device fmr2_radio = {
 430         .name           = "SF16FMR2 radio",
 431         .fops           = &fmr2_fops,
 432         .ioctl_ops      = &fmr2_ioctl_ops,
 433 };
 434
 435 static int __init fmr2_init(void)
 436 {
 437         fmr2_unit.port = io;
 438         fmr2_unit.curvol = 0;
 439         fmr2_unit.mute = 0;
 440         fmr2_unit.curfreq = 0;
 441         fmr2_unit.stereo = 1;
 442         fmr2_unit.flags = V4L2_TUNER_CAP_LOW;
 443         fmr2_unit.card_type = 0;
 444         fmr2_radio.priv = &fmr2_unit;
 445
 446         mutex_init(&lock);
 447
 448         if (!request_region(io, 2, "sf16fmr2")) {
 449                 printk(KERN_ERR "radio-sf16fmr2: request_region failed!\n");
 450                 return -EBUSY;
 451         }
 452
 453         if (video_register_device(&fmr2_radio, VFL_TYPE_RADIO, radio_nr) < 0) {
 454                 release_region(io, 2);
 455                 return -EINVAL;
 456         }
 457
 458         printk(KERN_INFO "SF16FMR2 radio card driver at 0x%x.\n", io);
 459         /* mute card - prevents noisy bootups */
 460         mutex_lock(&lock);
 461         fmr2_mute(io);
 462         fmr2_product_info(&fmr2_unit);
 463         mutex_unlock(&lock);
 464         debug_print((KERN_DEBUG "card_type %d\n", fmr2_unit.card_type));
 465
 466         /* Only card_type == 11 implements volume */
 467         if (fmr2_unit.card_type != 11)
 468                 radio_qctrl[AUD_VOL_INDEX].maximum = 1;
 469
 470         return 0;
 471 }
 472
 473 MODULE_AUTHOR("Ziglio Frediano, freddy77@angelfire.com");
 474 MODULE_DESCRIPTION("A driver for the SF16FMR2 radio.");
 475 MODULE_LICENSE("GPL");
 476
 477 module_param(io, int, 0);
 478 MODULE_PARM_DESC(io, "I/O address of the SF16FMR2 card (should be 0x384, if do not work try 0x284)");
 479 module_param(radio_nr, int, 0);
 480
 481 static void __exit fmr2_cleanup_module(void)
 482 {
 483         video_unregister_device(&fmr2_radio);
 484         release_region(io,2);
 485 }
 486
 487 module_init(fmr2_init);
 488 module_exit(fmr2_cleanup_module);
 489
 490 #ifndef MODULE
 491
 492 static int __init fmr2_setup_io(char *str)
 493 {
 494         get_option(&str, &io);
 495         return 1;
 496 }
 497
 498 __setup("sf16fmr2=", fmr2_setup_io);
 499
 500 #endif