drivers/media/radio/radio-gemtek-pci.c

   1 /*
   2  ***************************************************************************
   3  *
   4  *     radio-gemtek-pci.c - Gemtek PCI Radio driver
   5  *     (C) 2001 Vladimir Shebordaev <vshebordaev@mail.ru>
   6  *
   7  ***************************************************************************
   8  *
   9  *     This program is free software; you can redistribute it and/or
  10  *     modify it under the terms of the GNU General Public License as
  11  *     published by the Free Software Foundation; either version 2 of
  12  *     the License, or (at your option) any later version.
  13  *
  14  *     This program is distributed in the hope that it will be useful,
  15  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *     GNU General Public License for more details.
  18  *
  19  *     You should have received a copy of the GNU General Public
  20  *     License along with this program; if not, write to the Free
  21  *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  22  *     USA.
  23  *
  24  ***************************************************************************
  25  *
  26  *     Gemtek Corp still silently refuses to release any specifications
  27  *     of their multimedia devices, so the protocol still has to be
  28  *     reverse engineered.
  29  *
  30  *     The v4l code was inspired by Jonas Munsin's  Gemtek serial line
  31  *     radio device driver.
  32  *
  33  *     Please, let me know if this piece of code was useful :)
  34  *
  35  *     TODO: multiple device support and portability were not tested
  36  *
  37  *     Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
  38  *
  39  ***************************************************************************
  40  */
  41
  42 #include <linux/types.h>
  43 #include <linux/list.h>
  44 #include <linux/module.h>
  45 #include <linux/init.h>
  46 #include <linux/pci.h>
  47 #include <linux/videodev2.h>
  48 #include <linux/errno.h>
  49 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
  50 #include <linux/io.h>
  51 #include <media/v4l2-device.h>
  52 #include <media/v4l2-ioctl.h>
  53
  54 MODULE_AUTHOR("Vladimir Shebordaev <vshebordaev@mail.ru>");
  55 MODULE_DESCRIPTION("The video4linux driver for the Gemtek PCI Radio Card");
  56 MODULE_LICENSE("GPL");
  57
  58 static int nr_radio = -1;
  59 static int mx = 1;
  60
  61 module_param(mx, bool, 0);
  62 MODULE_PARM_DESC(mx, "single digit: 1 - turn off the turner upon module exit (default), 0 - do not");
  63 module_param(nr_radio, int, 0);
  64 MODULE_PARM_DESC(nr_radio, "video4linux device number to use");
  65
  66 #define RADIO_VERSION KERNEL_VERSION(0, 0, 2)
  67
  68 #ifndef PCI_VENDOR_ID_GEMTEK
  69 #define PCI_VENDOR_ID_GEMTEK 0x5046
  70 #endif
  71
  72 #ifndef PCI_DEVICE_ID_GEMTEK_PR103
  73 #define PCI_DEVICE_ID_GEMTEK_PR103 0x1001
  74 #endif
  75
  76 #ifndef GEMTEK_PCI_RANGE_LOW
  77 #define GEMTEK_PCI_RANGE_LOW (87*16000)
  78 #endif
  79
  80 #ifndef GEMTEK_PCI_RANGE_HIGH
  81 #define GEMTEK_PCI_RANGE_HIGH (108*16000)
  82 #endif
  83
  84 struct gemtek_pci {
  85         struct v4l2_device v4l2_dev;
  86         struct video_device vdev;
  87         struct mutex lock;
  88         struct pci_dev *pdev;
  89
  90         u32 iobase;
  91         u32 length;
  92
  93         u32 current_frequency;
  94         u8  mute;
  95 };
  96
  97 static inline struct gemtek_pci *to_gemtek_pci(struct v4l2_device *v4l2_dev)
  98 {
  99         return container_of(v4l2_dev, struct gemtek_pci, v4l2_dev);
 100 }
 101
 102 static inline u8 gemtek_pci_out(u16 value, u32 port)
 103 {
 104         outw(value, port);
 105
 106         return (u8)value;
 107 }
 108
 109 #define _b0(v) (*((u8 *)&v))
 110
 111 static void __gemtek_pci_cmd(u16 value, u32 port, u8 *last_byte, int keep)
 112 {
 113         u8 byte = *last_byte;
 114
 115         if (!value) {
 116                 if (!keep)
 117                         value = (u16)port;
 118                 byte &= 0xfd;
 119         } else
 120                 byte |= 2;
 121
 122         _b0(value) = byte;
 123         outw(value, port);
 124         byte |= 1;
 125         _b0(value) = byte;
 126         outw(value, port);
 127         byte &= 0xfe;
 128         _b0(value) = byte;
 129         outw(value, port);
 130
 131         *last_byte = byte;
 132 }
 133
 134 static inline void gemtek_pci_nil(u32 port, u8 *last_byte)
 135 {
 136         __gemtek_pci_cmd(0x00, port, last_byte, false);
 137 }
 138
 139 static inline void gemtek_pci_cmd(u16 cmd, u32 port, u8 *last_byte)
 140 {
 141         __gemtek_pci_cmd(cmd, port, last_byte, true);
 142 }
 143
 144 static void gemtek_pci_setfrequency(struct gemtek_pci *card, unsigned long frequency)
 145 {
 146         int i;
 147         u32 value = frequency / 200 + 856;
 148         u16 mask = 0x8000;
 149         u8 last_byte;
 150         u32 port = card->iobase;
 151
 152         mutex_lock(&card->lock);
 153         card->current_frequency = frequency;
 154         last_byte = gemtek_pci_out(0x06, port);
 155
 156         i = 0;
 157         do {
 158                 gemtek_pci_nil(port, &last_byte);
 159                 i++;
 160         } while (i < 9);
 161
 162         i = 0;
 163         do {
 164                 gemtek_pci_cmd(value & mask, port, &last_byte);
 165                 mask >>= 1;
 166                 i++;
 167         } while (i < 16);
 168
 169         outw(0x10, port);
 170         mutex_unlock(&card->lock);
 171 }
 172
 173
 174 static void gemtek_pci_mute(struct gemtek_pci *card)
 175 {
 176         mutex_lock(&card->lock);
 177         outb(0x1f, card->iobase);
 178         card->mute = true;
 179         mutex_unlock(&card->lock);
 180 }
 181
 182 static void gemtek_pci_unmute(struct gemtek_pci *card)
 183 {
 184         if (card->mute) {
 185                 gemtek_pci_setfrequency(card, card->current_frequency);
 186                 card->mute = false;
 187         }
 188 }
 189
 190 static int gemtek_pci_getsignal(struct gemtek_pci *card)
 191 {
 192         int sig;
 193
 194         mutex_lock(&card->lock);
 195         sig = (inb(card->iobase) & 0x08) ? 0 : 1;
 196         mutex_unlock(&card->lock);
 197         return sig;
 198 }
 199
 200 static int vidioc_querycap(struct file *file, void *priv,
 201                                         struct v4l2_capability *v)
 202 {
 203         struct gemtek_pci *card = video_drvdata(file);
 204
 205         strlcpy(v->driver, "radio-gemtek-pci", sizeof(v->driver));
 206         strlcpy(v->card, "GemTek PCI Radio", sizeof(v->card));
 207         snprintf(v->bus_info, sizeof(v->bus_info), "PCI:%s", pci_name(card->pdev));
 208         v->version = RADIO_VERSION;
 209         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
 210         return 0;
 211 }
 212
 213 static int vidioc_g_tuner(struct file *file, void *priv,
 214                                         struct v4l2_tuner *v)
 215 {
 216         struct gemtek_pci *card = video_drvdata(file);
 217
 218         if (v->index > 0)
 219                 return -EINVAL;
 220
 221         strlcpy(v->name, "FM", sizeof(v->name));
 222         v->type = V4L2_TUNER_RADIO;
 223         v->rangelow = GEMTEK_PCI_RANGE_LOW;
 224         v->rangehigh = GEMTEK_PCI_RANGE_HIGH;
 225         v->rxsubchans = V4L2_TUNER_SUB_MONO;
 226         v->capability = V4L2_TUNER_CAP_LOW;
 227         v->audmode = V4L2_TUNER_MODE_MONO;
 228         v->signal = 0xffff * gemtek_pci_getsignal(card);
 229         return 0;
 230 }
 231
 232 static int vidioc_s_tuner(struct file *file, void *priv,
 233                                         struct v4l2_tuner *v)
 234 {
 235         return v->index ? -EINVAL : 0;
 236 }
 237
 238 static int vidioc_s_frequency(struct file *file, void *priv,
 239                                         struct v4l2_frequency *f)
 240 {
 241         struct gemtek_pci *card = video_drvdata(file);
 242
 243         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
 244                 return -EINVAL;
 245         if (f->frequency < GEMTEK_PCI_RANGE_LOW ||
 246             f->frequency > GEMTEK_PCI_RANGE_HIGH)
 247                 return -EINVAL;
 248         gemtek_pci_setfrequency(card, f->frequency);
 249         card->mute = false;
 250         return 0;
 251 }
 252
 253 static int vidioc_g_frequency(struct file *file, void *priv,
 254                                         struct v4l2_frequency *f)
 255 {
 256         struct gemtek_pci *card = video_drvdata(file);
 257
 258         if (f->tuner != 0)
 259                 return -EINVAL;
 260         f->type = V4L2_TUNER_RADIO;
 261         f->frequency = card->current_frequency;
 262         return 0;
 263 }
 264
 265 static int vidioc_queryctrl(struct file *file, void *priv,
 266                                         struct v4l2_queryctrl *qc)
 267 {
 268         switch (qc->id) {
 269         case V4L2_CID_AUDIO_MUTE:
 270                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
 271         case V4L2_CID_AUDIO_VOLUME:
 272                 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535, 65535);
 273         }
 274         return -EINVAL;
 275 }
 276
 277 static int vidioc_g_ctrl(struct file *file, void *priv,
 278                                         struct v4l2_control *ctrl)
 279 {
 280         struct gemtek_pci *card = video_drvdata(file);
 281
 282         switch (ctrl->id) {
 283         case V4L2_CID_AUDIO_MUTE:
 284                 ctrl->value = card->mute;
 285                 return 0;
 286         case V4L2_CID_AUDIO_VOLUME:
 287                 if (card->mute)
 288                         ctrl->value = 0;
 289                 else
 290                         ctrl->value = 65535;
 291                 return 0;
 292         }
 293         return -EINVAL;
 294 }
 295
 296 static int vidioc_s_ctrl(struct file *file, void *priv,
 297                                         struct v4l2_control *ctrl)
 298 {
 299         struct gemtek_pci *card = video_drvdata(file);
 300
 301         switch (ctrl->id) {
 302         case V4L2_CID_AUDIO_MUTE:
 303                 if (ctrl->value)
 304                         gemtek_pci_mute(card);
 305                 else
 306                         gemtek_pci_unmute(card);
 307                 return 0;
 308         case V4L2_CID_AUDIO_VOLUME:
 309                 if (ctrl->value)
 310                         gemtek_pci_unmute(card);
 311                 else
 312                         gemtek_pci_mute(card);
 313                 return 0;
 314         }
 315         return -EINVAL;
 316 }
 317
 318 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 319 {
 320         *i = 0;
 321         return 0;
 322 }
 323
 324 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 325 {
 326         return i ? -EINVAL : 0;
 327 }
 328
 329 static int vidioc_g_audio(struct file *file, void *priv,
 330                                         struct v4l2_audio *a)
 331 {
 332         a->index = 0;
 333         strlcpy(a->name, "Radio", sizeof(a->name));
 334         a->capability = V4L2_AUDCAP_STEREO;
 335         return 0;
 336 }
 337
 338 static int vidioc_s_audio(struct file *file, void *priv,
 339                                         struct v4l2_audio *a)
 340 {
 341         return a->index ? -EINVAL : 0;
 342 }
 343
 344 enum {
 345         GEMTEK_PR103
 346 };
 347
 348 static char *card_names[] __devinitdata = {
 349         "GEMTEK_PR103"
 350 };
 351
 352 static struct pci_device_id gemtek_pci_id[] =
 353 {
 354         { PCI_VENDOR_ID_GEMTEK, PCI_DEVICE_ID_GEMTEK_PR103,
 355           PCI_ANY_ID, PCI_ANY_ID, 0, 0, GEMTEK_PR103 },
 356         { 0 }
 357 };
 358
 359 MODULE_DEVICE_TABLE(pci, gemtek_pci_id);
 360
 361 static const struct v4l2_file_operations gemtek_pci_fops = {
 362         .owner          = THIS_MODULE,
 363         .ioctl          = video_ioctl2,
 364 };
 365
 366 static const struct v4l2_ioctl_ops gemtek_pci_ioctl_ops = {
 367         .vidioc_querycap    = vidioc_querycap,
 368         .vidioc_g_tuner     = vidioc_g_tuner,
 369         .vidioc_s_tuner     = vidioc_s_tuner,
 370         .vidioc_g_audio     = vidioc_g_audio,
 371         .vidioc_s_audio     = vidioc_s_audio,
 372         .vidioc_g_input     = vidioc_g_input,
 373         .vidioc_s_input     = vidioc_s_input,
 374         .vidioc_g_frequency = vidioc_g_frequency,
 375         .vidioc_s_frequency = vidioc_s_frequency,
 376         .vidioc_queryctrl   = vidioc_queryctrl,
 377         .vidioc_g_ctrl      = vidioc_g_ctrl,
 378         .vidioc_s_ctrl      = vidioc_s_ctrl,
 379 };
 380
 381 static int __devinit gemtek_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
 382 {
 383         struct gemtek_pci *card;
 384         struct v4l2_device *v4l2_dev;
 385         int res;
 386
 387         card = kzalloc(sizeof(struct gemtek_pci), GFP_KERNEL);
 388         if (card == NULL) {
 389                 dev_err(&pdev->dev, "out of memory\n");
 390                 return -ENOMEM;
 391         }
 392
 393         v4l2_dev = &card->v4l2_dev;
 394         mutex_init(&card->lock);
 395         card->pdev = pdev;
 396
 397         strlcpy(v4l2_dev->name, "gemtek_pci", sizeof(v4l2_dev->name));
 398
 399         res = v4l2_device_register(&pdev->dev, v4l2_dev);
 400         if (res < 0) {
 401                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
 402                 kfree(card);
 403                 return res;
 404         }
 405
 406         if (pci_enable_device(pdev))
 407                 goto err_pci;
 408
 409         card->iobase = pci_resource_start(pdev, 0);
 410         card->length = pci_resource_len(pdev, 0);
 411
 412         if (request_region(card->iobase, card->length, card_names[pci_id->driver_data]) == NULL) {
 413                 v4l2_err(v4l2_dev, "i/o port already in use\n");
 414                 goto err_pci;
 415         }
 416
 417         strlcpy(card->vdev.name, v4l2_dev->name, sizeof(card->vdev.name));
 418         card->vdev.v4l2_dev = v4l2_dev;
 419         card->vdev.fops = &gemtek_pci_fops;
 420         card->vdev.ioctl_ops = &gemtek_pci_ioctl_ops;
 421         card->vdev.release = video_device_release_empty;
 422         video_set_drvdata(&card->vdev, card);
 423
 424         if (video_register_device(&card->vdev, VFL_TYPE_RADIO, nr_radio) < 0)
 425                 goto err_video;
 426
 427         gemtek_pci_mute(card);
 428
 429         v4l2_info(v4l2_dev, "Gemtek PCI Radio (rev. %d) found at 0x%04x-0x%04x.\n",
 430                 pdev->revision, card->iobase, card->iobase + card->length - 1);
 431
 432         return 0;
 433
 434 err_video:
 435         release_region(card->iobase, card->length);
 436
 437 err_pci:
 438         v4l2_device_unregister(v4l2_dev);
 439         kfree(card);
 440         return -ENODEV;
 441 }
 442
 443 static void __devexit gemtek_pci_remove(struct pci_dev *pdev)
 444 {
 445         struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
 446         struct gemtek_pci *card = to_gemtek_pci(v4l2_dev);
 447
 448         video_unregister_device(&card->vdev);
 449         v4l2_device_unregister(v4l2_dev);
 450
 451         release_region(card->iobase, card->length);
 452
 453         if (mx)
 454                 gemtek_pci_mute(card);
 455
 456         kfree(card);
 457 }
 458
 459 static struct pci_driver gemtek_pci_driver = {
 460         .name           = "gemtek_pci",
 461         .id_table       = gemtek_pci_id,
 462         .probe          = gemtek_pci_probe,
 463         .remove         = __devexit_p(gemtek_pci_remove),
 464 };
 465
 466 static int __init gemtek_pci_init(void)
 467 {
 468         return pci_register_driver(&gemtek_pci_driver);
 469 }
 470
 471 static void __exit gemtek_pci_exit(void)
 472 {
 473         pci_unregister_driver(&gemtek_pci_driver);
 474 }
 475
 476 module_init(gemtek_pci_init);
 477 module_exit(gemtek_pci_exit);