drivers/media/radio/radio-aztech.c

   1 /* radio-aztech.c - Aztech radio card driver for Linux 2.2
   2  *
   3  * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
   4  * Adapted to support the Video for Linux API by
   5  * Russell Kroll <rkroll@exploits.org>.  Based on original tuner code by:
   6  *
   7  * Quay Ly
   8  * Donald Song
   9  * Jason Lewis      (jlewis@twilight.vtc.vsc.edu)
  10  * Scott McGrath    (smcgrath@twilight.vtc.vsc.edu)
  11  * William McGrath  (wmcgrath@twilight.vtc.vsc.edu)
  12  *
  13  * The basis for this code may be found at http://bigbang.vtc.vsc.edu/fmradio/
  14  * along with more information on the card itself.
  15  *
  16  * History:
  17  * 1999-02-24   Russell Kroll <rkroll@exploits.org>
  18  *              Fine tuning/VIDEO_TUNER_LOW
  19  *              Range expanded to 87-108 MHz (from 87.9-107.8)
  20  *
  21  * Notable changes from the original source:
  22  * - includes stripped down to the essentials
  23  * - for loops used as delays replaced with udelay()
  24  * - #defines removed, changed to static values
  25  * - tuning structure changed - no more character arrays, other changes
  26 */
  27
  28 #include <linux/module.h>       /* Modules                      */
  29 #include <linux/init.h>         /* Initdata                     */
  30 #include <linux/ioport.h>       /* request_region               */
  31 #include <linux/delay.h>        /* udelay                       */
  32 #include <linux/videodev2.h>    /* kernel radio structs         */
  33 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
  34 #include <linux/io.h>           /* outb, outb_p                 */
  35 #include <linux/uaccess.h>      /* copy to/from user            */
  36 #include <media/v4l2-device.h>
  37 #include <media/v4l2-ioctl.h>
  38
  39 MODULE_AUTHOR("Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
  40 MODULE_DESCRIPTION("A driver for the Aztech radio card.");
  41 MODULE_LICENSE("GPL");
  42
  43 /* acceptable ports: 0x350 (JP3 shorted), 0x358 (JP3 open) */
  44
  45 #ifndef CONFIG_RADIO_AZTECH_PORT
  46 #define CONFIG_RADIO_AZTECH_PORT -1
  47 #endif
  48
  49 static int io = CONFIG_RADIO_AZTECH_PORT;
  50 static int radio_nr = -1;
  51 static int radio_wait_time = 1000;
  52
  53 module_param(io, int, 0);
  54 module_param(radio_nr, int, 0);
  55 MODULE_PARM_DESC(io, "I/O address of the Aztech card (0x350 or 0x358)");
  56
  57 #define RADIO_VERSION KERNEL_VERSION(0, 0, 2)
  58
  59 struct aztech
  60 {
  61         struct v4l2_device v4l2_dev;
  62         struct video_device vdev;
  63         int io;
  64         int curvol;
  65         unsigned long curfreq;
  66         int stereo;
  67         struct mutex lock;
  68 };
  69
  70 static struct aztech aztech_card;
  71
  72 static int volconvert(int level)
  73 {
  74         level >>= 14;           /* Map 16bits down to 2 bit */
  75         level &= 3;
  76
  77         /* convert to card-friendly values */
  78         switch (level) {
  79         case 0:
  80                 return 0;
  81         case 1:
  82                 return 1;
  83         case 2:
  84                 return 4;
  85         case 3:
  86                 return 5;
  87         }
  88         return 0;       /* Quieten gcc */
  89 }
  90
  91 static void send_0_byte(struct aztech *az)
  92 {
  93         udelay(radio_wait_time);
  94         outb_p(2 + volconvert(az->curvol), az->io);
  95         outb_p(64 + 2 + volconvert(az->curvol), az->io);
  96 }
  97
  98 static void send_1_byte(struct aztech *az)
  99 {
 100         udelay (radio_wait_time);
 101         outb_p(128 + 2 + volconvert(az->curvol), az->io);
 102         outb_p(128 + 64 + 2 + volconvert(az->curvol), az->io);
 103 }
 104
 105 static int az_setvol(struct aztech *az, int vol)
 106 {
 107         mutex_lock(&az->lock);
 108         outb(volconvert(vol), az->io);
 109         mutex_unlock(&az->lock);
 110         return 0;
 111 }
 112
 113 /* thanks to Michael Dwyer for giving me a dose of clues in
 114  * the signal strength department..
 115  *
 116  * This card has a stereo bit - bit 0 set = mono, not set = stereo
 117  * It also has a "signal" bit - bit 1 set = bad signal, not set = good
 118  *
 119  */
 120
 121 static int az_getsigstr(struct aztech *az)
 122 {
 123         int sig = 1;
 124
 125         mutex_lock(&az->lock);
 126         if (inb(az->io) & 2)    /* bit set = no signal present */
 127                 sig = 0;
 128         mutex_unlock(&az->lock);
 129         return sig;
 130 }
 131
 132 static int az_getstereo(struct aztech *az)
 133 {
 134         int stereo = 1;
 135
 136         mutex_lock(&az->lock);
 137         if (inb(az->io) & 1)    /* bit set = mono */
 138                 stereo = 0;
 139         mutex_unlock(&az->lock);
 140         return stereo;
 141 }
 142
 143 static int az_setfreq(struct aztech *az, unsigned long frequency)
 144 {
 145         int  i;
 146
 147         mutex_lock(&az->lock);
 148
 149         az->curfreq = frequency;
 150         frequency += 171200;            /* Add 10.7 MHz IF              */
 151         frequency /= 800;               /* Convert to 50 kHz units      */
 152
 153         send_0_byte(az);                /*  0: LSB of frequency       */
 154
 155         for (i = 0; i < 13; i++)        /*   : frequency bits (1-13)  */
 156                 if (frequency & (1 << i))
 157                         send_1_byte(az);
 158                 else
 159                         send_0_byte(az);
 160
 161         send_0_byte(az);                /* 14: test bit - always 0    */
 162         send_0_byte(az);                /* 15: test bit - always 0    */
 163         send_0_byte(az);                /* 16: band data 0 - always 0 */
 164         if (az->stereo)         /* 17: stereo (1 to enable)   */
 165                 send_1_byte(az);
 166         else
 167                 send_0_byte(az);
 168
 169         send_1_byte(az);                /* 18: band data 1 - unknown  */
 170         send_0_byte(az);                /* 19: time base - always 0   */
 171         send_0_byte(az);                /* 20: spacing (0 = 25 kHz)   */
 172         send_1_byte(az);                /* 21: spacing (1 = 25 kHz)   */
 173         send_0_byte(az);                /* 22: spacing (0 = 25 kHz)   */
 174         send_1_byte(az);                /* 23: AM/FM (FM = 1, always) */
 175
 176         /* latch frequency */
 177
 178         udelay(radio_wait_time);
 179         outb_p(128 + 64 + volconvert(az->curvol), az->io);
 180
 181         mutex_unlock(&az->lock);
 182
 183         return 0;
 184 }
 185
 186 static int vidioc_querycap(struct file *file, void  *priv,
 187                                         struct v4l2_capability *v)
 188 {
 189         strlcpy(v->driver, "radio-aztech", sizeof(v->driver));
 190         strlcpy(v->card, "Aztech Radio", sizeof(v->card));
 191         strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
 192         v->version = RADIO_VERSION;
 193         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
 194         return 0;
 195 }
 196
 197 static int vidioc_g_tuner(struct file *file, void *priv,
 198                                 struct v4l2_tuner *v)
 199 {
 200         struct aztech *az = video_drvdata(file);
 201
 202         if (v->index > 0)
 203                 return -EINVAL;
 204
 205         strlcpy(v->name, "FM", sizeof(v->name));
 206         v->type = V4L2_TUNER_RADIO;
 207
 208         v->rangelow = 87 * 16000;
 209         v->rangehigh = 108 * 16000;
 210         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 211         v->capability = V4L2_TUNER_CAP_LOW;
 212         if (az_getstereo(az))
 213                 v->audmode = V4L2_TUNER_MODE_STEREO;
 214         else
 215                 v->audmode = V4L2_TUNER_MODE_MONO;
 216         v->signal = 0xFFFF * az_getsigstr(az);
 217
 218         return 0;
 219 }
 220
 221 static int vidioc_s_tuner(struct file *file, void *priv,
 222                                 struct v4l2_tuner *v)
 223 {
 224         return v->index ? -EINVAL : 0;
 225 }
 226
 227 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 228 {
 229         *i = 0;
 230         return 0;
 231 }
 232
 233 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 234 {
 235         return i ? -EINVAL : 0;
 236 }
 237
 238 static int vidioc_g_audio(struct file *file, void *priv,
 239                            struct v4l2_audio *a)
 240 {
 241         a->index = 0;
 242         strlcpy(a->name, "Radio", sizeof(a->name));
 243         a->capability = V4L2_AUDCAP_STEREO;
 244         return 0;
 245 }
 246
 247 static int vidioc_s_audio(struct file *file, void *priv,
 248                            struct v4l2_audio *a)
 249 {
 250         return a->index ? -EINVAL : 0;
 251 }
 252
 253 static int vidioc_s_frequency(struct file *file, void *priv,
 254                                 struct v4l2_frequency *f)
 255 {
 256         struct aztech *az = video_drvdata(file);
 257
 258         az_setfreq(az, f->frequency);
 259         return 0;
 260 }
 261
 262 static int vidioc_g_frequency(struct file *file, void *priv,
 263                                 struct v4l2_frequency *f)
 264 {
 265         struct aztech *az = video_drvdata(file);
 266
 267         f->type = V4L2_TUNER_RADIO;
 268         f->frequency = az->curfreq;
 269         return 0;
 270 }
 271
 272 static int vidioc_queryctrl(struct file *file, void *priv,
 273                             struct v4l2_queryctrl *qc)
 274 {
 275         switch (qc->id) {
 276         case V4L2_CID_AUDIO_MUTE:
 277                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
 278         case V4L2_CID_AUDIO_VOLUME:
 279                 return v4l2_ctrl_query_fill(qc, 0, 0xff, 1, 0xff);
 280         }
 281         return -EINVAL;
 282 }
 283
 284 static int vidioc_g_ctrl(struct file *file, void *priv,
 285                             struct v4l2_control *ctrl)
 286 {
 287         struct aztech *az = video_drvdata(file);
 288
 289         switch (ctrl->id) {
 290         case V4L2_CID_AUDIO_MUTE:
 291                 if (az->curvol == 0)
 292                         ctrl->value = 1;
 293                 else
 294                         ctrl->value = 0;
 295                 return 0;
 296         case V4L2_CID_AUDIO_VOLUME:
 297                 ctrl->value = az->curvol * 6554;
 298                 return 0;
 299         }
 300         return -EINVAL;
 301 }
 302
 303 static int vidioc_s_ctrl(struct file *file, void *priv,
 304                             struct v4l2_control *ctrl)
 305 {
 306         struct aztech *az = video_drvdata(file);
 307
 308         switch (ctrl->id) {
 309         case V4L2_CID_AUDIO_MUTE:
 310                 if (ctrl->value)
 311                         az_setvol(az, 0);
 312                 else
 313                         az_setvol(az, az->curvol);
 314                 return 0;
 315         case V4L2_CID_AUDIO_VOLUME:
 316                 az_setvol(az, ctrl->value);
 317                 return 0;
 318         }
 319         return -EINVAL;
 320 }
 321
 322 static int aztech_open(struct file *file)
 323 {
 324         return 0;
 325 }
 326
 327 static int aztech_release(struct file *file)
 328 {
 329         return 0;
 330 }
 331
 332 static const struct v4l2_file_operations aztech_fops = {
 333         .owner          = THIS_MODULE,
 334         .open           = aztech_open,
 335         .release        = aztech_release,
 336         .ioctl          = video_ioctl2,
 337 };
 338
 339 static const struct v4l2_ioctl_ops aztech_ioctl_ops = {
 340         .vidioc_querycap    = vidioc_querycap,
 341         .vidioc_g_tuner     = vidioc_g_tuner,
 342         .vidioc_s_tuner     = vidioc_s_tuner,
 343         .vidioc_g_audio     = vidioc_g_audio,
 344         .vidioc_s_audio     = vidioc_s_audio,
 345         .vidioc_g_input     = vidioc_g_input,
 346         .vidioc_s_input     = vidioc_s_input,
 347         .vidioc_g_frequency = vidioc_g_frequency,
 348         .vidioc_s_frequency = vidioc_s_frequency,
 349         .vidioc_queryctrl   = vidioc_queryctrl,
 350         .vidioc_g_ctrl      = vidioc_g_ctrl,
 351         .vidioc_s_ctrl      = vidioc_s_ctrl,
 352 };
 353
 354 static int __init aztech_init(void)
 355 {
 356         struct aztech *az = &aztech_card;
 357         struct v4l2_device *v4l2_dev = &az->v4l2_dev;
 358         int res;
 359
 360         strlcpy(v4l2_dev->name, "aztech", sizeof(v4l2_dev->name));
 361         az->io = io;
 362
 363         if (az->io == -1) {
 364                 v4l2_err(v4l2_dev, "you must set an I/O address with io=0x???\n");
 365                 return -EINVAL;
 366         }
 367
 368         if (!request_region(az->io, 2, "aztech")) {
 369                 v4l2_err(v4l2_dev, "port 0x%x already in use\n", az->io);
 370                 return -EBUSY;
 371         }
 372
 373         res = v4l2_device_register(NULL, v4l2_dev);
 374         if (res < 0) {
 375                 release_region(az->io, 2);
 376                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
 377                 return res;
 378         }
 379
 380         mutex_init(&az->lock);
 381         strlcpy(az->vdev.name, v4l2_dev->name, sizeof(az->vdev.name));
 382         az->vdev.v4l2_dev = v4l2_dev;
 383         az->vdev.fops = &aztech_fops;
 384         az->vdev.ioctl_ops = &aztech_ioctl_ops;
 385         az->vdev.release = video_device_release_empty;
 386         video_set_drvdata(&az->vdev, az);
 387
 388         if (video_register_device(&az->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
 389                 v4l2_device_unregister(v4l2_dev);
 390                 release_region(az->io, 2);
 391                 return -EINVAL;
 392         }
 393
 394         v4l2_info(v4l2_dev, "Aztech radio card driver v1.00/19990224 rkroll@exploits.org\n");
 395         /* mute card - prevents noisy bootups */
 396         outb(0, az->io);
 397         return 0;
 398 }
 399
 400 static void __exit aztech_exit(void)
 401 {
 402         struct aztech *az = &aztech_card;
 403
 404         video_unregister_device(&az->vdev);
 405         v4l2_device_unregister(&az->v4l2_dev);
 406         release_region(az->io, 2);
 407 }
 408
 409 module_init(aztech_init);
 410 module_exit(aztech_exit);