sound/pci/als300.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  als300.c - driver for Avance Logic ALS300/ALS300+ soundcards.
   4  *  Copyright (C) 2005 by Ash Willis <ashwillis@programmer.net>
   5  *
   6  *  TODO
   7  *  4 channel playback for ALS300+
   8  *  gameport
   9  *  mpu401
  10  *  opl3
  11  *
  12  *  NOTES
  13  *  The BLOCK_COUNTER registers for the ALS300(+) return a figure related to
  14  *  the position in the current period, NOT the whole buffer. It is important
  15  *  to know which period we are in so we can calculate the correct pointer.
  16  *  This is why we always use 2 periods. We can then use a flip-flop variable
  17  *  to keep track of what period we are in.
  18  */
  19
  20 #include <linux/delay.h>
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23 #include <linux/pci.h>
  24 #include <linux/dma-mapping.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/slab.h>
  27 #include <linux/io.h>
  28
  29 #include <sound/core.h>
  30 #include <sound/control.h>
  31 #include <sound/initval.h>
  32 #include <sound/pcm.h>
  33 #include <sound/pcm_params.h>
  34 #include <sound/ac97_codec.h>
  35 #include <sound/opl3.h>
  36
  37 /* snd_als300_set_irq_flag */
  38 #define IRQ_DISABLE             0
  39 #define IRQ_ENABLE              1
  40
  41 /* I/O port layout */
  42 #define AC97_ACCESS             0x00
  43 #define AC97_READ               0x04
  44 #define AC97_STATUS             0x06
  45 #define   AC97_DATA_AVAIL               (1<<6)
  46 #define   AC97_BUSY                     (1<<7)
  47 #define ALS300_IRQ_STATUS       0x07            /* ALS300 Only */
  48 #define   IRQ_PLAYBACK                  (1<<3)
  49 #define   IRQ_CAPTURE                   (1<<2)
  50 #define GCR_DATA                0x08
  51 #define GCR_INDEX               0x0C
  52 #define ALS300P_DRAM_IRQ_STATUS 0x0D            /* ALS300+ Only */
  53 #define MPU_IRQ_STATUS          0x0E            /* ALS300 Rev. E+, ALS300+ */
  54 #define ALS300P_IRQ_STATUS      0x0F            /* ALS300+ Only */
  55
  56 /* General Control Registers */
  57 #define PLAYBACK_START          0x80
  58 #define PLAYBACK_END            0x81
  59 #define PLAYBACK_CONTROL        0x82
  60 #define   TRANSFER_START                (1<<16)
  61 #define   FIFO_PAUSE                    (1<<17)
  62 #define RECORD_START            0x83
  63 #define RECORD_END              0x84
  64 #define RECORD_CONTROL          0x85
  65 #define DRAM_WRITE_CONTROL      0x8B
  66 #define   WRITE_TRANS_START             (1<<16)
  67 #define   DRAM_MODE_2                   (1<<17)
  68 #define MISC_CONTROL            0x8C
  69 #define   IRQ_SET_BIT                   (1<<15)
  70 #define   VMUTE_NORMAL                  (1<<20)
  71 #define   MMUTE_NORMAL                  (1<<21)
  72 #define MUS_VOC_VOL             0x8E
  73 #define PLAYBACK_BLOCK_COUNTER  0x9A
  74 #define RECORD_BLOCK_COUNTER    0x9B
  75
  76 #define DEBUG_PLAY_REC  0
  77
  78 #if DEBUG_PLAY_REC
  79 #define snd_als300_dbgplay(format, args...) printk(KERN_ERR format, ##args)
  80 #else
  81 #define snd_als300_dbgplay(format, args...)
  82 #endif
  83
  84 enum {DEVICE_ALS300, DEVICE_ALS300_PLUS};
  85
  86 MODULE_AUTHOR("Ash Willis <ashwillis@programmer.net>");
  87 MODULE_DESCRIPTION("Avance Logic ALS300");
  88 MODULE_LICENSE("GPL");
  89 MODULE_SUPPORTED_DEVICE("{{Avance Logic,ALS300},{Avance Logic,ALS300+}}");
  90
  91 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
  92 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
  93 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  94
  95 module_param_array(index, int, NULL, 0444);
  96 MODULE_PARM_DESC(index, "Index value for ALS300 sound card.");
  97 module_param_array(id, charp, NULL, 0444);
  98 MODULE_PARM_DESC(id, "ID string for ALS300 sound card.");
  99 module_param_array(enable, bool, NULL, 0444);
 100 MODULE_PARM_DESC(enable, "Enable ALS300 sound card.");
 101
 102 struct snd_als300 {
 103         unsigned long port;
 104         spinlock_t reg_lock;
 105         struct snd_card *card;
 106         struct pci_dev *pci;
 107
 108         struct snd_pcm *pcm;
 109         struct snd_pcm_substream *playback_substream;
 110         struct snd_pcm_substream *capture_substream;
 111
 112         struct snd_ac97 *ac97;
 113         struct snd_opl3 *opl3;
 114
 115         struct resource *res_port;
 116
 117         int irq;
 118
 119         int chip_type; /* ALS300 or ALS300+ */
 120
 121         char revision;
 122 };
 123
 124 struct snd_als300_substream_data {
 125         int period_flipflop;
 126         int control_register;
 127         int block_counter_register;
 128 };
 129
 130 static const struct pci_device_id snd_als300_ids[] = {
 131         { 0x4005, 0x0300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALS300 },
 132         { 0x4005, 0x0308, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALS300_PLUS },
 133         { 0, }
 134 };
 135
 136 MODULE_DEVICE_TABLE(pci, snd_als300_ids);
 137
 138 static inline u32 snd_als300_gcr_read(unsigned long port, unsigned short reg)
 139 {
 140         outb(reg, port+GCR_INDEX);
 141         return inl(port+GCR_DATA);
 142 }
 143
 144 static inline void snd_als300_gcr_write(unsigned long port,
 145                                                 unsigned short reg, u32 val)
 146 {
 147         outb(reg, port+GCR_INDEX);
 148         outl(val, port+GCR_DATA);
 149 }
 150
 151 /* Enable/Disable Interrupts */
 152 static void snd_als300_set_irq_flag(struct snd_als300 *chip, int cmd)
 153 {
 154         u32 tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL);
 155
 156         /* boolean XOR check, since old vs. new hardware have
 157            directly reversed bit setting for ENABLE and DISABLE.
 158            ALS300+ acts like newer versions of ALS300 */
 159         if (((chip->revision > 5 || chip->chip_type == DEVICE_ALS300_PLUS) ^
 160                                                 (cmd == IRQ_ENABLE)) == 0)
 161                 tmp |= IRQ_SET_BIT;
 162         else
 163                 tmp &= ~IRQ_SET_BIT;
 164         snd_als300_gcr_write(chip->port, MISC_CONTROL, tmp);
 165 }
 166
 167 static int snd_als300_free(struct snd_als300 *chip)
 168 {
 169         snd_als300_set_irq_flag(chip, IRQ_DISABLE);
 170         if (chip->irq >= 0)
 171                 free_irq(chip->irq, chip);
 172         pci_release_regions(chip->pci);
 173         pci_disable_device(chip->pci);
 174         kfree(chip);
 175         return 0;
 176 }
 177
 178 static int snd_als300_dev_free(struct snd_device *device)
 179 {
 180         struct snd_als300 *chip = device->device_data;
 181         return snd_als300_free(chip);
 182 }
 183
 184 static irqreturn_t snd_als300_interrupt(int irq, void *dev_id)
 185 {
 186         u8 status;
 187         struct snd_als300 *chip = dev_id;
 188         struct snd_als300_substream_data *data;
 189
 190         status = inb(chip->port+ALS300_IRQ_STATUS);
 191         if (!status) /* shared IRQ, for different device?? Exit ASAP! */
 192                 return IRQ_NONE;
 193
 194         /* ACK everything ASAP */
 195         outb(status, chip->port+ALS300_IRQ_STATUS);
 196         if (status & IRQ_PLAYBACK) {
 197                 if (chip->pcm && chip->playback_substream) {
 198                         data = chip->playback_substream->runtime->private_data;
 199                         data->period_flipflop ^= 1;
 200                         snd_pcm_period_elapsed(chip->playback_substream);
 201                         snd_als300_dbgplay("IRQ_PLAYBACK\n");
 202                 }
 203         }
 204         if (status & IRQ_CAPTURE) {
 205                 if (chip->pcm && chip->capture_substream) {
 206                         data = chip->capture_substream->runtime->private_data;
 207                         data->period_flipflop ^= 1;
 208                         snd_pcm_period_elapsed(chip->capture_substream);
 209                         snd_als300_dbgplay("IRQ_CAPTURE\n");
 210                 }
 211         }
 212         return IRQ_HANDLED;
 213 }
 214
 215 static irqreturn_t snd_als300plus_interrupt(int irq, void *dev_id)
 216 {
 217         u8 general, mpu, dram;
 218         struct snd_als300 *chip = dev_id;
 219         struct snd_als300_substream_data *data;
 220
 221         general = inb(chip->port+ALS300P_IRQ_STATUS);
 222         mpu = inb(chip->port+MPU_IRQ_STATUS);
 223         dram = inb(chip->port+ALS300P_DRAM_IRQ_STATUS);
 224
 225         /* shared IRQ, for different device?? Exit ASAP! */
 226         if ((general == 0) && ((mpu & 0x80) == 0) && ((dram & 0x01) == 0))
 227                 return IRQ_NONE;
 228
 229         if (general & IRQ_PLAYBACK) {
 230                 if (chip->pcm && chip->playback_substream) {
 231                         outb(IRQ_PLAYBACK, chip->port+ALS300P_IRQ_STATUS);
 232                         data = chip->playback_substream->runtime->private_data;
 233                         data->period_flipflop ^= 1;
 234                         snd_pcm_period_elapsed(chip->playback_substream);
 235                         snd_als300_dbgplay("IRQ_PLAYBACK\n");
 236                 }
 237         }
 238         if (general & IRQ_CAPTURE) {
 239                 if (chip->pcm && chip->capture_substream) {
 240                         outb(IRQ_CAPTURE, chip->port+ALS300P_IRQ_STATUS);
 241                         data = chip->capture_substream->runtime->private_data;
 242                         data->period_flipflop ^= 1;
 243                         snd_pcm_period_elapsed(chip->capture_substream);
 244                         snd_als300_dbgplay("IRQ_CAPTURE\n");
 245                 }
 246         }
 247         /* FIXME: Ack other interrupt types. Not important right now as
 248          * those other devices aren't enabled. */
 249         return IRQ_HANDLED;
 250 }
 251
 252 static void snd_als300_remove(struct pci_dev *pci)
 253 {
 254         snd_card_free(pci_get_drvdata(pci));
 255 }
 256
 257 static unsigned short snd_als300_ac97_read(struct snd_ac97 *ac97,
 258                                                         unsigned short reg)
 259 {
 260         int i;
 261         struct snd_als300 *chip = ac97->private_data;
 262
 263         for (i = 0; i < 1000; i++) {
 264                 if ((inb(chip->port+AC97_STATUS) & (AC97_BUSY)) == 0)
 265                         break;
 266                 udelay(10);
 267         }
 268         outl((reg << 24) | (1 << 31), chip->port+AC97_ACCESS);
 269
 270         for (i = 0; i < 1000; i++) {
 271                 if ((inb(chip->port+AC97_STATUS) & (AC97_DATA_AVAIL)) != 0)
 272                         break;
 273                 udelay(10);
 274         }
 275         return inw(chip->port+AC97_READ);
 276 }
 277
 278 static void snd_als300_ac97_write(struct snd_ac97 *ac97,
 279                                 unsigned short reg, unsigned short val)
 280 {
 281         int i;
 282         struct snd_als300 *chip = ac97->private_data;
 283
 284         for (i = 0; i < 1000; i++) {
 285                 if ((inb(chip->port+AC97_STATUS) & (AC97_BUSY)) == 0)
 286                         break;
 287                 udelay(10);
 288         }
 289         outl((reg << 24) | val, chip->port+AC97_ACCESS);
 290 }
 291
 292 static int snd_als300_ac97(struct snd_als300 *chip)
 293 {
 294         struct snd_ac97_bus *bus;
 295         struct snd_ac97_template ac97;
 296         int err;
 297         static struct snd_ac97_bus_ops ops = {
 298                 .write = snd_als300_ac97_write,
 299                 .read = snd_als300_ac97_read,
 300         };
 301
 302         if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &bus)) < 0)
 303                 return err;
 304
 305         memset(&ac97, 0, sizeof(ac97));
 306         ac97.private_data = chip;
 307
 308         return snd_ac97_mixer(bus, &ac97, &chip->ac97);
 309 }
 310
 311 /* hardware definition
 312  *
 313  * In AC97 mode, we always use 48k/16bit/stereo.
 314  * Any request to change data type is ignored by
 315  * the card when it is running outside of legacy
 316  * mode.
 317  */
 318 static const struct snd_pcm_hardware snd_als300_playback_hw =
 319 {
 320         .info =                 (SNDRV_PCM_INFO_MMAP |
 321                                 SNDRV_PCM_INFO_INTERLEAVED |
 322                                 SNDRV_PCM_INFO_PAUSE |
 323                                 SNDRV_PCM_INFO_MMAP_VALID),
 324         .formats =              SNDRV_PCM_FMTBIT_S16,
 325         .rates =                SNDRV_PCM_RATE_48000,
 326         .rate_min =             48000,
 327         .rate_max =             48000,
 328         .channels_min =         2,
 329         .channels_max =         2,
 330         .buffer_bytes_max =     64 * 1024,
 331         .period_bytes_min =     64,
 332         .period_bytes_max =     32 * 1024,
 333         .periods_min =          2,
 334         .periods_max =          2,
 335 };
 336
 337 static const struct snd_pcm_hardware snd_als300_capture_hw =
 338 {
 339         .info =                 (SNDRV_PCM_INFO_MMAP |
 340                                 SNDRV_PCM_INFO_INTERLEAVED |
 341                                 SNDRV_PCM_INFO_PAUSE |
 342                                 SNDRV_PCM_INFO_MMAP_VALID),
 343         .formats =              SNDRV_PCM_FMTBIT_S16,
 344         .rates =                SNDRV_PCM_RATE_48000,
 345         .rate_min =             48000,
 346         .rate_max =             48000,
 347         .channels_min =         2,
 348         .channels_max =         2,
 349         .buffer_bytes_max =     64 * 1024,
 350         .period_bytes_min =     64,
 351         .period_bytes_max =     32 * 1024,
 352         .periods_min =          2,
 353         .periods_max =          2,
 354 };
 355
 356 static int snd_als300_playback_open(struct snd_pcm_substream *substream)
 357 {
 358         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 359         struct snd_pcm_runtime *runtime = substream->runtime;
 360         struct snd_als300_substream_data *data = kzalloc(sizeof(*data),
 361                                                                 GFP_KERNEL);
 362
 363         if (!data)
 364                 return -ENOMEM;
 365         chip->playback_substream = substream;
 366         runtime->hw = snd_als300_playback_hw;
 367         runtime->private_data = data;
 368         data->control_register = PLAYBACK_CONTROL;
 369         data->block_counter_register = PLAYBACK_BLOCK_COUNTER;
 370         return 0;
 371 }
 372
 373 static int snd_als300_playback_close(struct snd_pcm_substream *substream)
 374 {
 375         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 376         struct snd_als300_substream_data *data;
 377
 378         data = substream->runtime->private_data;
 379         kfree(data);
 380         chip->playback_substream = NULL;
 381         snd_pcm_lib_free_pages(substream);
 382         return 0;
 383 }
 384
 385 static int snd_als300_capture_open(struct snd_pcm_substream *substream)
 386 {
 387         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 388         struct snd_pcm_runtime *runtime = substream->runtime;
 389         struct snd_als300_substream_data *data = kzalloc(sizeof(*data),
 390                                                                 GFP_KERNEL);
 391
 392         if (!data)
 393                 return -ENOMEM;
 394         chip->capture_substream = substream;
 395         runtime->hw = snd_als300_capture_hw;
 396         runtime->private_data = data;
 397         data->control_register = RECORD_CONTROL;
 398         data->block_counter_register = RECORD_BLOCK_COUNTER;
 399         return 0;
 400 }
 401
 402 static int snd_als300_capture_close(struct snd_pcm_substream *substream)
 403 {
 404         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 405         struct snd_als300_substream_data *data;
 406
 407         data = substream->runtime->private_data;
 408         kfree(data);
 409         chip->capture_substream = NULL;
 410         snd_pcm_lib_free_pages(substream);
 411         return 0;
 412 }
 413
 414 static int snd_als300_pcm_hw_params(struct snd_pcm_substream *substream,
 415                                     struct snd_pcm_hw_params *hw_params)
 416 {
 417         return snd_pcm_lib_malloc_pages(substream,
 418                                         params_buffer_bytes(hw_params));
 419 }
 420
 421 static int snd_als300_pcm_hw_free(struct snd_pcm_substream *substream)
 422 {
 423         return snd_pcm_lib_free_pages(substream);
 424 }
 425
 426 static int snd_als300_playback_prepare(struct snd_pcm_substream *substream)
 427 {
 428         u32 tmp;
 429         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 430         struct snd_pcm_runtime *runtime = substream->runtime;
 431         unsigned short period_bytes = snd_pcm_lib_period_bytes(substream);
 432         unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
 433
 434         spin_lock_irq(&chip->reg_lock);
 435         tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL);
 436         tmp &= ~TRANSFER_START;
 437
 438         snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n",
 439                                                 period_bytes, buffer_bytes);
 440
 441         /* set block size */
 442         tmp &= 0xffff0000;
 443         tmp |= period_bytes - 1;
 444         snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL, tmp);
 445
 446         /* set dma area */
 447         snd_als300_gcr_write(chip->port, PLAYBACK_START,
 448                                         runtime->dma_addr);
 449         snd_als300_gcr_write(chip->port, PLAYBACK_END,
 450                                         runtime->dma_addr + buffer_bytes - 1);
 451         spin_unlock_irq(&chip->reg_lock);
 452         return 0;
 453 }
 454
 455 static int snd_als300_capture_prepare(struct snd_pcm_substream *substream)
 456 {
 457         u32 tmp;
 458         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 459         struct snd_pcm_runtime *runtime = substream->runtime;
 460         unsigned short period_bytes = snd_pcm_lib_period_bytes(substream);
 461         unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
 462
 463         spin_lock_irq(&chip->reg_lock);
 464         tmp = snd_als300_gcr_read(chip->port, RECORD_CONTROL);
 465         tmp &= ~TRANSFER_START;
 466
 467         snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n", period_bytes,
 468                                                         buffer_bytes);
 469
 470         /* set block size */
 471         tmp &= 0xffff0000;
 472         tmp |= period_bytes - 1;
 473
 474         /* set dma area */
 475         snd_als300_gcr_write(chip->port, RECORD_CONTROL, tmp);
 476         snd_als300_gcr_write(chip->port, RECORD_START,
 477                                         runtime->dma_addr);
 478         snd_als300_gcr_write(chip->port, RECORD_END,
 479                                         runtime->dma_addr + buffer_bytes - 1);
 480         spin_unlock_irq(&chip->reg_lock);
 481         return 0;
 482 }
 483
 484 static int snd_als300_trigger(struct snd_pcm_substream *substream, int cmd)
 485 {
 486         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 487         u32 tmp;
 488         struct snd_als300_substream_data *data;
 489         unsigned short reg;
 490         int ret = 0;
 491
 492         data = substream->runtime->private_data;
 493         reg = data->control_register;
 494
 495         spin_lock(&chip->reg_lock);
 496         switch (cmd) {
 497         case SNDRV_PCM_TRIGGER_START:
 498         case SNDRV_PCM_TRIGGER_RESUME:
 499                 tmp = snd_als300_gcr_read(chip->port, reg);
 500                 data->period_flipflop = 1;
 501                 snd_als300_gcr_write(chip->port, reg, tmp | TRANSFER_START);
 502                 snd_als300_dbgplay("TRIGGER START\n");
 503                 break;
 504         case SNDRV_PCM_TRIGGER_STOP:
 505         case SNDRV_PCM_TRIGGER_SUSPEND:
 506                 tmp = snd_als300_gcr_read(chip->port, reg);
 507                 snd_als300_gcr_write(chip->port, reg, tmp & ~TRANSFER_START);
 508                 snd_als300_dbgplay("TRIGGER STOP\n");
 509                 break;
 510         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 511                 tmp = snd_als300_gcr_read(chip->port, reg);
 512                 snd_als300_gcr_write(chip->port, reg, tmp | FIFO_PAUSE);
 513                 snd_als300_dbgplay("TRIGGER PAUSE\n");
 514                 break;
 515         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 516                 tmp = snd_als300_gcr_read(chip->port, reg);
 517                 snd_als300_gcr_write(chip->port, reg, tmp & ~FIFO_PAUSE);
 518                 snd_als300_dbgplay("TRIGGER RELEASE\n");
 519                 break;
 520         default:
 521                 snd_als300_dbgplay("TRIGGER INVALID\n");
 522                 ret = -EINVAL;
 523         }
 524         spin_unlock(&chip->reg_lock);
 525         return ret;
 526 }
 527
 528 static snd_pcm_uframes_t snd_als300_pointer(struct snd_pcm_substream *substream)
 529 {
 530         u16 current_ptr;
 531         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 532         struct snd_als300_substream_data *data;
 533         unsigned short period_bytes;
 534
 535         data = substream->runtime->private_data;
 536         period_bytes = snd_pcm_lib_period_bytes(substream);
 537
 538         spin_lock(&chip->reg_lock);
 539         current_ptr = (u16) snd_als300_gcr_read(chip->port,
 540                                         data->block_counter_register) + 4;
 541         spin_unlock(&chip->reg_lock);
 542         if (current_ptr > period_bytes)
 543                 current_ptr = 0;
 544         else
 545                 current_ptr = period_bytes - current_ptr;
 546
 547         if (data->period_flipflop == 0)
 548                 current_ptr += period_bytes;
 549         snd_als300_dbgplay("Pointer (bytes): %d\n", current_ptr);
 550         return bytes_to_frames(substream->runtime, current_ptr);
 551 }
 552
 553 static const struct snd_pcm_ops snd_als300_playback_ops = {
 554         .open =         snd_als300_playback_open,
 555         .close =        snd_als300_playback_close,
 556         .ioctl =        snd_pcm_lib_ioctl,
 557         .hw_params =    snd_als300_pcm_hw_params,
 558         .hw_free =      snd_als300_pcm_hw_free,
 559         .prepare =      snd_als300_playback_prepare,
 560         .trigger =      snd_als300_trigger,
 561         .pointer =      snd_als300_pointer,
 562 };
 563
 564 static const struct snd_pcm_ops snd_als300_capture_ops = {
 565         .open =         snd_als300_capture_open,
 566         .close =        snd_als300_capture_close,
 567         .ioctl =        snd_pcm_lib_ioctl,
 568         .hw_params =    snd_als300_pcm_hw_params,
 569         .hw_free =      snd_als300_pcm_hw_free,
 570         .prepare =      snd_als300_capture_prepare,
 571         .trigger =      snd_als300_trigger,
 572         .pointer =      snd_als300_pointer,
 573 };
 574
 575 static int snd_als300_new_pcm(struct snd_als300 *chip)
 576 {
 577         struct snd_pcm *pcm;
 578         int err;
 579
 580         err = snd_pcm_new(chip->card, "ALS300", 0, 1, 1, &pcm);
 581         if (err < 0)
 582                 return err;
 583         pcm->private_data = chip;
 584         strcpy(pcm->name, "ALS300");
 585         chip->pcm = pcm;
 586
 587         /* set operators */
 588         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 589                                 &snd_als300_playback_ops);
 590         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 591                                 &snd_als300_capture_ops);
 592
 593         /* pre-allocation of buffers */
 594         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
 595         snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
 596         return 0;
 597 }
 598
 599 static void snd_als300_init(struct snd_als300 *chip)
 600 {
 601         unsigned long flags;
 602         u32 tmp;
 603
 604         spin_lock_irqsave(&chip->reg_lock, flags);
 605         chip->revision = (snd_als300_gcr_read(chip->port, MISC_CONTROL) >> 16)
 606                                                                 & 0x0000000F;
 607         /* Setup DRAM */
 608         tmp = snd_als300_gcr_read(chip->port, DRAM_WRITE_CONTROL);
 609         snd_als300_gcr_write(chip->port, DRAM_WRITE_CONTROL,
 610                                                 (tmp | DRAM_MODE_2)
 611                                                 & ~WRITE_TRANS_START);
 612
 613         /* Enable IRQ output */
 614         snd_als300_set_irq_flag(chip, IRQ_ENABLE);
 615
 616         /* Unmute hardware devices so their outputs get routed to
 617          * the onboard mixer */
 618         tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL);
 619         snd_als300_gcr_write(chip->port, MISC_CONTROL,
 620                         tmp | VMUTE_NORMAL | MMUTE_NORMAL);
 621
 622         /* Reset volumes */
 623         snd_als300_gcr_write(chip->port, MUS_VOC_VOL, 0);
 624
 625         /* Make sure playback transfer is stopped */
 626         tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL);
 627         snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL,
 628                         tmp & ~TRANSFER_START);
 629         spin_unlock_irqrestore(&chip->reg_lock, flags);
 630 }
 631
 632 static int snd_als300_create(struct snd_card *card,
 633                              struct pci_dev *pci, int chip_type,
 634                              struct snd_als300 **rchip)
 635 {
 636         struct snd_als300 *chip;
 637         void *irq_handler;
 638         int err;
 639
 640         static struct snd_device_ops ops = {
 641                 .dev_free = snd_als300_dev_free,
 642         };
 643         *rchip = NULL;
 644
 645         if ((err = pci_enable_device(pci)) < 0)
 646                 return err;
 647
 648         if (dma_set_mask(&pci->dev, DMA_BIT_MASK(28)) < 0 ||
 649                 dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(28)) < 0) {
 650                 dev_err(card->dev, "error setting 28bit DMA mask\n");
 651                 pci_disable_device(pci);
 652                 return -ENXIO;
 653         }
 654         pci_set_master(pci);
 655
 656         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 657         if (chip == NULL) {
 658                 pci_disable_device(pci);
 659                 return -ENOMEM;
 660         }
 661
 662         chip->card = card;
 663         chip->pci = pci;
 664         chip->irq = -1;
 665         chip->chip_type = chip_type;
 666         spin_lock_init(&chip->reg_lock);
 667
 668         if ((err = pci_request_regions(pci, "ALS300")) < 0) {
 669                 kfree(chip);
 670                 pci_disable_device(pci);
 671                 return err;
 672         }
 673         chip->port = pci_resource_start(pci, 0);
 674
 675         if (chip->chip_type == DEVICE_ALS300_PLUS)
 676                 irq_handler = snd_als300plus_interrupt;
 677         else
 678                 irq_handler = snd_als300_interrupt;
 679
 680         if (request_irq(pci->irq, irq_handler, IRQF_SHARED,
 681                         KBUILD_MODNAME, chip)) {
 682                 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
 683                 snd_als300_free(chip);
 684                 return -EBUSY;
 685         }
 686         chip->irq = pci->irq;
 687
 688
 689         snd_als300_init(chip);
 690
 691         err = snd_als300_ac97(chip);
 692         if (err < 0) {
 693                 dev_err(card->dev, "Could not create ac97\n");
 694                 snd_als300_free(chip);
 695                 return err;
 696         }
 697
 698         if ((err = snd_als300_new_pcm(chip)) < 0) {
 699                 dev_err(card->dev, "Could not create PCM\n");
 700                 snd_als300_free(chip);
 701                 return err;
 702         }
 703
 704         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
 705                                                 chip, &ops)) < 0) {
 706                 snd_als300_free(chip);
 707                 return err;
 708         }
 709
 710         *rchip = chip;
 711         return 0;
 712 }
 713
 714 #ifdef CONFIG_PM_SLEEP
 715 static int snd_als300_suspend(struct device *dev)
 716 {
 717         struct snd_card *card = dev_get_drvdata(dev);
 718         struct snd_als300 *chip = card->private_data;
 719
 720         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 721         snd_ac97_suspend(chip->ac97);
 722         return 0;
 723 }
 724
 725 static int snd_als300_resume(struct device *dev)
 726 {
 727         struct snd_card *card = dev_get_drvdata(dev);
 728         struct snd_als300 *chip = card->private_data;
 729
 730         snd_als300_init(chip);
 731         snd_ac97_resume(chip->ac97);
 732
 733         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
 734         return 0;
 735 }
 736
 737 static SIMPLE_DEV_PM_OPS(snd_als300_pm, snd_als300_suspend, snd_als300_resume);
 738 #define SND_ALS300_PM_OPS       &snd_als300_pm
 739 #else
 740 #define SND_ALS300_PM_OPS       NULL
 741 #endif
 742
 743 static int snd_als300_probe(struct pci_dev *pci,
 744                              const struct pci_device_id *pci_id)
 745 {
 746         static int dev;
 747         struct snd_card *card;
 748         struct snd_als300 *chip;
 749         int err, chip_type;
 750
 751         if (dev >= SNDRV_CARDS)
 752                 return -ENODEV;
 753         if (!enable[dev]) {
 754                 dev++;
 755                 return -ENOENT;
 756         }
 757
 758         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
 759                            0, &card);
 760
 761         if (err < 0)
 762                 return err;
 763
 764         chip_type = pci_id->driver_data;
 765
 766         if ((err = snd_als300_create(card, pci, chip_type, &chip)) < 0) {
 767                 snd_card_free(card);
 768                 return err;
 769         }
 770         card->private_data = chip;
 771
 772         strcpy(card->driver, "ALS300");
 773         if (chip->chip_type == DEVICE_ALS300_PLUS)
 774                 /* don't know much about ALS300+ yet
 775                  * print revision number for now */
 776                 sprintf(card->shortname, "ALS300+ (Rev. %d)", chip->revision);
 777         else
 778                 sprintf(card->shortname, "ALS300 (Rev. %c)", 'A' +
 779                                                         chip->revision - 1);
 780         sprintf(card->longname, "%s at 0x%lx irq %i",
 781                                 card->shortname, chip->port, chip->irq);
 782
 783         if ((err = snd_card_register(card)) < 0) {
 784                 snd_card_free(card);
 785                 return err;
 786         }
 787         pci_set_drvdata(pci, card);
 788         dev++;
 789         return 0;
 790 }
 791
 792 static struct pci_driver als300_driver = {
 793         .name = KBUILD_MODNAME,
 794         .id_table = snd_als300_ids,
 795         .probe = snd_als300_probe,
 796         .remove = snd_als300_remove,
 797         .driver = {
 798                 .pm = SND_ALS300_PM_OPS,
 799         },
 800 };
 801
 802 module_pci_driver(als300_driver);