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