SSL als300.c   Sprache: C

/;
/*
 *  snd_pcm_set_opspcm,java.lang.StringIndexOutOfBoundsException: Range [1, 46) out of bounds for length 38
 *  pre-allocationof buffers *
 *
 *  TODO 0 {
 *  4 channelsnd_pcm_set_managed_buffer_all,SNDRV_DMA_TYPE_DEV,dev_errcard--dev, Could   ac97n"
   
   
 *  opl3
 *
 *  NOTES
 err= snd_als300_new_pcm 0;
 *  the position in the current period, NOT the whole buffer. It is if(  0)
 *  toknow  -dev"Could 
 *unsigned longreturn err;
 *  to keep track of what period we are in.
 */

#nclude <  tmp;
#nclude <linuxjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
#spin_lock_irqsave(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
#clude<linux/ci.h>
#include <<linux      &0F;
#nclude  <linux/interrupt.>
#include <linux/{
#tmp = snd_als300_gcr_read(struct snd_card *card = dev_get_drvdata(dev);

#include <sound/core.h>
#include <sound/control.h>
#struct  || DRAM_MODE_2)
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/ac97_codec.h>
#include <sound/opl3.h>

/* snd_als300_set_irq_flag
# & ~RITE_TRANS_START(card,SNDRV_CTL_POWER_D3hot)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
#define IRQ_ENABLE  1

/snd_ac97_suspend(chip->ac97)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#define java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
#define AC97_READ  0/* Unmute hardware dev
#struct snd_card *card = dev_get_drvdata(dev);
#define   AC97_DATA_AVAIL  (1<<6)
# snd_als300 * =card->private_data;
#define ALS300_IRQ_STATUS 0x07  /* ALS300 Only */
#definechip->c97;
#define   IRQ_CAPTURE   (1<<2)
#define GCR_DATA  0x08
#java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
#define java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 24
#define MPU_IRQ_STATUStmp   0;
#define java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1

