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