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 snd_pcm_lib_free_pages(substream); 382b3a70d5eSAsh Willis return 0; 383b3a70d5eSAsh Willis } 384b3a70d5eSAsh Willis 385b3a70d5eSAsh Willis static int snd_als300_capture_open(struct snd_pcm_substream *substream) 386b3a70d5eSAsh Willis { 387b3a70d5eSAsh Willis struct snd_als300 *chip = snd_pcm_substream_chip(substream); 388b3a70d5eSAsh Willis struct snd_pcm_runtime *runtime = substream->runtime; 389b3a70d5eSAsh Willis struct snd_als300_substream_data *data = kzalloc(sizeof(*data), 390b3a70d5eSAsh Willis GFP_KERNEL); 391b3a70d5eSAsh Willis 39221b3de88SDenis Kirjanov if (!data) 39321b3de88SDenis Kirjanov return -ENOMEM; 394b3a70d5eSAsh Willis chip->capture_substream = substream; 395b3a70d5eSAsh Willis runtime->hw = snd_als300_capture_hw; 396b3a70d5eSAsh Willis runtime->private_data = data; 397b3a70d5eSAsh Willis data->control_register = RECORD_CONTROL; 398b3a70d5eSAsh Willis data->block_counter_register = RECORD_BLOCK_COUNTER; 399b3a70d5eSAsh Willis return 0; 400b3a70d5eSAsh Willis } 401b3a70d5eSAsh Willis 402b3a70d5eSAsh Willis static int snd_als300_capture_close(struct snd_pcm_substream *substream) 403b3a70d5eSAsh Willis { 404b3a70d5eSAsh Willis struct snd_als300 *chip = snd_pcm_substream_chip(substream); 405b3a70d5eSAsh Willis struct snd_als300_substream_data *data; 406b3a70d5eSAsh Willis 407b3a70d5eSAsh Willis data = substream->runtime->private_data; 408b3a70d5eSAsh Willis kfree(data); 409b3a70d5eSAsh Willis chip->capture_substream = NULL; 410b3a70d5eSAsh Willis snd_pcm_lib_free_pages(substream); 411b3a70d5eSAsh Willis return 0; 412b3a70d5eSAsh Willis } 413b3a70d5eSAsh Willis 414b3a70d5eSAsh Willis static int snd_als300_pcm_hw_params(struct snd_pcm_substream *substream, 415d1d985f0STakashi Iwai struct snd_pcm_hw_params *hw_params) 416b3a70d5eSAsh Willis { 417b3a70d5eSAsh Willis return snd_pcm_lib_malloc_pages(substream, 418b3a70d5eSAsh Willis params_buffer_bytes(hw_params)); 419b3a70d5eSAsh Willis } 420b3a70d5eSAsh Willis 421b3a70d5eSAsh Willis static int snd_als300_pcm_hw_free(struct snd_pcm_substream *substream) 422b3a70d5eSAsh Willis { 423b3a70d5eSAsh Willis return snd_pcm_lib_free_pages(substream); 424b3a70d5eSAsh Willis } 425b3a70d5eSAsh Willis 426b3a70d5eSAsh Willis static int snd_als300_playback_prepare(struct snd_pcm_substream *substream) 427b3a70d5eSAsh Willis { 428b3a70d5eSAsh Willis u32 tmp; 429b3a70d5eSAsh Willis struct snd_als300 *chip = snd_pcm_substream_chip(substream); 430b3a70d5eSAsh Willis struct snd_pcm_runtime *runtime = substream->runtime; 431b3a70d5eSAsh Willis unsigned short period_bytes = snd_pcm_lib_period_bytes(substream); 432b3a70d5eSAsh Willis unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream); 433b3a70d5eSAsh Willis 434b3a70d5eSAsh Willis spin_lock_irq(&chip->reg_lock); 435b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL); 436b3a70d5eSAsh Willis tmp &= ~TRANSFER_START; 437b3a70d5eSAsh Willis 438b3a70d5eSAsh Willis snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n", 439b3a70d5eSAsh Willis period_bytes, buffer_bytes); 440b3a70d5eSAsh Willis 441b3a70d5eSAsh Willis /* set block size */ 442b3a70d5eSAsh Willis tmp &= 0xffff0000; 443b3a70d5eSAsh Willis tmp |= period_bytes - 1; 444b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL, tmp); 445b3a70d5eSAsh Willis 446b3a70d5eSAsh Willis /* set dma area */ 447b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, PLAYBACK_START, 448b3a70d5eSAsh Willis runtime->dma_addr); 449b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, PLAYBACK_END, 450b3a70d5eSAsh Willis runtime->dma_addr + buffer_bytes - 1); 451b3a70d5eSAsh Willis spin_unlock_irq(&chip->reg_lock); 452b3a70d5eSAsh Willis return 0; 453b3a70d5eSAsh Willis } 454b3a70d5eSAsh Willis 455b3a70d5eSAsh Willis static int snd_als300_capture_prepare(struct snd_pcm_substream *substream) 456b3a70d5eSAsh Willis { 457b3a70d5eSAsh Willis u32 tmp; 458b3a70d5eSAsh Willis struct snd_als300 *chip = snd_pcm_substream_chip(substream); 459b3a70d5eSAsh Willis struct snd_pcm_runtime *runtime = substream->runtime; 460b3a70d5eSAsh Willis unsigned short period_bytes = snd_pcm_lib_period_bytes(substream); 461b3a70d5eSAsh Willis unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream); 462b3a70d5eSAsh Willis 463b3a70d5eSAsh Willis spin_lock_irq(&chip->reg_lock); 464b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, RECORD_CONTROL); 465b3a70d5eSAsh Willis tmp &= ~TRANSFER_START; 466b3a70d5eSAsh Willis 467b3a70d5eSAsh Willis snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n", period_bytes, 468b3a70d5eSAsh Willis buffer_bytes); 469b3a70d5eSAsh Willis 470b3a70d5eSAsh Willis /* set block size */ 471b3a70d5eSAsh Willis tmp &= 0xffff0000; 472b3a70d5eSAsh Willis tmp |= period_bytes - 1; 473b3a70d5eSAsh Willis 474b3a70d5eSAsh Willis /* set dma area */ 475b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, RECORD_CONTROL, tmp); 476b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, RECORD_START, 477b3a70d5eSAsh Willis runtime->dma_addr); 478b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, RECORD_END, 479b3a70d5eSAsh Willis runtime->dma_addr + buffer_bytes - 1); 480b3a70d5eSAsh Willis spin_unlock_irq(&chip->reg_lock); 481b3a70d5eSAsh Willis return 0; 482b3a70d5eSAsh Willis } 483b3a70d5eSAsh Willis 484b3a70d5eSAsh Willis static int snd_als300_trigger(struct snd_pcm_substream *substream, int cmd) 485b3a70d5eSAsh Willis { 486b3a70d5eSAsh Willis struct snd_als300 *chip = snd_pcm_substream_chip(substream); 487b3a70d5eSAsh Willis u32 tmp; 488b3a70d5eSAsh Willis struct snd_als300_substream_data *data; 489b3a70d5eSAsh Willis unsigned short reg; 490b3a70d5eSAsh Willis int ret = 0; 491b3a70d5eSAsh Willis 492b3a70d5eSAsh Willis data = substream->runtime->private_data; 493b3a70d5eSAsh Willis reg = data->control_register; 494b3a70d5eSAsh Willis 495b3a70d5eSAsh Willis spin_lock(&chip->reg_lock); 496b3a70d5eSAsh Willis switch (cmd) { 497b3a70d5eSAsh Willis case SNDRV_PCM_TRIGGER_START: 498b3a70d5eSAsh Willis case SNDRV_PCM_TRIGGER_RESUME: 499b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, reg); 500b3a70d5eSAsh Willis data->period_flipflop = 1; 501b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, reg, tmp | TRANSFER_START); 502b3a70d5eSAsh Willis snd_als300_dbgplay("TRIGGER START\n"); 503b3a70d5eSAsh Willis break; 504b3a70d5eSAsh Willis case SNDRV_PCM_TRIGGER_STOP: 505b3a70d5eSAsh Willis case SNDRV_PCM_TRIGGER_SUSPEND: 506b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, reg); 507b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, reg, tmp & ~TRANSFER_START); 508b3a70d5eSAsh Willis snd_als300_dbgplay("TRIGGER STOP\n"); 509b3a70d5eSAsh Willis break; 510b3a70d5eSAsh Willis case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 511b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, reg); 512b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, reg, tmp | FIFO_PAUSE); 513b3a70d5eSAsh Willis snd_als300_dbgplay("TRIGGER PAUSE\n"); 514b3a70d5eSAsh Willis break; 515b3a70d5eSAsh Willis case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 516b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, reg); 517b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, reg, tmp & ~FIFO_PAUSE); 518b3a70d5eSAsh Willis snd_als300_dbgplay("TRIGGER RELEASE\n"); 519b3a70d5eSAsh Willis break; 520b3a70d5eSAsh Willis default: 521b3a70d5eSAsh Willis snd_als300_dbgplay("TRIGGER INVALID\n"); 522b3a70d5eSAsh Willis ret = -EINVAL; 523b3a70d5eSAsh Willis } 524b3a70d5eSAsh Willis spin_unlock(&chip->reg_lock); 525b3a70d5eSAsh Willis return ret; 526b3a70d5eSAsh Willis } 527b3a70d5eSAsh Willis 528b3a70d5eSAsh Willis static snd_pcm_uframes_t snd_als300_pointer(struct snd_pcm_substream *substream) 529b3a70d5eSAsh Willis { 530b3a70d5eSAsh Willis u16 current_ptr; 531b3a70d5eSAsh Willis struct snd_als300 *chip = snd_pcm_substream_chip(substream); 532b3a70d5eSAsh Willis struct snd_als300_substream_data *data; 533b3a70d5eSAsh Willis unsigned short period_bytes; 534b3a70d5eSAsh Willis 535b3a70d5eSAsh Willis data = substream->runtime->private_data; 536b3a70d5eSAsh Willis period_bytes = snd_pcm_lib_period_bytes(substream); 537b3a70d5eSAsh Willis 538b3a70d5eSAsh Willis spin_lock(&chip->reg_lock); 539b3a70d5eSAsh Willis current_ptr = (u16) snd_als300_gcr_read(chip->port, 540b3a70d5eSAsh Willis data->block_counter_register) + 4; 541b3a70d5eSAsh Willis spin_unlock(&chip->reg_lock); 542b3a70d5eSAsh Willis if (current_ptr > period_bytes) 543b3a70d5eSAsh Willis current_ptr = 0; 544b3a70d5eSAsh Willis else 545b3a70d5eSAsh Willis current_ptr = period_bytes - current_ptr; 546b3a70d5eSAsh Willis 547b3a70d5eSAsh Willis if (data->period_flipflop == 0) 548b3a70d5eSAsh Willis current_ptr += period_bytes; 549b3a70d5eSAsh Willis snd_als300_dbgplay("Pointer (bytes): %d\n", current_ptr); 550b3a70d5eSAsh Willis return bytes_to_frames(substream->runtime, current_ptr); 551b3a70d5eSAsh Willis } 552b3a70d5eSAsh Willis 5536769e988SJulia Lawall static const struct snd_pcm_ops snd_als300_playback_ops = { 554b3a70d5eSAsh Willis .open = snd_als300_playback_open, 555b3a70d5eSAsh Willis .close = snd_als300_playback_close, 556b3a70d5eSAsh Willis .ioctl = snd_pcm_lib_ioctl, 557b3a70d5eSAsh Willis .hw_params = snd_als300_pcm_hw_params, 558b3a70d5eSAsh Willis .hw_free = snd_als300_pcm_hw_free, 559b3a70d5eSAsh Willis .prepare = snd_als300_playback_prepare, 560b3a70d5eSAsh Willis .trigger = snd_als300_trigger, 561b3a70d5eSAsh Willis .pointer = snd_als300_pointer, 562b3a70d5eSAsh Willis }; 563b3a70d5eSAsh Willis 5646769e988SJulia Lawall static const struct snd_pcm_ops snd_als300_capture_ops = { 565b3a70d5eSAsh Willis .open = snd_als300_capture_open, 566b3a70d5eSAsh Willis .close = snd_als300_capture_close, 567b3a70d5eSAsh Willis .ioctl = snd_pcm_lib_ioctl, 568b3a70d5eSAsh Willis .hw_params = snd_als300_pcm_hw_params, 569b3a70d5eSAsh Willis .hw_free = snd_als300_pcm_hw_free, 570b3a70d5eSAsh Willis .prepare = snd_als300_capture_prepare, 571b3a70d5eSAsh Willis .trigger = snd_als300_trigger, 572b3a70d5eSAsh Willis .pointer = snd_als300_pointer, 573b3a70d5eSAsh Willis }; 574b3a70d5eSAsh Willis 575e23e7a14SBill Pemberton static int snd_als300_new_pcm(struct snd_als300 *chip) 576b3a70d5eSAsh Willis { 577b3a70d5eSAsh Willis struct snd_pcm *pcm; 578b3a70d5eSAsh Willis int err; 579b3a70d5eSAsh Willis 580b3a70d5eSAsh Willis err = snd_pcm_new(chip->card, "ALS300", 0, 1, 1, &pcm); 581b3a70d5eSAsh Willis if (err < 0) 582b3a70d5eSAsh Willis return err; 583b3a70d5eSAsh Willis pcm->private_data = chip; 584b3a70d5eSAsh Willis strcpy(pcm->name, "ALS300"); 585b3a70d5eSAsh Willis chip->pcm = pcm; 586b3a70d5eSAsh Willis 587b3a70d5eSAsh Willis /* set operators */ 588b3a70d5eSAsh Willis snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 589b3a70d5eSAsh Willis &snd_als300_playback_ops); 590b3a70d5eSAsh Willis snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 591b3a70d5eSAsh Willis &snd_als300_capture_ops); 592b3a70d5eSAsh Willis 593b3a70d5eSAsh Willis /* pre-allocation of buffers */ 594b3a70d5eSAsh Willis snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 5956974f8adSTakashi Iwai &chip->pci->dev, 5966974f8adSTakashi Iwai 64*1024, 64*1024); 597b3a70d5eSAsh Willis return 0; 598b3a70d5eSAsh Willis } 599b3a70d5eSAsh Willis 600b3a70d5eSAsh Willis static void snd_als300_init(struct snd_als300 *chip) 601b3a70d5eSAsh Willis { 602b3a70d5eSAsh Willis unsigned long flags; 603b3a70d5eSAsh Willis u32 tmp; 604b3a70d5eSAsh Willis 605b3a70d5eSAsh Willis spin_lock_irqsave(&chip->reg_lock, flags); 606b3a70d5eSAsh Willis chip->revision = (snd_als300_gcr_read(chip->port, MISC_CONTROL) >> 16) 607b3a70d5eSAsh Willis & 0x0000000F; 608b3a70d5eSAsh Willis /* Setup DRAM */ 609b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, DRAM_WRITE_CONTROL); 610b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, DRAM_WRITE_CONTROL, 611b3a70d5eSAsh Willis (tmp | DRAM_MODE_2) 612b3a70d5eSAsh Willis & ~WRITE_TRANS_START); 613b3a70d5eSAsh Willis 614b3a70d5eSAsh Willis /* Enable IRQ output */ 615b3a70d5eSAsh Willis snd_als300_set_irq_flag(chip, IRQ_ENABLE); 616b3a70d5eSAsh Willis 617b3a70d5eSAsh Willis /* Unmute hardware devices so their outputs get routed to 618b3a70d5eSAsh Willis * the onboard mixer */ 619b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL); 620b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, MISC_CONTROL, 621b3a70d5eSAsh Willis tmp | VMUTE_NORMAL | MMUTE_NORMAL); 622b3a70d5eSAsh Willis 623b3a70d5eSAsh Willis /* Reset volumes */ 624b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, MUS_VOC_VOL, 0); 625b3a70d5eSAsh Willis 626b3a70d5eSAsh Willis /* Make sure playback transfer is stopped */ 627b3a70d5eSAsh Willis tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL); 628b3a70d5eSAsh Willis snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL, 629b3a70d5eSAsh Willis tmp & ~TRANSFER_START); 630b3a70d5eSAsh Willis spin_unlock_irqrestore(&chip->reg_lock, flags); 631b3a70d5eSAsh Willis } 632b3a70d5eSAsh Willis 633e23e7a14SBill Pemberton static int snd_als300_create(struct snd_card *card, 634b3a70d5eSAsh Willis struct pci_dev *pci, int chip_type, 635b3a70d5eSAsh Willis struct snd_als300 **rchip) 636b3a70d5eSAsh Willis { 637b3a70d5eSAsh Willis struct snd_als300 *chip; 638b3a70d5eSAsh Willis void *irq_handler; 639b3a70d5eSAsh Willis int err; 640b3a70d5eSAsh Willis 641d1d985f0STakashi Iwai static struct snd_device_ops ops = { 642b3a70d5eSAsh Willis .dev_free = snd_als300_dev_free, 643b3a70d5eSAsh Willis }; 644b3a70d5eSAsh Willis *rchip = NULL; 645b3a70d5eSAsh Willis 646b3a70d5eSAsh Willis if ((err = pci_enable_device(pci)) < 0) 647b3a70d5eSAsh Willis return err; 648b3a70d5eSAsh Willis 649412b979cSQuentin Lambert if (dma_set_mask(&pci->dev, DMA_BIT_MASK(28)) < 0 || 650412b979cSQuentin Lambert dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(28)) < 0) { 651c778f7ecSTakashi Iwai dev_err(card->dev, "error setting 28bit DMA mask\n"); 652b3a70d5eSAsh Willis pci_disable_device(pci); 653b3a70d5eSAsh Willis return -ENXIO; 654b3a70d5eSAsh Willis } 655b3a70d5eSAsh Willis pci_set_master(pci); 656b3a70d5eSAsh Willis 657b3a70d5eSAsh Willis chip = kzalloc(sizeof(*chip), GFP_KERNEL); 658b3a70d5eSAsh Willis if (chip == NULL) { 659b3a70d5eSAsh Willis pci_disable_device(pci); 660b3a70d5eSAsh Willis return -ENOMEM; 661b3a70d5eSAsh Willis } 662b3a70d5eSAsh Willis 663b3a70d5eSAsh Willis chip->card = card; 664b3a70d5eSAsh Willis chip->pci = pci; 665b3a70d5eSAsh Willis chip->irq = -1; 666b3a70d5eSAsh Willis chip->chip_type = chip_type; 667b3a70d5eSAsh Willis spin_lock_init(&chip->reg_lock); 668b3a70d5eSAsh Willis 669b3a70d5eSAsh Willis if ((err = pci_request_regions(pci, "ALS300")) < 0) { 670b3a70d5eSAsh Willis kfree(chip); 671b3a70d5eSAsh Willis pci_disable_device(pci); 672b3a70d5eSAsh Willis return err; 673b3a70d5eSAsh Willis } 674b3a70d5eSAsh Willis chip->port = pci_resource_start(pci, 0); 675b3a70d5eSAsh Willis 676b3a70d5eSAsh Willis if (chip->chip_type == DEVICE_ALS300_PLUS) 677b3a70d5eSAsh Willis irq_handler = snd_als300plus_interrupt; 678b3a70d5eSAsh Willis else 679b3a70d5eSAsh Willis irq_handler = snd_als300_interrupt; 680b3a70d5eSAsh Willis 681437a5a46STakashi Iwai if (request_irq(pci->irq, irq_handler, IRQF_SHARED, 682934c2b6dSTakashi Iwai KBUILD_MODNAME, chip)) { 683c778f7ecSTakashi Iwai dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); 684b3a70d5eSAsh Willis snd_als300_free(chip); 685b3a70d5eSAsh Willis return -EBUSY; 686b3a70d5eSAsh Willis } 687b3a70d5eSAsh Willis chip->irq = pci->irq; 688b3a70d5eSAsh Willis 689b3a70d5eSAsh Willis 690b3a70d5eSAsh Willis snd_als300_init(chip); 691b3a70d5eSAsh Willis 69265ff2357SAsh Willis err = snd_als300_ac97(chip); 69365ff2357SAsh Willis if (err < 0) { 694c778f7ecSTakashi Iwai dev_err(card->dev, "Could not create ac97\n"); 695b3a70d5eSAsh Willis snd_als300_free(chip); 696b3a70d5eSAsh Willis return err; 697b3a70d5eSAsh Willis } 698b3a70d5eSAsh Willis 699b3a70d5eSAsh Willis if ((err = snd_als300_new_pcm(chip)) < 0) { 700c778f7ecSTakashi Iwai dev_err(card->dev, "Could not create PCM\n"); 701b3a70d5eSAsh Willis snd_als300_free(chip); 702b3a70d5eSAsh Willis return err; 703b3a70d5eSAsh Willis } 704b3a70d5eSAsh Willis 705b3a70d5eSAsh Willis if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, 706b3a70d5eSAsh Willis chip, &ops)) < 0) { 707b3a70d5eSAsh Willis snd_als300_free(chip); 708b3a70d5eSAsh Willis return err; 709b3a70d5eSAsh Willis } 710b3a70d5eSAsh Willis 711b3a70d5eSAsh Willis *rchip = chip; 712b3a70d5eSAsh Willis return 0; 713b3a70d5eSAsh Willis } 714b3a70d5eSAsh Willis 715c7561cd8STakashi Iwai #ifdef CONFIG_PM_SLEEP 71668cb2b55STakashi Iwai static int snd_als300_suspend(struct device *dev) 717b3a70d5eSAsh Willis { 71868cb2b55STakashi Iwai struct snd_card *card = dev_get_drvdata(dev); 719b3a70d5eSAsh Willis struct snd_als300 *chip = card->private_data; 720b3a70d5eSAsh Willis 721b3a70d5eSAsh Willis snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 722b3a70d5eSAsh Willis snd_ac97_suspend(chip->ac97); 723b3a70d5eSAsh Willis return 0; 724b3a70d5eSAsh Willis } 725b3a70d5eSAsh Willis 72668cb2b55STakashi Iwai static int snd_als300_resume(struct device *dev) 727b3a70d5eSAsh Willis { 72868cb2b55STakashi Iwai struct snd_card *card = dev_get_drvdata(dev); 729b3a70d5eSAsh Willis struct snd_als300 *chip = card->private_data; 730b3a70d5eSAsh Willis 731b3a70d5eSAsh Willis snd_als300_init(chip); 732b3a70d5eSAsh Willis snd_ac97_resume(chip->ac97); 733b3a70d5eSAsh Willis 734b3a70d5eSAsh Willis snd_power_change_state(card, SNDRV_CTL_POWER_D0); 735b3a70d5eSAsh Willis return 0; 736b3a70d5eSAsh Willis } 73768cb2b55STakashi Iwai 73868cb2b55STakashi Iwai static SIMPLE_DEV_PM_OPS(snd_als300_pm, snd_als300_suspend, snd_als300_resume); 73968cb2b55STakashi Iwai #define SND_ALS300_PM_OPS &snd_als300_pm 74068cb2b55STakashi Iwai #else 74168cb2b55STakashi Iwai #define SND_ALS300_PM_OPS NULL 742b3a70d5eSAsh Willis #endif 743b3a70d5eSAsh Willis 744e23e7a14SBill Pemberton static int snd_als300_probe(struct pci_dev *pci, 745b3a70d5eSAsh Willis const struct pci_device_id *pci_id) 746b3a70d5eSAsh Willis { 747b3a70d5eSAsh Willis static int dev; 748b3a70d5eSAsh Willis struct snd_card *card; 749b3a70d5eSAsh Willis struct snd_als300 *chip; 750b3a70d5eSAsh Willis int err, chip_type; 751b3a70d5eSAsh Willis 752b3a70d5eSAsh Willis if (dev >= SNDRV_CARDS) 753b3a70d5eSAsh Willis return -ENODEV; 754b3a70d5eSAsh Willis if (!enable[dev]) { 755b3a70d5eSAsh Willis dev++; 756b3a70d5eSAsh Willis return -ENOENT; 757b3a70d5eSAsh Willis } 758b3a70d5eSAsh Willis 75960c5772bSTakashi Iwai err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, 76060c5772bSTakashi Iwai 0, &card); 761b3a70d5eSAsh Willis 762e58de7baSTakashi Iwai if (err < 0) 763e58de7baSTakashi Iwai return err; 764b3a70d5eSAsh Willis 765b3a70d5eSAsh Willis chip_type = pci_id->driver_data; 766b3a70d5eSAsh Willis 767b3a70d5eSAsh Willis if ((err = snd_als300_create(card, pci, chip_type, &chip)) < 0) { 768b3a70d5eSAsh Willis snd_card_free(card); 769b3a70d5eSAsh Willis return err; 770b3a70d5eSAsh Willis } 771b3a70d5eSAsh Willis card->private_data = chip; 772b3a70d5eSAsh Willis 773b3a70d5eSAsh Willis strcpy(card->driver, "ALS300"); 774b3a70d5eSAsh Willis if (chip->chip_type == DEVICE_ALS300_PLUS) 775b3a70d5eSAsh Willis /* don't know much about ALS300+ yet 776b3a70d5eSAsh Willis * print revision number for now */ 777b3a70d5eSAsh Willis sprintf(card->shortname, "ALS300+ (Rev. %d)", chip->revision); 778b3a70d5eSAsh Willis else 779b3a70d5eSAsh Willis sprintf(card->shortname, "ALS300 (Rev. %c)", 'A' + 780b3a70d5eSAsh Willis chip->revision - 1); 781b3a70d5eSAsh Willis sprintf(card->longname, "%s at 0x%lx irq %i", 782b3a70d5eSAsh Willis card->shortname, chip->port, chip->irq); 783b3a70d5eSAsh Willis 784b3a70d5eSAsh Willis if ((err = snd_card_register(card)) < 0) { 785b3a70d5eSAsh Willis snd_card_free(card); 786b3a70d5eSAsh Willis return err; 787b3a70d5eSAsh Willis } 788b3a70d5eSAsh Willis pci_set_drvdata(pci, card); 789b3a70d5eSAsh Willis dev++; 790b3a70d5eSAsh Willis return 0; 791b3a70d5eSAsh Willis } 792b3a70d5eSAsh Willis 793e9f66d9bSTakashi Iwai static struct pci_driver als300_driver = { 7943733e424STakashi Iwai .name = KBUILD_MODNAME, 795b3a70d5eSAsh Willis .id_table = snd_als300_ids, 796b3a70d5eSAsh Willis .probe = snd_als300_probe, 797e23e7a14SBill Pemberton .remove = snd_als300_remove, 79868cb2b55STakashi Iwai .driver = { 79968cb2b55STakashi Iwai .pm = SND_ALS300_PM_OPS, 80068cb2b55STakashi Iwai }, 801b3a70d5eSAsh Willis }; 802b3a70d5eSAsh Willis 803e9f66d9bSTakashi Iwai module_pci_driver(als300_driver); 804