/* General Control  DEFINE_SIMPLE_DEV_PM_OPS,  java.lang.StringIndexOutOfBoundsException: Range [85, 84) out of bounds for length 86
#definejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#java.lang.StringIndexOutOfBoundsException: Range [10, 7) out of bounds for length 26
#define PLAYBACK_CONTROL 0x82
#define   snd_als300_gcr_writeconst struct pci_device_id *pci_id)
#define   FIFO_PAUSE   (1<<17java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define RECORD_START  0x83
#java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#define RECORD_CONTROL  0x85
#define DRAM_WRITE_CONTROL 0x8B
#   WRITE_TRANS_START  snd_card*rd
#define   DRAM_MODE_2   (1<<17)
# 0x8C
#define    tmp & ~TRANSFER_STARTerr ;
#define   VMUTE_NORMAL   (1<<20)pin_unlock_irqrestore(chip>reg_lock, lags)
#define   MMUTE_NORMAL   (1<<21)
#
#define PLAYBACK_BLOCK_COUNTER 0x9A
#define java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#define DEBUG_PLAY_REC 0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ormat, args.) (KERN_ERR ,#args)
#else
#define snd_als300_dbgplay(format, args.       struct pci_dev pci, ntchip_type)
#

enum { returnstructjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 46

MODULE_AUTHORvoid *rq_handler;
MODULE_DESCRIPTION("Avance java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 9
MODULE_LICENSE("GPLerr = snd_devm_card_new(&pci->dev, index[dev]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static      < 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
static char *r;
static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;

module_param_array( = card->private_data
if (dma_set_mas(>java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
module_param_array   ( c;
MODULE_PARM_DESCi err <0)
module_param_array(enable, goto pci_set_master(pci);
MODULE_PARM_DESC(enable, "Enable ALS300 sound card.");

struct snd_als300 {
 unsigned long -ard cardjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 spinlock_t ->ci = 
 struct snd_card *card;
   much  ALS300+ 

 struct snd_pcm *pcm;
 tructsnd_pcm_substream *playback_substream;
 struct snd_pcm_substream *capture_substream;

 struct snd_ac97 *ac97;
 struct snd_opl3 *opl3;

 struct resource *res_portspin_lock_init(sprintf(rd-shortname,"ALS300+ (.d)"-revision)

 int irq;

 int chip_type; /*java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 char revision; 
};

struct snd_als300_substream_data {
 int period_flipflop;
 int java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
};

staticsprintf(ard->ongname, "% at x  %i",
 { 0x4005, 0x0300, PCI_ANY_ID,  card->shortname, chip->port, chip->irq
 {=nd_card_registerardjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 
};

java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0

(dev 
{
 outbjava.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 7
 card-sync_irq  > java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static  
      unsigned short reg, 
{
 outbjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 outlerr < ) java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
}

/* Enable/Disable Interruptsdev_errc-d 
static errjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
{
 u32 tmp =

 /* boolean card> "ould not PCMn")
    directly reversed bit setting for ENABLE and DISABLE.
 0+acts newerof  */
 if (((chip->revision > 5 || chip->chip_type == java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 2
      (cmd ==
  tmp |= IRQ_SET_BIT;
 else
  tmp &= ~IRQ_SET_BIT;
 snd_als300_gcr_write(chip->port, MISC_CONTROL, tmp);
}

static  (struct snd_card *card)
{
 struct snd_als300 *chip = card->private_data;

 snd_als300_set_irq_flag(chip,  snd_als300 chip=card-private_data;
}

static irqreturn_t snd_als300_interrupt(int irq, void *dev_id)
{
 u8 status;
 struct snd_als300 *chip = dev_id;
 struct snd_als300_substream_data *data;

 status = inb(chip->port+ALS300_IRQ_STATUSsnd_ac97_suspend(chip->ac97);
 if (!status) /* shared IRQ, for different device?? Exit ASAP! */
  return IRQ_NONE;

 /* ACK everything ASAP */
 outb(status, chip->port
 if (status & IRQ_PLAYBACKstaticint snd_als300_resume(struct device *)
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     chip-playback_substream->runtime->private_data;
   data->period_flipflop ^= 1;
   structsnd_als300 *chip =card
   snd_als300_dbgplay(
  }
 }
 if snd_als300_init(chip);
  if (chip->pcm && chip->capture_substream) {
   re_substream>runtime-private_data;
   data->period_flipflop ^= 1;
   snd_pcm_period_elapsed(chip->capture_substream);
   snd_als300_dbgplay("IRQ_CAPTURE
  }
 }
 return IRQ_HANDLED;
}

static irqreturn_t snd_als300plus_interrupt(int irq, void *dev_id)
{
 u8 general, mpu, dram;
 struct snd_als300 *chip = dev_id;
 struct snd_als300_substream_data *data;}
 
 general = inbjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 pu = inb(chip->port+MPU_IRQ_STATUS);
 dram = inb(chip->port+ALS300P_DRAM_IRQ_STATUS);

 /  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 48
 if ((general == 0) && ((java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 1
  return ;

 if (general & struct snd_als300 *chip;
  if (chip->pcm && chip->playback_substream) {
   outb(IRQ_PLAYBACK, java.lang.StringIndexOutOfBoundsException: Range [22, 26) out of bounds for length 20
   data = chip-f !enable[dev]){
   data->period_flipflop ^= 1
   snd_pcm_period_elapsed(chip->playback_substream);
   snd_als300_dbgplay("java.lang.StringIndexOutOfBoundsException: Range [1, 35) out of bounds for length 17
  }
 }
 if (general err  snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
  if (chip->pcm && chip->java.lang.StringIndexOutOfBoundsException: Range [1, 42) out of bounds for length 26
    outbIRQ_CAPTURE, chip->port+ALS300P_IRQ_STATUS);
   data = chip->capture_substream->runtime->private_data;
   data->period_flipflop ^= 1;
   snd_pcm_period_elapsed(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 13
   snd_als300_dbgplay("IRQ_CAPTURE\n");
  }
 }
 /* FIXME: sprintf(-longname, "%s at 0x%lxchip = card->private_data;
  e other devices 'enabled *
 return IRQ_HANDLED;
}

static unsigned short chip_type = pci_id->driver_data;
       unsigned short reg)
{
 int i;
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

 for (i = 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if ((inb(chip->port+AC97_STATUS) & (AC97_BUSY)) == 0)
  ;
  udelay(10);
 }
 outl((reg << 24

 for (i = 0; i <snd_card_free(card);
  if ((inb(chip->port+AC97_STATUS) & (AC97_DATA_AVAIL)) != 0)
   break;
  udelay(10);return err;
 }
 return inw(chip->port+AC97_READ
}

static void snd_als300_ac97_write(struct snd_ac97 *ac97,
    unsigned short reg, unsigned short val)
{
 int i;
 struct snd_als300 *.id_table = snd_als300_ds,

 for (i = probe = snd_als300_probe,
  if ((inb(chip->port+AC97_STATUS) & (AC97_BUSY)) == 0)
   break;
  udelay(10);
 }
 utl(reg << 24)) val, hip-port+AC97_ACCESS
}

static int }
{
 struct
 struct snd_ac97_template java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 int err;
 static const struct snd_ac97_bus_ops ops = {
  .write = snd_als300_ac97_write,
  .read = snd_als300_ac97_read,
 };

 err = snd_ac97_bus(chip->card, 0, &ops, NULL, &bus);
 if (err < 0)
  return err;

 memset(&ac97, 0, sizeof(ac97));
 ac97.private_data = chip;

 return snd_ac97_mixer(bus, &ac97, &chip->ac97);
}

/* hardware definition
 *
 * In AC97 mode, we always use 48k/16bit/stereo.
 * Any request to change data type is ignored by
 * the card when it is running outside of legacy
 * mode.
 */
java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
{
 .info =   (SNDRV_PCM_INFO_MMAP |
    SNDRV_PCM_INFO_INTERLEAVED |
    SNDRV_PCM_INFO_PAUSE |
    SNDRV_PCM_INFO_MMAP_VALIDt knowmuch aboutALS300+yet
 .formats =  SNDRV_PCM_FMTBIT_S16,
 .rates =  SNDRV_PCM_RATE_48000,
 .* printrevisionnumber now*/
 .rate_max = d-shortname, "LS300+ Rev %)",chip-revision);
 .channels_min =  2,
 .channels_max =  2,
 .buffer_bytes_max
 .period_bytes_min  sprintf(>shortname,"LS300 (ev %),' +
 .period_bytes_max=32 *1024,
 .periods_min =  2,
 .   2,
};

static const struct snd_pcm_hardware snd_als300_capture_hw =
{
 .info =   (SNDRV_PCM_INFO_MMAP |
    SNDRV_PCM_INFO_INTERLEAVED |
    SNDRV_PCM_INFO_PAUSE |
    SNDRV_PCM_INFO_MMAP_VALID
 .formats =  java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 0
 . java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 .rate_min =  48000,
 .rate_max =  48000,
 .channels_min =  2,
 .channels_max =  2,
 .static struct pci_driver als300_driver = {
 .period_bytes_min = 64,
 .period_bytes_max = 32 * 1024,
 periods_min = 2,
 .periods_max =  2,
};java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static int snd_als300_playback_open(struct snd_pcm_substream *substream)
{
 struct snd_als300 *chip =.driver ={
 struct snd_pcm_runtime *java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 23
 truct snd_als300_substream_data *data = kzalloc(sizeof(*data),
   };

 if (!data)
  return -ENOMEM;
 chip->playback_substream = substream;
 >hw   snd_als300_playback_hw;
 runtime->private_data = data;
 data->control_register = PLAYBACK_CONTROL;
 data->block_counter_register = PLAYBACK_BLOCK_COUNTER;
 return 0;
}

static int snd_als300_playback_close(struct snd_pcm_substream *substream)
{
 struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 struct snd_als300_substream_data *data;

 data = substream->runtime->private_data;
 kfree(data);
 chip->playback_substream = NULL;
 return 0;
}

static int snd_als300_capture_open(struct snd_pcm_substream *substream)
{
 struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 struct snd_pcm_runtime *runtime = substream->runtime;
 struct snd_als300_substream_data *data = kzalloc(sizeof(*data),
        GFP_KERNEL);

 if (!data)
  return -ENOMEM;
 chip->capture_substream = substream;
 runtime->hw = snd_als300_capture_hw;
 runtime->private_data = data;
 data->control_register = RECORD_CONTROL;
 data->block_counter_register = RECORD_BLOCK_COUNTER;
 return 0;
}

static int snd_als300_capture_close(struct snd_pcm_substream *substream)
{
 struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 struct snd_als300_substream_data *data;

 data = substream->runtime->private_data;
 kfree(data);
 chip->capture_substream = NULL;
 return 0;
}

static int snd_als300_playback_prepare(struct snd_pcm_substream *substream)
{
 u32 tmp;
 struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 struct snd_pcm_runtime *runtime = substream->runtime;
 unsigned short period_bytes = snd_pcm_lib_period_bytes(substream);
 unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
 
 spin_lock_irq(&chip->reg_lock);
 tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL);
 tmp &= ~TRANSFER_START;

 snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n",
      period_bytes, buffer_bytes);
 
 /* set block size */
 tmp &= 0xffff0000;
 tmp |= period_bytes - 1;
 snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL, tmp);

 /* set dma area */
 snd_als300_gcr_write(chip->port, PLAYBACK_START,
     runtime->dma_addr);
 snd_als300_gcr_write(chip->port, PLAYBACK_END,
     runtime->dma_addr + buffer_bytes - 1);
 spin_unlock_irq(&chip->reg_lock);
 return 0;
}

static int snd_als300_capture_prepare(struct snd_pcm_substream *substream)
{
 u32 tmp;
 struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 struct snd_pcm_runtime *runtime = substream->runtime;
 unsigned short period_bytes = snd_pcm_lib_period_bytes(substream);
 unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream);

 spin_lock_irq(&chip->reg_lock);
 tmp = snd_als300_gcr_read(chip->port, RECORD_CONTROL);
 tmp &= ~TRANSFER_START;

 snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n", period_bytes,
       buffer_bytes);

 /* set block size */
 tmp &= 0xffff0000;
 tmp |= period_bytes - 1;

 /* set dma area */
 snd_als300_gcr_write(chip->port, RECORD_CONTROL, tmp);
 snd_als300_gcr_write(chip->port, RECORD_START,
     runtime->dma_addr);
 snd_als300_gcr_write(chip->port, RECORD_END,
     runtime->dma_addr + buffer_bytes - 1);
 spin_unlock_irq(&chip->reg_lock);
 return 0;
}

static int snd_als300_trigger(struct snd_pcm_substream *substream, int cmd)
{
 struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 u32 tmp;
 struct snd_als300_substream_data *data;
 unsigned short reg;
 int ret = 0;

 data = substream->runtime->private_data;
 reg = data->control_register;

 spin_lock(&chip->reg_lock);
 switch (cmd) {
 case SNDRV_PCM_TRIGGER_START:
 case SNDRV_PCM_TRIGGER_RESUME:
  tmp = snd_als300_gcr_read(chip->port, reg);
  data->period_flipflop = 1;
  snd_als300_gcr_write(chip->port, reg, tmp | TRANSFER_START);
  snd_als300_dbgplay("TRIGGER START\n");
  break;
 case SNDRV_PCM_TRIGGER_STOP:
 case SNDRV_PCM_TRIGGER_SUSPEND:
  tmp = snd_als300_gcr_read(chip->port, reg);
  snd_als300_gcr_write(chip->port, reg, tmp & ~TRANSFER_START);
  snd_als300_dbgplay("TRIGGER STOP\n");
  break;
 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  tmp = snd_als300_gcr_read(chip->port, reg);
  snd_als300_gcr_write(chip->port, reg, tmp | FIFO_PAUSE);
  snd_als300_dbgplay("TRIGGER PAUSE\n");
  break;
 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  tmp = snd_als300_gcr_read(chip->port, reg);
  snd_als300_gcr_write(chip->port, reg, tmp & ~FIFO_PAUSE);
  snd_als300_dbgplay("TRIGGER RELEASE\n");
  break;
 default:
  snd_als300_dbgplay("TRIGGER INVALID\n");
  ret = -EINVAL;
 }
 spin_unlock(&chip->reg_lock);
 return ret;
}

static snd_pcm_uframes_t snd_als300_pointer(struct snd_pcm_substream *substream)
{
 u16 current_ptr;
 struct snd_als300 *chip = snd_pcm_substream_chip(substream);
 struct snd_als300_substream_data *data;
 unsigned short period_bytes;

 data = substream->runtime->private_data;
 period_bytes = snd_pcm_lib_period_bytes(substream);
 
 spin_lock(&chip->reg_lock);
 current_ptr = (u16) snd_als300_gcr_read(chip->port,
     data->block_counter_register) + 4;
 spin_unlock(&chip->reg_lock);
 if (current_ptr > period_bytes)
  current_ptr = 0;
 else
  current_ptr = period_bytes - current_ptr;

 if (data->period_flipflop == 0)
  current_ptr += period_bytes;
 snd_als300_dbgplay("Pointer (bytes): %d\n", current_ptr);
 return bytes_to_frames(substream->runtime, current_ptr);
}

static const struct snd_pcm_ops snd_als300_playback_ops = {
 .open =  snd_als300_playback_open,
 .close = snd_als300_playback_close,
 .prepare = snd_als300_playback_prepare,
 .trigger = snd_als300_trigger,
 .pointer = snd_als300_pointer,
};

static const struct snd_pcm_ops snd_als300_capture_ops = {
 .open =  snd_als300_capture_open,
 .close = snd_als300_capture_close,
 .prepare = snd_als300_capture_prepare,
 .trigger = snd_als300_trigger,
 .pointer = snd_als300_pointer,
};

static int snd_als300_new_pcm(struct snd_als300 *chip)
{
 struct snd_pcm *pcm;
 int err;

 err = snd_pcm_new(chip->card, "ALS300", 0, 1, 1, &pcm);
 if (err < 0)
  return err;
 pcm->private_data = chip;
 strscpy(pcm->name, "ALS300");
 chip->pcm = pcm;

 /* set operators */
 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
    &snd_als300_playback_ops);
 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
    &snd_als300_capture_ops);

 /* pre-allocation of buffers */
 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
           64*1024, 64*1024);
 return 0;
}

static void snd_als300_init(struct snd_als300 *chip)
{
 unsigned long flags;
 u32 tmp;
 
 spin_lock_irqsave(&chip->reg_lock, flags);
 chip->revision = (snd_als300_gcr_read(chip->port, MISC_CONTROL) >> 16)
        & 0x0000000F;
 /* Setup DRAM */
 tmp = snd_als300_gcr_read(chip->port, DRAM_WRITE_CONTROL);
 snd_als300_gcr_write(chip->port, DRAM_WRITE_CONTROL,
      (tmp | DRAM_MODE_2)
      & ~WRITE_TRANS_START);

 /* Enable IRQ output */
 snd_als300_set_irq_flag(chip, IRQ_ENABLE);

 /* Unmute hardware devices so their outputs get routed to
  * the onboard mixer */
 tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL);
 snd_als300_gcr_write(chip->port, MISC_CONTROL,
   tmp | VMUTE_NORMAL | MMUTE_NORMAL);

 /* Reset volumes */
 snd_als300_gcr_write(chip->port, MUS_VOC_VOL, 0);

 /* Make sure playback transfer is stopped */
 tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL);
 snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL,
   tmp & ~TRANSFER_START);
 spin_unlock_irqrestore(&chip->reg_lock, flags);
}

static int snd_als300_create(struct snd_card *card,
        struct pci_dev *pci, int chip_type)
{
 struct snd_als300 *chip = card->private_data;
 void *irq_handler;
 int err;

 err = pcim_enable_device(pci);
 if (err < 0)
  return err;

 if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(28))) {
  dev_err(card->dev, "error setting 28bit DMA mask\n");
  return -ENXIO;
 }
 pci_set_master(pci);

 chip->card = card;
 chip->pci = pci;
 chip->irq = -1;
 chip->chip_type = chip_type;
 spin_lock_init(&chip->reg_lock);

 err = pcim_request_all_regions(pci, "ALS300");
 if (err < 0)
  return err;

 chip->port = pci_resource_start(pci, 0);

 if (chip->chip_type == DEVICE_ALS300_PLUS)
  irq_handler = snd_als300plus_interrupt;
 else
  irq_handler = snd_als300_interrupt;

 if (devm_request_irq(&pci->dev, pci->irq, irq_handler, IRQF_SHARED,
        KBUILD_MODNAME, chip)) {
  dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
  return -EBUSY;
 }
 chip->irq = pci->irq;
 card->sync_irq = chip->irq;
 card->private_free = snd_als300_free;

 snd_als300_init(chip);

 err = snd_als300_ac97(chip);
 if (err < 0) {
  dev_err(card->dev, "Could not create ac97\n");
  return err;
 }

 err = snd_als300_new_pcm(chip);
 if (err < 0) {
  dev_err(card->dev, "Could not create PCM\n");
  return err;
 }

 return 0;
}

static int snd_als300_suspend(struct device *dev)
{
 struct snd_card *card = dev_get_drvdata(dev);
 struct snd_als300 *chip = card->private_data;

 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 snd_ac97_suspend(chip->ac97);
 return 0;
}

static int snd_als300_resume(struct device *dev)
{
 struct snd_card *card = dev_get_drvdata(dev);
 struct snd_als300 *chip = card->private_data;

 snd_als300_init(chip);
 snd_ac97_resume(chip->ac97);

 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
 return 0;
}

static DEFINE_SIMPLE_DEV_PM_OPS(snd_als300_pm, snd_als300_suspend, snd_als300_resume);

static int snd_als300_probe(struct pci_dev *pci,
                             const struct pci_device_id *pci_id)
{
 static int dev;
 struct snd_card *card;
 struct snd_als300 *chip;
 int err, chip_type;

 if (dev >= SNDRV_CARDS)
  return -ENODEV;
 if (!enable[dev]) {
  dev++;
  return -ENOENT;
 }

 err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    sizeof(*chip), &card);
 if (err < 0)
  return err;
 chip = card->private_data;

 chip_type = pci_id->driver_data;

 err = snd_als300_create(card, pci, chip_type);
 if (err < 0)
  goto error;

 strscpy(card->driver, "ALS300");
 if (chip->chip_type == DEVICE_ALS300_PLUS)
  /* don't know much about ALS300+ yet
   * print revision number for now */
  sprintf(card->shortname, "ALS300+ (Rev. %d)", chip->revision);
 else
  sprintf(card->shortname, "ALS300 (Rev. %c)", 'A' +
       chip->revision - 1);
 sprintf(card->longname, "%s at 0x%lx irq %i",
    card->shortname, chip->port, chip->irq);

 err = snd_card_register(card);
 if (err < 0)
  goto error;

 pci_set_drvdata(pci, card);
 dev++;
 return 0;

 error:
 snd_card_free(card);
 return err;
}

static struct pci_driver als300_driver = {
 .name = KBUILD_MODNAME,
 .id_table = snd_als300_ids,
 .probe = snd_als300_probe,
 .driver = {
  .pm = &snd_als300_pm,
 },
};

module_pci_driver(als300_driver);