sound/drivers/opl3/opl3_lib.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
   4  *                   Hannu Savolainen 1993-1996,
   5  *                   Rob Hooft
   6  *
   7  *  Routines for control of AdLib FM cards (OPL2/OPL3/OPL4 chips)
   8  *
   9  *  Most if code is ported from OSS/Lite.
  10  */
  11
  12 #include <sound/opl3.h>
  13 #include <linux/io.h>
  14 #include <linux/delay.h>
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/slab.h>
  18 #include <linux/ioport.h>
  19 #include <sound/minors.h>
  20 #include "opl3_voice.h"
  21
  22 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Hannu Savolainen 1993-1996, Rob Hooft");
  23 MODULE_DESCRIPTION("Routines for control of AdLib FM cards (OPL2/OPL3/OPL4 chips)");
  24 MODULE_LICENSE("GPL");
  25
  26 static void snd_opl2_command(struct snd_opl3 * opl3, unsigned short cmd, unsigned char val)
  27 {
  28         unsigned long flags;
  29         unsigned long port;
  30
  31         /*
  32          * The original 2-OP synth requires a quite long delay
  33          * after writing to a register.
  34          */
  35
  36         port = (cmd & OPL3_RIGHT) ? opl3->r_port : opl3->l_port;
  37
  38         spin_lock_irqsave(&opl3->reg_lock, flags);
  39
  40         outb((unsigned char) cmd, port);
  41         udelay(10);
  42
  43         outb((unsigned char) val, port + 1);
  44         udelay(30);
  45
  46         spin_unlock_irqrestore(&opl3->reg_lock, flags);
  47 }
  48
  49 static void snd_opl3_command(struct snd_opl3 * opl3, unsigned short cmd, unsigned char val)
  50 {
  51         unsigned long flags;
  52         unsigned long port;
  53
  54         /*
  55          * The OPL-3 survives with just two INBs
  56          * after writing to a register.
  57          */
  58
  59         port = (cmd & OPL3_RIGHT) ? opl3->r_port : opl3->l_port;
  60
  61         spin_lock_irqsave(&opl3->reg_lock, flags);
  62
  63         outb((unsigned char) cmd, port);
  64         inb(opl3->l_port);
  65         inb(opl3->l_port);
  66
  67         outb((unsigned char) val, port + 1);
  68         inb(opl3->l_port);
  69         inb(opl3->l_port);
  70
  71         spin_unlock_irqrestore(&opl3->reg_lock, flags);
  72 }
  73
  74 static int snd_opl3_detect(struct snd_opl3 * opl3)
  75 {
  76         /*
  77          * This function returns 1 if the FM chip is present at the given I/O port
  78          * The detection algorithm plays with the timer built in the FM chip and
  79          * looks for a change in the status register.
  80          *
  81          * Note! The timers of the FM chip are not connected to AdLib (and compatible)
  82          * boards.
  83          *
  84          * Note2! The chip is initialized if detected.
  85          */
  86
  87         unsigned char stat1, stat2, signature;
  88
  89         /* Reset timers 1 and 2 */
  90         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, OPL3_TIMER1_MASK | OPL3_TIMER2_MASK);
  91         /* Reset the IRQ of the FM chip */
  92         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, OPL3_IRQ_RESET);
  93         signature = stat1 = inb(opl3->l_port);  /* Status register */
  94         if ((stat1 & 0xe0) != 0x00) {   /* Should be 0x00 */
  95                 snd_printd("OPL3: stat1 = 0x%x\n", stat1);
  96                 return -ENODEV;
  97         }
  98         /* Set timer1 to 0xff */
  99         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER1, 0xff);
 100         /* Unmask and start timer 1 */
 101         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, OPL3_TIMER2_MASK | OPL3_TIMER1_START);
 102         /* Now we have to delay at least 80us */
 103         udelay(200);
 104         /* Read status after timers have expired */
 105         stat2 = inb(opl3->l_port);
 106         /* Stop the timers */
 107         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, OPL3_TIMER1_MASK | OPL3_TIMER2_MASK);
 108         /* Reset the IRQ of the FM chip */
 109         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, OPL3_IRQ_RESET);
 110         if ((stat2 & 0xe0) != 0xc0) {   /* There is no YM3812 */
 111                 snd_printd("OPL3: stat2 = 0x%x\n", stat2);
 112                 return -ENODEV;
 113         }
 114
 115         /* If the toplevel code knows exactly the type of chip, don't try
 116            to detect it. */
 117         if (opl3->hardware != OPL3_HW_AUTO)
 118                 return 0;
 119
 120         /* There is a FM chip on this address. Detect the type (OPL2 to OPL4) */
 121         if (signature == 0x06) {        /* OPL2 */
 122                 opl3->hardware = OPL3_HW_OPL2;
 123         } else {
 124                 /*
 125                  * If we had an OPL4 chip, opl3->hardware would have been set
 126                  * by the OPL4 driver; so we can assume OPL3 here.
 127                  */
 128                 if (snd_BUG_ON(!opl3->r_port))
 129                         return -ENODEV;
 130                 opl3->hardware = OPL3_HW_OPL3;
 131         }
 132         return 0;
 133 }
 134
 135 /*
 136  *  AdLib timers
 137  */
 138
 139 /*
 140  *  Timer 1 - 80us
 141  */
 142
 143 static int snd_opl3_timer1_start(struct snd_timer * timer)
 144 {
 145         unsigned long flags;
 146         unsigned char tmp;
 147         unsigned int ticks;
 148         struct snd_opl3 *opl3;
 149
 150         opl3 = snd_timer_chip(timer);
 151         spin_lock_irqsave(&opl3->timer_lock, flags);
 152         ticks = timer->sticks;
 153         tmp = (opl3->timer_enable | OPL3_TIMER1_START) & ~OPL3_TIMER1_MASK;
 154         opl3->timer_enable = tmp;
 155         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER1, 256 - ticks);  /* timer 1 count */
 156         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, tmp);   /* enable timer 1 IRQ */
 157         spin_unlock_irqrestore(&opl3->timer_lock, flags);
 158         return 0;
 159 }
 160
 161 static int snd_opl3_timer1_stop(struct snd_timer * timer)
 162 {
 163         unsigned long flags;
 164         unsigned char tmp;
 165         struct snd_opl3 *opl3;
 166
 167         opl3 = snd_timer_chip(timer);
 168         spin_lock_irqsave(&opl3->timer_lock, flags);
 169         tmp = (opl3->timer_enable | OPL3_TIMER1_MASK) & ~OPL3_TIMER1_START;
 170         opl3->timer_enable = tmp;
 171         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, tmp);   /* disable timer #1 */
 172         spin_unlock_irqrestore(&opl3->timer_lock, flags);
 173         return 0;
 174 }
 175
 176 /*
 177  *  Timer 2 - 320us
 178  */
 179
 180 static int snd_opl3_timer2_start(struct snd_timer * timer)
 181 {
 182         unsigned long flags;
 183         unsigned char tmp;
 184         unsigned int ticks;
 185         struct snd_opl3 *opl3;
 186
 187         opl3 = snd_timer_chip(timer);
 188         spin_lock_irqsave(&opl3->timer_lock, flags);
 189         ticks = timer->sticks;
 190         tmp = (opl3->timer_enable | OPL3_TIMER2_START) & ~OPL3_TIMER2_MASK;
 191         opl3->timer_enable = tmp;
 192         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER2, 256 - ticks);  /* timer 1 count */
 193         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, tmp);   /* enable timer 1 IRQ */
 194         spin_unlock_irqrestore(&opl3->timer_lock, flags);
 195         return 0;
 196 }
 197
 198 static int snd_opl3_timer2_stop(struct snd_timer * timer)
 199 {
 200         unsigned long flags;
 201         unsigned char tmp;
 202         struct snd_opl3 *opl3;
 203
 204         opl3 = snd_timer_chip(timer);
 205         spin_lock_irqsave(&opl3->timer_lock, flags);
 206         tmp = (opl3->timer_enable | OPL3_TIMER2_MASK) & ~OPL3_TIMER2_START;
 207         opl3->timer_enable = tmp;
 208         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TIMER_CONTROL, tmp);   /* disable timer #1 */
 209         spin_unlock_irqrestore(&opl3->timer_lock, flags);
 210         return 0;
 211 }
 212
 213 /*
 214
 215  */
 216
 217 static const struct snd_timer_hardware snd_opl3_timer1 =
 218 {
 219         .flags =        SNDRV_TIMER_HW_STOP,
 220         .resolution =   80000,
 221         .ticks =        256,
 222         .start =        snd_opl3_timer1_start,
 223         .stop =         snd_opl3_timer1_stop,
 224 };
 225
 226 static const struct snd_timer_hardware snd_opl3_timer2 =
 227 {
 228         .flags =        SNDRV_TIMER_HW_STOP,
 229         .resolution =   320000,
 230         .ticks =        256,
 231         .start =        snd_opl3_timer2_start,
 232         .stop =         snd_opl3_timer2_stop,
 233 };
 234
 235 static int snd_opl3_timer1_init(struct snd_opl3 * opl3, int timer_no)
 236 {
 237         struct snd_timer *timer = NULL;
 238         struct snd_timer_id tid;
 239         int err;
 240
 241         tid.dev_class = SNDRV_TIMER_CLASS_CARD;
 242         tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
 243         tid.card = opl3->card->number;
 244         tid.device = timer_no;
 245         tid.subdevice = 0;
 246         err = snd_timer_new(opl3->card, "AdLib timer #1", &tid, &timer);
 247         if (err >= 0) {
 248                 strcpy(timer->name, "AdLib timer #1");
 249                 timer->private_data = opl3;
 250                 timer->hw = snd_opl3_timer1;
 251         }
 252         opl3->timer1 = timer;
 253         return err;
 254 }
 255
 256 static int snd_opl3_timer2_init(struct snd_opl3 * opl3, int timer_no)
 257 {
 258         struct snd_timer *timer = NULL;
 259         struct snd_timer_id tid;
 260         int err;
 261
 262         tid.dev_class = SNDRV_TIMER_CLASS_CARD;
 263         tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
 264         tid.card = opl3->card->number;
 265         tid.device = timer_no;
 266         tid.subdevice = 0;
 267         err = snd_timer_new(opl3->card, "AdLib timer #2", &tid, &timer);
 268         if (err >= 0) {
 269                 strcpy(timer->name, "AdLib timer #2");
 270                 timer->private_data = opl3;
 271                 timer->hw = snd_opl3_timer2;
 272         }
 273         opl3->timer2 = timer;
 274         return err;
 275 }
 276
 277 /*
 278
 279  */
 280
 281 void snd_opl3_interrupt(struct snd_hwdep * hw)
 282 {
 283         unsigned char status;
 284         struct snd_opl3 *opl3;
 285         struct snd_timer *timer;
 286
 287         if (hw == NULL)
 288                 return;
 289
 290         opl3 = hw->private_data;
 291         status = inb(opl3->l_port);
 292 #if 0
 293         snd_printk(KERN_DEBUG "AdLib IRQ status = 0x%x\n", status);
 294 #endif
 295         if (!(status & 0x80))
 296                 return;
 297
 298         if (status & 0x40) {
 299                 timer = opl3->timer1;
 300                 snd_timer_interrupt(timer, timer->sticks);
 301         }
 302         if (status & 0x20) {
 303                 timer = opl3->timer2;
 304                 snd_timer_interrupt(timer, timer->sticks);
 305         }
 306 }
 307
 308 EXPORT_SYMBOL(snd_opl3_interrupt);
 309
 310 /*
 311
 312  */
 313
 314 static int snd_opl3_free(struct snd_opl3 *opl3)
 315 {
 316         if (snd_BUG_ON(!opl3))
 317                 return -ENXIO;
 318         if (opl3->private_free)
 319                 opl3->private_free(opl3);
 320         snd_opl3_clear_patches(opl3);
 321         release_and_free_resource(opl3->res_l_port);
 322         release_and_free_resource(opl3->res_r_port);
 323         kfree(opl3);
 324         return 0;
 325 }
 326
 327 static int snd_opl3_dev_free(struct snd_device *device)
 328 {
 329         struct snd_opl3 *opl3 = device->device_data;
 330         return snd_opl3_free(opl3);
 331 }
 332
 333 int snd_opl3_new(struct snd_card *card,
 334                  unsigned short hardware,
 335                  struct snd_opl3 **ropl3)
 336 {
 337         static const struct snd_device_ops ops = {
 338                 .dev_free = snd_opl3_dev_free,
 339         };
 340         struct snd_opl3 *opl3;
 341         int err;
 342
 343         *ropl3 = NULL;
 344         opl3 = kzalloc(sizeof(*opl3), GFP_KERNEL);
 345         if (!opl3)
 346                 return -ENOMEM;
 347
 348         opl3->card = card;
 349         opl3->hardware = hardware;
 350         spin_lock_init(&opl3->reg_lock);
 351         spin_lock_init(&opl3->timer_lock);
 352
 353         err = snd_device_new(card, SNDRV_DEV_CODEC, opl3, &ops);
 354         if (err < 0) {
 355                 snd_opl3_free(opl3);
 356                 return err;
 357         }
 358
 359         *ropl3 = opl3;
 360         return 0;
 361 }
 362
 363 EXPORT_SYMBOL(snd_opl3_new);
 364
 365 int snd_opl3_init(struct snd_opl3 *opl3)
 366 {
 367         if (! opl3->command) {
 368                 printk(KERN_ERR "snd_opl3_init: command not defined!\n");
 369                 return -EINVAL;
 370         }
 371
 372         opl3->command(opl3, OPL3_LEFT | OPL3_REG_TEST, OPL3_ENABLE_WAVE_SELECT);
 373         /* Melodic mode */
 374         opl3->command(opl3, OPL3_LEFT | OPL3_REG_PERCUSSION, 0x00);
 375
 376         switch (opl3->hardware & OPL3_HW_MASK) {
 377         case OPL3_HW_OPL2:
 378                 opl3->max_voices = MAX_OPL2_VOICES;
 379                 break;
 380         case OPL3_HW_OPL3:
 381         case OPL3_HW_OPL4:
 382                 opl3->max_voices = MAX_OPL3_VOICES;
 383                 /* Enter OPL3 mode */
 384                 opl3->command(opl3, OPL3_RIGHT | OPL3_REG_MODE, OPL3_OPL3_ENABLE);
 385         }
 386         return 0;
 387 }
 388
 389 EXPORT_SYMBOL(snd_opl3_init);
 390
 391 int snd_opl3_create(struct snd_card *card,
 392                     unsigned long l_port,
 393                     unsigned long r_port,
 394                     unsigned short hardware,
 395                     int integrated,
 396                     struct snd_opl3 ** ropl3)
 397 {
 398         struct snd_opl3 *opl3;
 399         int err;
 400
 401         *ropl3 = NULL;
 402         err = snd_opl3_new(card, hardware, &opl3);
 403         if (err < 0)
 404                 return err;
 405         if (! integrated) {
 406                 opl3->res_l_port = request_region(l_port, 2, "OPL2/3 (left)");
 407                 if (!opl3->res_l_port) {
 408                         snd_printk(KERN_ERR "opl3: can't grab left port 0x%lx\n", l_port);
 409                         snd_device_free(card, opl3);
 410                         return -EBUSY;
 411                 }
 412                 if (r_port != 0) {
 413                         opl3->res_r_port = request_region(r_port, 2, "OPL2/3 (right)");
 414                         if (!opl3->res_r_port) {
 415                                 snd_printk(KERN_ERR "opl3: can't grab right port 0x%lx\n", r_port);
 416                                 snd_device_free(card, opl3);
 417                                 return -EBUSY;
 418                         }
 419                 }
 420         }
 421         opl3->l_port = l_port;
 422         opl3->r_port = r_port;
 423
 424         switch (opl3->hardware) {
 425         /* some hardware doesn't support timers */
 426         case OPL3_HW_OPL3_SV:
 427         case OPL3_HW_OPL3_CS:
 428         case OPL3_HW_OPL3_FM801:
 429                 opl3->command = &snd_opl3_command;
 430                 break;
 431         default:
 432                 opl3->command = &snd_opl2_command;
 433                 err = snd_opl3_detect(opl3);
 434                 if (err < 0) {
 435                         snd_printd("OPL2/3 chip not detected at 0x%lx/0x%lx\n",
 436                                    opl3->l_port, opl3->r_port);
 437                         snd_device_free(card, opl3);
 438                         return err;
 439                 }
 440                 /* detect routine returns correct hardware type */
 441                 switch (opl3->hardware & OPL3_HW_MASK) {
 442                 case OPL3_HW_OPL3:
 443                 case OPL3_HW_OPL4:
 444                         opl3->command = &snd_opl3_command;
 445                 }
 446         }
 447
 448         snd_opl3_init(opl3);
 449
 450         *ropl3 = opl3;
 451         return 0;
 452 }
 453
 454 EXPORT_SYMBOL(snd_opl3_create);
 455
 456 int snd_opl3_timer_new(struct snd_opl3 * opl3, int timer1_dev, int timer2_dev)
 457 {
 458         int err;
 459
 460         if (timer1_dev >= 0) {
 461                 err = snd_opl3_timer1_init(opl3, timer1_dev);
 462                 if (err < 0)
 463                         return err;
 464         }
 465         if (timer2_dev >= 0) {
 466                 err = snd_opl3_timer2_init(opl3, timer2_dev);
 467                 if (err < 0) {
 468                         snd_device_free(opl3->card, opl3->timer1);
 469                         opl3->timer1 = NULL;
 470                         return err;
 471                 }
 472         }
 473         return 0;
 474 }
 475
 476 EXPORT_SYMBOL(snd_opl3_timer_new);
 477
 478 int snd_opl3_hwdep_new(struct snd_opl3 * opl3,
 479                        int device, int seq_device,
 480                        struct snd_hwdep ** rhwdep)
 481 {
 482         struct snd_hwdep *hw;
 483         struct snd_card *card = opl3->card;
 484         int err;
 485
 486         if (rhwdep)
 487                 *rhwdep = NULL;
 488
 489         /* create hardware dependent device (direct FM) */
 490
 491         err = snd_hwdep_new(card, "OPL2/OPL3", device, &hw);
 492         if (err < 0) {
 493                 snd_device_free(card, opl3);
 494                 return err;
 495         }
 496         hw->private_data = opl3;
 497         hw->exclusive = 1;
 498 #ifdef CONFIG_SND_OSSEMUL
 499         if (device == 0)
 500                 hw->oss_type = SNDRV_OSS_DEVICE_TYPE_DMFM;
 501 #endif
 502         strcpy(hw->name, hw->id);
 503         switch (opl3->hardware & OPL3_HW_MASK) {
 504         case OPL3_HW_OPL2:
 505                 strcpy(hw->name, "OPL2 FM");
 506                 hw->iface = SNDRV_HWDEP_IFACE_OPL2;
 507                 break;
 508         case OPL3_HW_OPL3:
 509                 strcpy(hw->name, "OPL3 FM");
 510                 hw->iface = SNDRV_HWDEP_IFACE_OPL3;
 511                 break;
 512         case OPL3_HW_OPL4:
 513                 strcpy(hw->name, "OPL4 FM");
 514                 hw->iface = SNDRV_HWDEP_IFACE_OPL4;
 515                 break;
 516         }
 517
 518         /* operators - only ioctl */
 519         hw->ops.open = snd_opl3_open;
 520         hw->ops.ioctl = snd_opl3_ioctl;
 521         hw->ops.write = snd_opl3_write;
 522         hw->ops.release = snd_opl3_release;
 523
 524         opl3->hwdep = hw;
 525         opl3->seq_dev_num = seq_device;
 526 #if IS_ENABLED(CONFIG_SND_SEQUENCER)
 527         if (snd_seq_device_new(card, seq_device, SNDRV_SEQ_DEV_ID_OPL3,
 528                                sizeof(struct snd_opl3 *), &opl3->seq_dev) >= 0) {
 529                 strcpy(opl3->seq_dev->name, hw->name);
 530                 *(struct snd_opl3 **)SNDRV_SEQ_DEVICE_ARGPTR(opl3->seq_dev) = opl3;
 531         }
 532 #endif
 533         if (rhwdep)
 534                 *rhwdep = hw;
 535         return 0;
 536 }
 537
 538 EXPORT_SYMBOL(snd_opl3_hwdep_new);