1175859bfSDavid Dillow /* 2175859bfSDavid Dillow * Driver for SiS7019 Audio Accelerator 3175859bfSDavid Dillow * 4175859bfSDavid Dillow * Copyright (C) 2004-2007, David Dillow 5175859bfSDavid Dillow * Written by David Dillow <dave@thedillows.org> 6175859bfSDavid Dillow * Inspired by the Trident 4D-WaveDX/NX driver. 7175859bfSDavid Dillow * 8175859bfSDavid Dillow * All rights reserved. 9175859bfSDavid Dillow * 10175859bfSDavid Dillow * This program is free software; you can redistribute it and/or modify 11175859bfSDavid Dillow * it under the terms of the GNU General Public License as published by 12175859bfSDavid Dillow * the Free Software Foundation, version 2. 13175859bfSDavid Dillow * 14175859bfSDavid Dillow * This program is distributed in the hope that it will be useful, 15175859bfSDavid Dillow * but WITHOUT ANY WARRANTY; without even the implied warranty of 16175859bfSDavid Dillow * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17175859bfSDavid Dillow * GNU General Public License for more details. 18175859bfSDavid Dillow * 19175859bfSDavid Dillow * You should have received a copy of the GNU General Public License 20175859bfSDavid Dillow * along with this program; if not, write to the Free Software 21175859bfSDavid Dillow * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22175859bfSDavid Dillow */ 23175859bfSDavid Dillow 24175859bfSDavid Dillow #include <sound/driver.h> 25175859bfSDavid Dillow #include <linux/init.h> 26175859bfSDavid Dillow #include <linux/pci.h> 27175859bfSDavid Dillow #include <linux/time.h> 28175859bfSDavid Dillow #include <linux/moduleparam.h> 29175859bfSDavid Dillow #include <linux/interrupt.h> 30175859bfSDavid Dillow #include <linux/delay.h> 31175859bfSDavid Dillow #include <sound/core.h> 32175859bfSDavid Dillow #include <sound/ac97_codec.h> 33175859bfSDavid Dillow #include <sound/initval.h> 34175859bfSDavid Dillow #include "sis7019.h" 35175859bfSDavid Dillow 36175859bfSDavid Dillow MODULE_AUTHOR("David Dillow <dave@thedillows.org>"); 37175859bfSDavid Dillow MODULE_DESCRIPTION("SiS7019"); 38175859bfSDavid Dillow MODULE_LICENSE("GPL"); 39175859bfSDavid Dillow MODULE_SUPPORTED_DEVICE("{{SiS,SiS7019 Audio Accelerator}}"); 40175859bfSDavid Dillow 41175859bfSDavid Dillow static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ 42175859bfSDavid Dillow static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 43175859bfSDavid Dillow static int enable = 1; 44175859bfSDavid Dillow 45175859bfSDavid Dillow module_param(index, int, 0444); 46175859bfSDavid Dillow MODULE_PARM_DESC(index, "Index value for SiS7019 Audio Accelerator."); 47175859bfSDavid Dillow module_param(id, charp, 0444); 48175859bfSDavid Dillow MODULE_PARM_DESC(id, "ID string for SiS7019 Audio Accelerator."); 49175859bfSDavid Dillow module_param(enable, bool, 0444); 50175859bfSDavid Dillow MODULE_PARM_DESC(enable, "Enable SiS7019 Audio Accelerator."); 51175859bfSDavid Dillow 52175859bfSDavid Dillow static struct pci_device_id snd_sis7019_ids[] = { 53175859bfSDavid Dillow { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x7019) }, 54175859bfSDavid Dillow { 0, } 55175859bfSDavid Dillow }; 56175859bfSDavid Dillow 57175859bfSDavid Dillow MODULE_DEVICE_TABLE(pci, snd_sis7019_ids); 58175859bfSDavid Dillow 59175859bfSDavid Dillow /* There are three timing modes for the voices. 60175859bfSDavid Dillow * 61175859bfSDavid Dillow * For both playback and capture, when the buffer is one or two periods long, 62175859bfSDavid Dillow * we use the hardware's built-in Mid-Loop Interrupt and End-Loop Interrupt 63175859bfSDavid Dillow * to let us know when the periods have ended. 64175859bfSDavid Dillow * 65175859bfSDavid Dillow * When performing playback with more than two periods per buffer, we set 66175859bfSDavid Dillow * the "Stop Sample Offset" and tell the hardware to interrupt us when we 67175859bfSDavid Dillow * reach it. We then update the offset and continue on until we are 68175859bfSDavid Dillow * interrupted for the next period. 69175859bfSDavid Dillow * 70175859bfSDavid Dillow * Capture channels do not have a SSO, so we allocate a playback channel to 71175859bfSDavid Dillow * use as a timer for the capture periods. We use the SSO on the playback 72175859bfSDavid Dillow * channel to clock out virtual periods, and adjust the virtual period length 73175859bfSDavid Dillow * to maintain synchronization. This algorithm came from the Trident driver. 74175859bfSDavid Dillow * 75175859bfSDavid Dillow * FIXME: It'd be nice to make use of some of the synth features in the 76175859bfSDavid Dillow * hardware, but a woeful lack of documentation is a significant roadblock. 77175859bfSDavid Dillow */ 78175859bfSDavid Dillow struct voice { 79175859bfSDavid Dillow u16 flags; 80175859bfSDavid Dillow #define VOICE_IN_USE 1 81175859bfSDavid Dillow #define VOICE_CAPTURE 2 82175859bfSDavid Dillow #define VOICE_SSO_TIMING 4 83175859bfSDavid Dillow #define VOICE_SYNC_TIMING 8 84175859bfSDavid Dillow u16 sync_cso; 85175859bfSDavid Dillow u16 period_size; 86175859bfSDavid Dillow u16 buffer_size; 87175859bfSDavid Dillow u16 sync_period_size; 88175859bfSDavid Dillow u16 sync_buffer_size; 89175859bfSDavid Dillow u32 sso; 90175859bfSDavid Dillow u32 vperiod; 91175859bfSDavid Dillow struct snd_pcm_substream *substream; 92175859bfSDavid Dillow struct voice *timing; 93175859bfSDavid Dillow void __iomem *ctrl_base; 94175859bfSDavid Dillow void __iomem *wave_base; 95175859bfSDavid Dillow void __iomem *sync_base; 96175859bfSDavid Dillow int num; 97175859bfSDavid Dillow }; 98175859bfSDavid Dillow 99175859bfSDavid Dillow /* We need four pages to store our wave parameters during a suspend. If 100175859bfSDavid Dillow * we're not doing power management, we still need to allocate a page 101175859bfSDavid Dillow * for the silence buffer. 102175859bfSDavid Dillow */ 103175859bfSDavid Dillow #ifdef CONFIG_PM 104175859bfSDavid Dillow #define SIS_SUSPEND_PAGES 4 105175859bfSDavid Dillow #else 106175859bfSDavid Dillow #define SIS_SUSPEND_PAGES 1 107175859bfSDavid Dillow #endif 108175859bfSDavid Dillow 109175859bfSDavid Dillow struct sis7019 { 110175859bfSDavid Dillow unsigned long ioport; 111175859bfSDavid Dillow void __iomem *ioaddr; 112175859bfSDavid Dillow int irq; 113175859bfSDavid Dillow int codecs_present; 114175859bfSDavid Dillow 115175859bfSDavid Dillow struct pci_dev *pci; 116175859bfSDavid Dillow struct snd_pcm *pcm; 117175859bfSDavid Dillow struct snd_card *card; 118175859bfSDavid Dillow struct snd_ac97 *ac97[3]; 119175859bfSDavid Dillow 120175859bfSDavid Dillow /* Protect against more than one thread hitting the AC97 121175859bfSDavid Dillow * registers (in a more polite manner than pounding the hardware 122175859bfSDavid Dillow * semaphore) 123175859bfSDavid Dillow */ 124175859bfSDavid Dillow struct mutex ac97_mutex; 125175859bfSDavid Dillow 126175859bfSDavid Dillow /* voice_lock protects allocation/freeing of the voice descriptions 127175859bfSDavid Dillow */ 128175859bfSDavid Dillow spinlock_t voice_lock; 129175859bfSDavid Dillow 130175859bfSDavid Dillow struct voice voices[64]; 131175859bfSDavid Dillow struct voice capture_voice; 132175859bfSDavid Dillow 133175859bfSDavid Dillow /* Allocate pages to store the internal wave state during 134175859bfSDavid Dillow * suspends. When we're operating, this can be used as a silence 135175859bfSDavid Dillow * buffer for a timing channel. 136175859bfSDavid Dillow */ 137175859bfSDavid Dillow void *suspend_state[SIS_SUSPEND_PAGES]; 138175859bfSDavid Dillow 139175859bfSDavid Dillow int silence_users; 140175859bfSDavid Dillow dma_addr_t silence_dma_addr; 141175859bfSDavid Dillow }; 142175859bfSDavid Dillow 143175859bfSDavid Dillow #define SIS_PRIMARY_CODEC_PRESENT 0x0001 144175859bfSDavid Dillow #define SIS_SECONDARY_CODEC_PRESENT 0x0002 145175859bfSDavid Dillow #define SIS_TERTIARY_CODEC_PRESENT 0x0004 146175859bfSDavid Dillow 147175859bfSDavid Dillow /* The HW offset parameters (Loop End, Stop Sample, End Sample) have a 148175859bfSDavid Dillow * documented range of 8-0xfff8 samples. Given that they are 0-based, 149175859bfSDavid Dillow * that places our period/buffer range at 9-0xfff9 samples. That makes the 150175859bfSDavid Dillow * max buffer size 0xfff9 samples * 2 channels * 2 bytes per sample, and 151175859bfSDavid Dillow * max samples / min samples gives us the max periods in a buffer. 152175859bfSDavid Dillow * 153175859bfSDavid Dillow * We'll add a constraint upon open that limits the period and buffer sample 154175859bfSDavid Dillow * size to values that are legal for the hardware. 155175859bfSDavid Dillow */ 156175859bfSDavid Dillow static struct snd_pcm_hardware sis_playback_hw_info = { 157175859bfSDavid Dillow .info = (SNDRV_PCM_INFO_MMAP | 158175859bfSDavid Dillow SNDRV_PCM_INFO_MMAP_VALID | 159175859bfSDavid Dillow SNDRV_PCM_INFO_INTERLEAVED | 160175859bfSDavid Dillow SNDRV_PCM_INFO_BLOCK_TRANSFER | 161175859bfSDavid Dillow SNDRV_PCM_INFO_SYNC_START | 162175859bfSDavid Dillow SNDRV_PCM_INFO_RESUME), 163175859bfSDavid Dillow .formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 | 164175859bfSDavid Dillow SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE), 165175859bfSDavid Dillow .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_CONTINUOUS, 166175859bfSDavid Dillow .rate_min = 4000, 167175859bfSDavid Dillow .rate_max = 48000, 168175859bfSDavid Dillow .channels_min = 1, 169175859bfSDavid Dillow .channels_max = 2, 170175859bfSDavid Dillow .buffer_bytes_max = (0xfff9 * 4), 171175859bfSDavid Dillow .period_bytes_min = 9, 172175859bfSDavid Dillow .period_bytes_max = (0xfff9 * 4), 173175859bfSDavid Dillow .periods_min = 1, 174175859bfSDavid Dillow .periods_max = (0xfff9 / 9), 175175859bfSDavid Dillow }; 176175859bfSDavid Dillow 177175859bfSDavid Dillow static struct snd_pcm_hardware sis_capture_hw_info = { 178175859bfSDavid Dillow .info = (SNDRV_PCM_INFO_MMAP | 179175859bfSDavid Dillow SNDRV_PCM_INFO_MMAP_VALID | 180175859bfSDavid Dillow SNDRV_PCM_INFO_INTERLEAVED | 181175859bfSDavid Dillow SNDRV_PCM_INFO_BLOCK_TRANSFER | 182175859bfSDavid Dillow SNDRV_PCM_INFO_SYNC_START | 183175859bfSDavid Dillow SNDRV_PCM_INFO_RESUME), 184175859bfSDavid Dillow .formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 | 185175859bfSDavid Dillow SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE), 186175859bfSDavid Dillow .rates = SNDRV_PCM_RATE_48000, 187175859bfSDavid Dillow .rate_min = 4000, 188175859bfSDavid Dillow .rate_max = 48000, 189175859bfSDavid Dillow .channels_min = 1, 190175859bfSDavid Dillow .channels_max = 2, 191175859bfSDavid Dillow .buffer_bytes_max = (0xfff9 * 4), 192175859bfSDavid Dillow .period_bytes_min = 9, 193175859bfSDavid Dillow .period_bytes_max = (0xfff9 * 4), 194175859bfSDavid Dillow .periods_min = 1, 195175859bfSDavid Dillow .periods_max = (0xfff9 / 9), 196175859bfSDavid Dillow }; 197175859bfSDavid Dillow 198175859bfSDavid Dillow static void sis_update_sso(struct voice *voice, u16 period) 199175859bfSDavid Dillow { 200175859bfSDavid Dillow void __iomem *base = voice->ctrl_base; 201175859bfSDavid Dillow 202175859bfSDavid Dillow voice->sso += period; 203175859bfSDavid Dillow if (voice->sso >= voice->buffer_size) 204175859bfSDavid Dillow voice->sso -= voice->buffer_size; 205175859bfSDavid Dillow 206175859bfSDavid Dillow /* Enforce the documented hardware minimum offset */ 207175859bfSDavid Dillow if (voice->sso < 8) 208175859bfSDavid Dillow voice->sso = 8; 209175859bfSDavid Dillow 210175859bfSDavid Dillow /* The SSO is in the upper 16 bits of the register. */ 211175859bfSDavid Dillow writew(voice->sso & 0xffff, base + SIS_PLAY_DMA_SSO_ESO + 2); 212175859bfSDavid Dillow } 213175859bfSDavid Dillow 214175859bfSDavid Dillow static void sis_update_voice(struct voice *voice) 215175859bfSDavid Dillow { 216175859bfSDavid Dillow if (voice->flags & VOICE_SSO_TIMING) { 217175859bfSDavid Dillow sis_update_sso(voice, voice->period_size); 218175859bfSDavid Dillow } else if (voice->flags & VOICE_SYNC_TIMING) { 219175859bfSDavid Dillow int sync; 220175859bfSDavid Dillow 221175859bfSDavid Dillow /* If we've not hit the end of the virtual period, update 222175859bfSDavid Dillow * our records and keep going. 223175859bfSDavid Dillow */ 224175859bfSDavid Dillow if (voice->vperiod > voice->period_size) { 225175859bfSDavid Dillow voice->vperiod -= voice->period_size; 226175859bfSDavid Dillow if (voice->vperiod < voice->period_size) 227175859bfSDavid Dillow sis_update_sso(voice, voice->vperiod); 228175859bfSDavid Dillow else 229175859bfSDavid Dillow sis_update_sso(voice, voice->period_size); 230175859bfSDavid Dillow return; 231175859bfSDavid Dillow } 232175859bfSDavid Dillow 233175859bfSDavid Dillow /* Calculate our relative offset between the target and 234175859bfSDavid Dillow * the actual CSO value. Since we're operating in a loop, 235175859bfSDavid Dillow * if the value is more than half way around, we can 236175859bfSDavid Dillow * consider ourselves wrapped. 237175859bfSDavid Dillow */ 238175859bfSDavid Dillow sync = voice->sync_cso; 239175859bfSDavid Dillow sync -= readw(voice->sync_base + SIS_CAPTURE_DMA_FORMAT_CSO); 240175859bfSDavid Dillow if (sync > (voice->sync_buffer_size / 2)) 241175859bfSDavid Dillow sync -= voice->sync_buffer_size; 242175859bfSDavid Dillow 243175859bfSDavid Dillow /* If sync is positive, then we interrupted too early, and 244175859bfSDavid Dillow * we'll need to come back in a few samples and try again. 245175859bfSDavid Dillow * There's a minimum wait, as it takes some time for the DMA 246175859bfSDavid Dillow * engine to startup, etc... 247175859bfSDavid Dillow */ 248175859bfSDavid Dillow if (sync > 0) { 249175859bfSDavid Dillow if (sync < 16) 250175859bfSDavid Dillow sync = 16; 251175859bfSDavid Dillow sis_update_sso(voice, sync); 252175859bfSDavid Dillow return; 253175859bfSDavid Dillow } 254175859bfSDavid Dillow 255175859bfSDavid Dillow /* Ok, we interrupted right on time, or (hopefully) just 256175859bfSDavid Dillow * a bit late. We'll adjst our next waiting period based 257175859bfSDavid Dillow * on how close we got. 258175859bfSDavid Dillow * 259175859bfSDavid Dillow * We need to stay just behind the actual channel to ensure 260175859bfSDavid Dillow * it really is past a period when we get our interrupt -- 261175859bfSDavid Dillow * otherwise we'll fall into the early code above and have 262175859bfSDavid Dillow * a minimum wait time, which makes us quite late here, 263175859bfSDavid Dillow * eating into the user's time to refresh the buffer, esp. 264175859bfSDavid Dillow * if using small periods. 265175859bfSDavid Dillow * 266175859bfSDavid Dillow * If we're less than 9 samples behind, we're on target. 267175859bfSDavid Dillow */ 268175859bfSDavid Dillow if (sync > -9) 269175859bfSDavid Dillow voice->vperiod = voice->sync_period_size + 1; 270175859bfSDavid Dillow else 271175859bfSDavid Dillow voice->vperiod = voice->sync_period_size - 4; 272175859bfSDavid Dillow 273175859bfSDavid Dillow if (voice->vperiod < voice->buffer_size) { 274175859bfSDavid Dillow sis_update_sso(voice, voice->vperiod); 275175859bfSDavid Dillow voice->vperiod = 0; 276175859bfSDavid Dillow } else 277175859bfSDavid Dillow sis_update_sso(voice, voice->period_size); 278175859bfSDavid Dillow 279175859bfSDavid Dillow sync = voice->sync_cso + voice->sync_period_size; 280175859bfSDavid Dillow if (sync >= voice->sync_buffer_size) 281175859bfSDavid Dillow sync -= voice->sync_buffer_size; 282175859bfSDavid Dillow voice->sync_cso = sync; 283175859bfSDavid Dillow } 284175859bfSDavid Dillow 285175859bfSDavid Dillow snd_pcm_period_elapsed(voice->substream); 286175859bfSDavid Dillow } 287175859bfSDavid Dillow 288175859bfSDavid Dillow static void sis_voice_irq(u32 status, struct voice *voice) 289175859bfSDavid Dillow { 290175859bfSDavid Dillow int bit; 291175859bfSDavid Dillow 292175859bfSDavid Dillow while (status) { 293175859bfSDavid Dillow bit = __ffs(status); 294175859bfSDavid Dillow status >>= bit + 1; 295175859bfSDavid Dillow voice += bit; 296175859bfSDavid Dillow sis_update_voice(voice); 297175859bfSDavid Dillow voice++; 298175859bfSDavid Dillow } 299175859bfSDavid Dillow } 300175859bfSDavid Dillow 301175859bfSDavid Dillow static irqreturn_t sis_interrupt(int irq, void *dev) 302175859bfSDavid Dillow { 303175859bfSDavid Dillow struct sis7019 *sis = dev; 304175859bfSDavid Dillow unsigned long io = sis->ioport; 305175859bfSDavid Dillow struct voice *voice; 306175859bfSDavid Dillow u32 intr, status; 307175859bfSDavid Dillow 308175859bfSDavid Dillow /* We only use the DMA interrupts, and we don't enable any other 309175859bfSDavid Dillow * source of interrupts. But, it is possible to see an interupt 310175859bfSDavid Dillow * status that didn't actually interrupt us, so eliminate anything 311175859bfSDavid Dillow * we're not expecting to avoid falsely claiming an IRQ, and an 312175859bfSDavid Dillow * ensuing endless loop. 313175859bfSDavid Dillow */ 314175859bfSDavid Dillow intr = inl(io + SIS_GISR); 315175859bfSDavid Dillow intr &= SIS_GISR_AUDIO_PLAY_DMA_IRQ_STATUS | 316175859bfSDavid Dillow SIS_GISR_AUDIO_RECORD_DMA_IRQ_STATUS; 317175859bfSDavid Dillow if (!intr) 318175859bfSDavid Dillow return IRQ_NONE; 319175859bfSDavid Dillow 320175859bfSDavid Dillow do { 321175859bfSDavid Dillow status = inl(io + SIS_PISR_A); 322175859bfSDavid Dillow if (status) { 323175859bfSDavid Dillow sis_voice_irq(status, sis->voices); 324175859bfSDavid Dillow outl(status, io + SIS_PISR_A); 325175859bfSDavid Dillow } 326175859bfSDavid Dillow 327175859bfSDavid Dillow status = inl(io + SIS_PISR_B); 328175859bfSDavid Dillow if (status) { 329175859bfSDavid Dillow sis_voice_irq(status, &sis->voices[32]); 330175859bfSDavid Dillow outl(status, io + SIS_PISR_B); 331175859bfSDavid Dillow } 332175859bfSDavid Dillow 333175859bfSDavid Dillow status = inl(io + SIS_RISR); 334175859bfSDavid Dillow if (status) { 335175859bfSDavid Dillow voice = &sis->capture_voice; 336175859bfSDavid Dillow if (!voice->timing) 337175859bfSDavid Dillow snd_pcm_period_elapsed(voice->substream); 338175859bfSDavid Dillow 339175859bfSDavid Dillow outl(status, io + SIS_RISR); 340175859bfSDavid Dillow } 341175859bfSDavid Dillow 342175859bfSDavid Dillow outl(intr, io + SIS_GISR); 343175859bfSDavid Dillow intr = inl(io + SIS_GISR); 344175859bfSDavid Dillow intr &= SIS_GISR_AUDIO_PLAY_DMA_IRQ_STATUS | 345175859bfSDavid Dillow SIS_GISR_AUDIO_RECORD_DMA_IRQ_STATUS; 346175859bfSDavid Dillow } while (intr); 347175859bfSDavid Dillow 348175859bfSDavid Dillow return IRQ_HANDLED; 349175859bfSDavid Dillow } 350175859bfSDavid Dillow 351175859bfSDavid Dillow static u32 sis_rate_to_delta(unsigned int rate) 352175859bfSDavid Dillow { 353175859bfSDavid Dillow u32 delta; 354175859bfSDavid Dillow 355175859bfSDavid Dillow /* This was copied from the trident driver, but it seems its gotten 356175859bfSDavid Dillow * around a bit... nevertheless, it works well. 357175859bfSDavid Dillow * 358175859bfSDavid Dillow * We special case 44100 and 8000 since rounding with the equation 359175859bfSDavid Dillow * does not give us an accurate enough value. For 11025 and 22050 360175859bfSDavid Dillow * the equation gives us the best answer. All other frequencies will 361175859bfSDavid Dillow * also use the equation. JDW 362175859bfSDavid Dillow */ 363175859bfSDavid Dillow if (rate == 44100) 364175859bfSDavid Dillow delta = 0xeb3; 365175859bfSDavid Dillow else if (rate == 8000) 366175859bfSDavid Dillow delta = 0x2ab; 367175859bfSDavid Dillow else if (rate == 48000) 368175859bfSDavid Dillow delta = 0x1000; 369175859bfSDavid Dillow else 370175859bfSDavid Dillow delta = (((rate << 12) + 24000) / 48000) & 0x0000ffff; 371175859bfSDavid Dillow return delta; 372175859bfSDavid Dillow } 373175859bfSDavid Dillow 374175859bfSDavid Dillow static void __sis_map_silence(struct sis7019 *sis) 375175859bfSDavid Dillow { 376175859bfSDavid Dillow /* Helper function: must hold sis->voice_lock on entry */ 377175859bfSDavid Dillow if (!sis->silence_users) 378175859bfSDavid Dillow sis->silence_dma_addr = pci_map_single(sis->pci, 379175859bfSDavid Dillow sis->suspend_state[0], 380175859bfSDavid Dillow 4096, PCI_DMA_TODEVICE); 381175859bfSDavid Dillow sis->silence_users++; 382175859bfSDavid Dillow } 383175859bfSDavid Dillow 384175859bfSDavid Dillow static void __sis_unmap_silence(struct sis7019 *sis) 385175859bfSDavid Dillow { 386175859bfSDavid Dillow /* Helper function: must hold sis->voice_lock on entry */ 387175859bfSDavid Dillow sis->silence_users--; 388175859bfSDavid Dillow if (!sis->silence_users) 389175859bfSDavid Dillow pci_unmap_single(sis->pci, sis->silence_dma_addr, 4096, 390175859bfSDavid Dillow PCI_DMA_TODEVICE); 391175859bfSDavid Dillow } 392175859bfSDavid Dillow 393175859bfSDavid Dillow static void sis_free_voice(struct sis7019 *sis, struct voice *voice) 394175859bfSDavid Dillow { 395175859bfSDavid Dillow unsigned long flags; 396175859bfSDavid Dillow 397175859bfSDavid Dillow spin_lock_irqsave(&sis->voice_lock, flags); 398175859bfSDavid Dillow if (voice->timing) { 399175859bfSDavid Dillow __sis_unmap_silence(sis); 400175859bfSDavid Dillow voice->timing->flags &= ~(VOICE_IN_USE | VOICE_SSO_TIMING | 401175859bfSDavid Dillow VOICE_SYNC_TIMING); 402175859bfSDavid Dillow voice->timing = NULL; 403175859bfSDavid Dillow } 404175859bfSDavid Dillow voice->flags &= ~(VOICE_IN_USE | VOICE_SSO_TIMING | VOICE_SYNC_TIMING); 405175859bfSDavid Dillow spin_unlock_irqrestore(&sis->voice_lock, flags); 406175859bfSDavid Dillow } 407175859bfSDavid Dillow 408175859bfSDavid Dillow static struct voice *__sis_alloc_playback_voice(struct sis7019 *sis) 409175859bfSDavid Dillow { 410175859bfSDavid Dillow /* Must hold the voice_lock on entry */ 411175859bfSDavid Dillow struct voice *voice; 412175859bfSDavid Dillow int i; 413175859bfSDavid Dillow 414175859bfSDavid Dillow for (i = 0; i < 64; i++) { 415175859bfSDavid Dillow voice = &sis->voices[i]; 416175859bfSDavid Dillow if (voice->flags & VOICE_IN_USE) 417175859bfSDavid Dillow continue; 418175859bfSDavid Dillow voice->flags |= VOICE_IN_USE; 419175859bfSDavid Dillow goto found_one; 420175859bfSDavid Dillow } 421175859bfSDavid Dillow voice = NULL; 422175859bfSDavid Dillow 423175859bfSDavid Dillow found_one: 424175859bfSDavid Dillow return voice; 425175859bfSDavid Dillow } 426175859bfSDavid Dillow 427175859bfSDavid Dillow static struct voice *sis_alloc_playback_voice(struct sis7019 *sis) 428175859bfSDavid Dillow { 429175859bfSDavid Dillow struct voice *voice; 430175859bfSDavid Dillow unsigned long flags; 431175859bfSDavid Dillow 432175859bfSDavid Dillow spin_lock_irqsave(&sis->voice_lock, flags); 433175859bfSDavid Dillow voice = __sis_alloc_playback_voice(sis); 434175859bfSDavid Dillow spin_unlock_irqrestore(&sis->voice_lock, flags); 435175859bfSDavid Dillow 436175859bfSDavid Dillow return voice; 437175859bfSDavid Dillow } 438175859bfSDavid Dillow 439175859bfSDavid Dillow static int sis_alloc_timing_voice(struct snd_pcm_substream *substream, 440175859bfSDavid Dillow struct snd_pcm_hw_params *hw_params) 441175859bfSDavid Dillow { 442175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 443175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 444175859bfSDavid Dillow struct voice *voice = runtime->private_data; 445175859bfSDavid Dillow unsigned int period_size, buffer_size; 446175859bfSDavid Dillow unsigned long flags; 447175859bfSDavid Dillow int needed; 448175859bfSDavid Dillow 449175859bfSDavid Dillow /* If there are one or two periods per buffer, we don't need a 450175859bfSDavid Dillow * timing voice, as we can use the capture channel's interrupts 451175859bfSDavid Dillow * to clock out the periods. 452175859bfSDavid Dillow */ 453175859bfSDavid Dillow period_size = params_period_size(hw_params); 454175859bfSDavid Dillow buffer_size = params_buffer_size(hw_params); 455175859bfSDavid Dillow needed = (period_size != buffer_size && 456175859bfSDavid Dillow period_size != (buffer_size / 2)); 457175859bfSDavid Dillow 458175859bfSDavid Dillow if (needed && !voice->timing) { 459175859bfSDavid Dillow spin_lock_irqsave(&sis->voice_lock, flags); 460175859bfSDavid Dillow voice->timing = __sis_alloc_playback_voice(sis); 461175859bfSDavid Dillow if (voice->timing) 462175859bfSDavid Dillow __sis_map_silence(sis); 463175859bfSDavid Dillow spin_unlock_irqrestore(&sis->voice_lock, flags); 464175859bfSDavid Dillow if (!voice->timing) 465175859bfSDavid Dillow return -ENOMEM; 466175859bfSDavid Dillow voice->timing->substream = substream; 467175859bfSDavid Dillow } else if (!needed && voice->timing) { 468175859bfSDavid Dillow sis_free_voice(sis, voice); 469175859bfSDavid Dillow voice->timing = NULL; 470175859bfSDavid Dillow } 471175859bfSDavid Dillow 472175859bfSDavid Dillow return 0; 473175859bfSDavid Dillow } 474175859bfSDavid Dillow 475175859bfSDavid Dillow static int sis_playback_open(struct snd_pcm_substream *substream) 476175859bfSDavid Dillow { 477175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 478175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 479175859bfSDavid Dillow struct voice *voice; 480175859bfSDavid Dillow 481175859bfSDavid Dillow voice = sis_alloc_playback_voice(sis); 482175859bfSDavid Dillow if (!voice) 483175859bfSDavid Dillow return -EAGAIN; 484175859bfSDavid Dillow 485175859bfSDavid Dillow voice->substream = substream; 486175859bfSDavid Dillow runtime->private_data = voice; 487175859bfSDavid Dillow runtime->hw = sis_playback_hw_info; 488175859bfSDavid Dillow snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 489175859bfSDavid Dillow 9, 0xfff9); 490175859bfSDavid Dillow snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 491175859bfSDavid Dillow 9, 0xfff9); 492175859bfSDavid Dillow snd_pcm_set_sync(substream); 493175859bfSDavid Dillow return 0; 494175859bfSDavid Dillow } 495175859bfSDavid Dillow 496175859bfSDavid Dillow static int sis_substream_close(struct snd_pcm_substream *substream) 497175859bfSDavid Dillow { 498175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 499175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 500175859bfSDavid Dillow struct voice *voice = runtime->private_data; 501175859bfSDavid Dillow 502175859bfSDavid Dillow sis_free_voice(sis, voice); 503175859bfSDavid Dillow return 0; 504175859bfSDavid Dillow } 505175859bfSDavid Dillow 506175859bfSDavid Dillow static int sis_playback_hw_params(struct snd_pcm_substream *substream, 507175859bfSDavid Dillow struct snd_pcm_hw_params *hw_params) 508175859bfSDavid Dillow { 509175859bfSDavid Dillow return snd_pcm_lib_malloc_pages(substream, 510175859bfSDavid Dillow params_buffer_bytes(hw_params)); 511175859bfSDavid Dillow } 512175859bfSDavid Dillow 513175859bfSDavid Dillow static int sis_hw_free(struct snd_pcm_substream *substream) 514175859bfSDavid Dillow { 515175859bfSDavid Dillow return snd_pcm_lib_free_pages(substream); 516175859bfSDavid Dillow } 517175859bfSDavid Dillow 518175859bfSDavid Dillow static int sis_pcm_playback_prepare(struct snd_pcm_substream *substream) 519175859bfSDavid Dillow { 520175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 521175859bfSDavid Dillow struct voice *voice = runtime->private_data; 522175859bfSDavid Dillow void __iomem *ctrl_base = voice->ctrl_base; 523175859bfSDavid Dillow void __iomem *wave_base = voice->wave_base; 524175859bfSDavid Dillow u32 format, dma_addr, control, sso_eso, delta, reg; 525175859bfSDavid Dillow u16 leo; 526175859bfSDavid Dillow 527175859bfSDavid Dillow /* We rely on the PCM core to ensure that the parameters for this 528175859bfSDavid Dillow * substream do not change on us while we're programming the HW. 529175859bfSDavid Dillow */ 530175859bfSDavid Dillow format = 0; 531175859bfSDavid Dillow if (snd_pcm_format_width(runtime->format) == 8) 532175859bfSDavid Dillow format |= SIS_PLAY_DMA_FORMAT_8BIT; 533175859bfSDavid Dillow if (!snd_pcm_format_signed(runtime->format)) 534175859bfSDavid Dillow format |= SIS_PLAY_DMA_FORMAT_UNSIGNED; 535175859bfSDavid Dillow if (runtime->channels == 1) 536175859bfSDavid Dillow format |= SIS_PLAY_DMA_FORMAT_MONO; 537175859bfSDavid Dillow 538175859bfSDavid Dillow /* The baseline setup is for a single period per buffer, and 539175859bfSDavid Dillow * we add bells and whistles as needed from there. 540175859bfSDavid Dillow */ 541175859bfSDavid Dillow dma_addr = runtime->dma_addr; 542175859bfSDavid Dillow leo = runtime->buffer_size - 1; 543175859bfSDavid Dillow control = leo | SIS_PLAY_DMA_LOOP | SIS_PLAY_DMA_INTR_AT_LEO; 544175859bfSDavid Dillow sso_eso = leo; 545175859bfSDavid Dillow 546175859bfSDavid Dillow if (runtime->period_size == (runtime->buffer_size / 2)) { 547175859bfSDavid Dillow control |= SIS_PLAY_DMA_INTR_AT_MLP; 548175859bfSDavid Dillow } else if (runtime->period_size != runtime->buffer_size) { 549175859bfSDavid Dillow voice->flags |= VOICE_SSO_TIMING; 550175859bfSDavid Dillow voice->sso = runtime->period_size - 1; 551175859bfSDavid Dillow voice->period_size = runtime->period_size; 552175859bfSDavid Dillow voice->buffer_size = runtime->buffer_size; 553175859bfSDavid Dillow 554175859bfSDavid Dillow control &= ~SIS_PLAY_DMA_INTR_AT_LEO; 555175859bfSDavid Dillow control |= SIS_PLAY_DMA_INTR_AT_SSO; 556175859bfSDavid Dillow sso_eso |= (runtime->period_size - 1) << 16; 557175859bfSDavid Dillow } 558175859bfSDavid Dillow 559175859bfSDavid Dillow delta = sis_rate_to_delta(runtime->rate); 560175859bfSDavid Dillow 561175859bfSDavid Dillow /* Ok, we're ready to go, set up the channel. 562175859bfSDavid Dillow */ 563175859bfSDavid Dillow writel(format, ctrl_base + SIS_PLAY_DMA_FORMAT_CSO); 564175859bfSDavid Dillow writel(dma_addr, ctrl_base + SIS_PLAY_DMA_BASE); 565175859bfSDavid Dillow writel(control, ctrl_base + SIS_PLAY_DMA_CONTROL); 566175859bfSDavid Dillow writel(sso_eso, ctrl_base + SIS_PLAY_DMA_SSO_ESO); 567175859bfSDavid Dillow 568175859bfSDavid Dillow for (reg = 0; reg < SIS_WAVE_SIZE; reg += 4) 569175859bfSDavid Dillow writel(0, wave_base + reg); 570175859bfSDavid Dillow 571175859bfSDavid Dillow writel(SIS_WAVE_GENERAL_WAVE_VOLUME, wave_base + SIS_WAVE_GENERAL); 572175859bfSDavid Dillow writel(delta << 16, wave_base + SIS_WAVE_GENERAL_ARTICULATION); 573175859bfSDavid Dillow writel(SIS_WAVE_CHANNEL_CONTROL_FIRST_SAMPLE | 574175859bfSDavid Dillow SIS_WAVE_CHANNEL_CONTROL_AMP_ENABLE | 575175859bfSDavid Dillow SIS_WAVE_CHANNEL_CONTROL_INTERPOLATE_ENABLE, 576175859bfSDavid Dillow wave_base + SIS_WAVE_CHANNEL_CONTROL); 577175859bfSDavid Dillow 578175859bfSDavid Dillow /* Force PCI writes to post. */ 579175859bfSDavid Dillow readl(ctrl_base); 580175859bfSDavid Dillow 581175859bfSDavid Dillow return 0; 582175859bfSDavid Dillow } 583175859bfSDavid Dillow 584175859bfSDavid Dillow static int sis_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 585175859bfSDavid Dillow { 586175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 587175859bfSDavid Dillow unsigned long io = sis->ioport; 588175859bfSDavid Dillow struct snd_pcm_substream *s; 589175859bfSDavid Dillow struct voice *voice; 590175859bfSDavid Dillow void *chip; 591175859bfSDavid Dillow int starting; 592175859bfSDavid Dillow u32 record = 0; 593175859bfSDavid Dillow u32 play[2] = { 0, 0 }; 594175859bfSDavid Dillow 595175859bfSDavid Dillow /* No locks needed, as the PCM core will hold the locks on the 596175859bfSDavid Dillow * substreams, and the HW will only start/stop the indicated voices 597175859bfSDavid Dillow * without changing the state of the others. 598175859bfSDavid Dillow */ 599175859bfSDavid Dillow switch (cmd) { 600175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_START: 601175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 602175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_RESUME: 603175859bfSDavid Dillow starting = 1; 604175859bfSDavid Dillow break; 605175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_STOP: 606175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 607175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_SUSPEND: 608175859bfSDavid Dillow starting = 0; 609175859bfSDavid Dillow break; 610175859bfSDavid Dillow default: 611175859bfSDavid Dillow return -EINVAL; 612175859bfSDavid Dillow } 613175859bfSDavid Dillow 614175859bfSDavid Dillow snd_pcm_group_for_each_entry(s, substream) { 615175859bfSDavid Dillow /* Make sure it is for us... */ 616175859bfSDavid Dillow chip = snd_pcm_substream_chip(s); 617175859bfSDavid Dillow if (chip != sis) 618175859bfSDavid Dillow continue; 619175859bfSDavid Dillow 620175859bfSDavid Dillow voice = s->runtime->private_data; 621175859bfSDavid Dillow if (voice->flags & VOICE_CAPTURE) { 622175859bfSDavid Dillow record |= 1 << voice->num; 623175859bfSDavid Dillow voice = voice->timing; 624175859bfSDavid Dillow } 625175859bfSDavid Dillow 626175859bfSDavid Dillow /* voice could be NULL if this a recording stream, and it 627175859bfSDavid Dillow * doesn't have an external timing channel. 628175859bfSDavid Dillow */ 629175859bfSDavid Dillow if (voice) 630175859bfSDavid Dillow play[voice->num / 32] |= 1 << (voice->num & 0x1f); 631175859bfSDavid Dillow 632175859bfSDavid Dillow snd_pcm_trigger_done(s, substream); 633175859bfSDavid Dillow } 634175859bfSDavid Dillow 635175859bfSDavid Dillow if (starting) { 636175859bfSDavid Dillow if (record) 637175859bfSDavid Dillow outl(record, io + SIS_RECORD_START_REG); 638175859bfSDavid Dillow if (play[0]) 639175859bfSDavid Dillow outl(play[0], io + SIS_PLAY_START_A_REG); 640175859bfSDavid Dillow if (play[1]) 641175859bfSDavid Dillow outl(play[1], io + SIS_PLAY_START_B_REG); 642175859bfSDavid Dillow } else { 643175859bfSDavid Dillow if (record) 644175859bfSDavid Dillow outl(record, io + SIS_RECORD_STOP_REG); 645175859bfSDavid Dillow if (play[0]) 646175859bfSDavid Dillow outl(play[0], io + SIS_PLAY_STOP_A_REG); 647175859bfSDavid Dillow if (play[1]) 648175859bfSDavid Dillow outl(play[1], io + SIS_PLAY_STOP_B_REG); 649175859bfSDavid Dillow } 650175859bfSDavid Dillow return 0; 651175859bfSDavid Dillow } 652175859bfSDavid Dillow 653175859bfSDavid Dillow static snd_pcm_uframes_t sis_pcm_pointer(struct snd_pcm_substream *substream) 654175859bfSDavid Dillow { 655175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 656175859bfSDavid Dillow struct voice *voice = runtime->private_data; 657175859bfSDavid Dillow u32 cso; 658175859bfSDavid Dillow 659175859bfSDavid Dillow cso = readl(voice->ctrl_base + SIS_PLAY_DMA_FORMAT_CSO); 660175859bfSDavid Dillow cso &= 0xffff; 661175859bfSDavid Dillow return cso; 662175859bfSDavid Dillow } 663175859bfSDavid Dillow 664175859bfSDavid Dillow static int sis_capture_open(struct snd_pcm_substream *substream) 665175859bfSDavid Dillow { 666175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 667175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 668175859bfSDavid Dillow struct voice *voice = &sis->capture_voice; 669175859bfSDavid Dillow unsigned long flags; 670175859bfSDavid Dillow 671175859bfSDavid Dillow /* FIXME: The driver only supports recording from one channel 672175859bfSDavid Dillow * at the moment, but it could support more. 673175859bfSDavid Dillow */ 674175859bfSDavid Dillow spin_lock_irqsave(&sis->voice_lock, flags); 675175859bfSDavid Dillow if (voice->flags & VOICE_IN_USE) 676175859bfSDavid Dillow voice = NULL; 677175859bfSDavid Dillow else 678175859bfSDavid Dillow voice->flags |= VOICE_IN_USE; 679175859bfSDavid Dillow spin_unlock_irqrestore(&sis->voice_lock, flags); 680175859bfSDavid Dillow 681175859bfSDavid Dillow if (!voice) 682175859bfSDavid Dillow return -EAGAIN; 683175859bfSDavid Dillow 684175859bfSDavid Dillow voice->substream = substream; 685175859bfSDavid Dillow runtime->private_data = voice; 686175859bfSDavid Dillow runtime->hw = sis_capture_hw_info; 687175859bfSDavid Dillow runtime->hw.rates = sis->ac97[0]->rates[AC97_RATES_ADC]; 688175859bfSDavid Dillow snd_pcm_limit_hw_rates(runtime); 689175859bfSDavid Dillow snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 690175859bfSDavid Dillow 9, 0xfff9); 691175859bfSDavid Dillow snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 692175859bfSDavid Dillow 9, 0xfff9); 693175859bfSDavid Dillow snd_pcm_set_sync(substream); 694175859bfSDavid Dillow return 0; 695175859bfSDavid Dillow } 696175859bfSDavid Dillow 697175859bfSDavid Dillow static int sis_capture_hw_params(struct snd_pcm_substream *substream, 698175859bfSDavid Dillow struct snd_pcm_hw_params *hw_params) 699175859bfSDavid Dillow { 700175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 701175859bfSDavid Dillow int rc; 702175859bfSDavid Dillow 703175859bfSDavid Dillow rc = snd_ac97_set_rate(sis->ac97[0], AC97_PCM_LR_ADC_RATE, 704175859bfSDavid Dillow params_rate(hw_params)); 705175859bfSDavid Dillow if (rc) 706175859bfSDavid Dillow goto out; 707175859bfSDavid Dillow 708175859bfSDavid Dillow rc = snd_pcm_lib_malloc_pages(substream, 709175859bfSDavid Dillow params_buffer_bytes(hw_params)); 710175859bfSDavid Dillow if (rc < 0) 711175859bfSDavid Dillow goto out; 712175859bfSDavid Dillow 713175859bfSDavid Dillow rc = sis_alloc_timing_voice(substream, hw_params); 714175859bfSDavid Dillow 715175859bfSDavid Dillow out: 716175859bfSDavid Dillow return rc; 717175859bfSDavid Dillow } 718175859bfSDavid Dillow 719175859bfSDavid Dillow static void sis_prepare_timing_voice(struct voice *voice, 720175859bfSDavid Dillow struct snd_pcm_substream *substream) 721175859bfSDavid Dillow { 722175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 723175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 724175859bfSDavid Dillow struct voice *timing = voice->timing; 725175859bfSDavid Dillow void __iomem *play_base = timing->ctrl_base; 726175859bfSDavid Dillow void __iomem *wave_base = timing->wave_base; 727175859bfSDavid Dillow u16 buffer_size, period_size; 728175859bfSDavid Dillow u32 format, control, sso_eso, delta; 729175859bfSDavid Dillow u32 vperiod, sso, reg; 730175859bfSDavid Dillow 731175859bfSDavid Dillow /* Set our initial buffer and period as large as we can given a 732175859bfSDavid Dillow * single page of silence. 733175859bfSDavid Dillow */ 734175859bfSDavid Dillow buffer_size = 4096 / runtime->channels; 735175859bfSDavid Dillow buffer_size /= snd_pcm_format_size(runtime->format, 1); 736175859bfSDavid Dillow period_size = buffer_size; 737175859bfSDavid Dillow 738175859bfSDavid Dillow /* Initially, we want to interrupt just a bit behind the end of 739175859bfSDavid Dillow * the period we're clocking out. 10 samples seems to give a good 740175859bfSDavid Dillow * delay. 741175859bfSDavid Dillow * 742175859bfSDavid Dillow * We want to spread our interrupts throughout the virtual period, 743175859bfSDavid Dillow * so that we don't end up with two interrupts back to back at the 744175859bfSDavid Dillow * end -- this helps minimize the effects of any jitter. Adjust our 745175859bfSDavid Dillow * clocking period size so that the last period is at least a fourth 746175859bfSDavid Dillow * of a full period. 747175859bfSDavid Dillow * 748175859bfSDavid Dillow * This is all moot if we don't need to use virtual periods. 749175859bfSDavid Dillow */ 750175859bfSDavid Dillow vperiod = runtime->period_size + 10; 751175859bfSDavid Dillow if (vperiod > period_size) { 752175859bfSDavid Dillow u16 tail = vperiod % period_size; 753175859bfSDavid Dillow u16 quarter_period = period_size / 4; 754175859bfSDavid Dillow 755175859bfSDavid Dillow if (tail && tail < quarter_period) { 756175859bfSDavid Dillow u16 loops = vperiod / period_size; 757175859bfSDavid Dillow 758175859bfSDavid Dillow tail = quarter_period - tail; 759175859bfSDavid Dillow tail += loops - 1; 760175859bfSDavid Dillow tail /= loops; 761175859bfSDavid Dillow period_size -= tail; 762175859bfSDavid Dillow } 763175859bfSDavid Dillow 764175859bfSDavid Dillow sso = period_size - 1; 765175859bfSDavid Dillow } else { 766175859bfSDavid Dillow /* The initial period will fit inside the buffer, so we 767175859bfSDavid Dillow * don't need to use virtual periods -- disable them. 768175859bfSDavid Dillow */ 769175859bfSDavid Dillow period_size = runtime->period_size; 770175859bfSDavid Dillow sso = vperiod - 1; 771175859bfSDavid Dillow vperiod = 0; 772175859bfSDavid Dillow } 773175859bfSDavid Dillow 774175859bfSDavid Dillow /* The interrupt handler implements the timing syncronization, so 775175859bfSDavid Dillow * setup its state. 776175859bfSDavid Dillow */ 777175859bfSDavid Dillow timing->flags |= VOICE_SYNC_TIMING; 778175859bfSDavid Dillow timing->sync_base = voice->ctrl_base; 779175859bfSDavid Dillow timing->sync_cso = runtime->period_size - 1; 780175859bfSDavid Dillow timing->sync_period_size = runtime->period_size; 781175859bfSDavid Dillow timing->sync_buffer_size = runtime->buffer_size; 782175859bfSDavid Dillow timing->period_size = period_size; 783175859bfSDavid Dillow timing->buffer_size = buffer_size; 784175859bfSDavid Dillow timing->sso = sso; 785175859bfSDavid Dillow timing->vperiod = vperiod; 786175859bfSDavid Dillow 787175859bfSDavid Dillow /* Using unsigned samples with the all-zero silence buffer 788175859bfSDavid Dillow * forces the output to the lower rail, killing playback. 789175859bfSDavid Dillow * So ignore unsigned vs signed -- it doesn't change the timing. 790175859bfSDavid Dillow */ 791175859bfSDavid Dillow format = 0; 792175859bfSDavid Dillow if (snd_pcm_format_width(runtime->format) == 8) 793175859bfSDavid Dillow format = SIS_CAPTURE_DMA_FORMAT_8BIT; 794175859bfSDavid Dillow if (runtime->channels == 1) 795175859bfSDavid Dillow format |= SIS_CAPTURE_DMA_FORMAT_MONO; 796175859bfSDavid Dillow 797175859bfSDavid Dillow control = timing->buffer_size - 1; 798175859bfSDavid Dillow control |= SIS_PLAY_DMA_LOOP | SIS_PLAY_DMA_INTR_AT_SSO; 799175859bfSDavid Dillow sso_eso = timing->buffer_size - 1; 800175859bfSDavid Dillow sso_eso |= timing->sso << 16; 801175859bfSDavid Dillow 802175859bfSDavid Dillow delta = sis_rate_to_delta(runtime->rate); 803175859bfSDavid Dillow 804175859bfSDavid Dillow /* We've done the math, now configure the channel. 805175859bfSDavid Dillow */ 806175859bfSDavid Dillow writel(format, play_base + SIS_PLAY_DMA_FORMAT_CSO); 807175859bfSDavid Dillow writel(sis->silence_dma_addr, play_base + SIS_PLAY_DMA_BASE); 808175859bfSDavid Dillow writel(control, play_base + SIS_PLAY_DMA_CONTROL); 809175859bfSDavid Dillow writel(sso_eso, play_base + SIS_PLAY_DMA_SSO_ESO); 810175859bfSDavid Dillow 811175859bfSDavid Dillow for (reg = 0; reg < SIS_WAVE_SIZE; reg += 4) 812175859bfSDavid Dillow writel(0, wave_base + reg); 813175859bfSDavid Dillow 814175859bfSDavid Dillow writel(SIS_WAVE_GENERAL_WAVE_VOLUME, wave_base + SIS_WAVE_GENERAL); 815175859bfSDavid Dillow writel(delta << 16, wave_base + SIS_WAVE_GENERAL_ARTICULATION); 816175859bfSDavid Dillow writel(SIS_WAVE_CHANNEL_CONTROL_FIRST_SAMPLE | 817175859bfSDavid Dillow SIS_WAVE_CHANNEL_CONTROL_AMP_ENABLE | 818175859bfSDavid Dillow SIS_WAVE_CHANNEL_CONTROL_INTERPOLATE_ENABLE, 819175859bfSDavid Dillow wave_base + SIS_WAVE_CHANNEL_CONTROL); 820175859bfSDavid Dillow } 821175859bfSDavid Dillow 822175859bfSDavid Dillow static int sis_pcm_capture_prepare(struct snd_pcm_substream *substream) 823175859bfSDavid Dillow { 824175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 825175859bfSDavid Dillow struct voice *voice = runtime->private_data; 826175859bfSDavid Dillow void __iomem *rec_base = voice->ctrl_base; 827175859bfSDavid Dillow u32 format, dma_addr, control; 828175859bfSDavid Dillow u16 leo; 829175859bfSDavid Dillow 830175859bfSDavid Dillow /* We rely on the PCM core to ensure that the parameters for this 831175859bfSDavid Dillow * substream do not change on us while we're programming the HW. 832175859bfSDavid Dillow */ 833175859bfSDavid Dillow format = 0; 834175859bfSDavid Dillow if (snd_pcm_format_width(runtime->format) == 8) 835175859bfSDavid Dillow format = SIS_CAPTURE_DMA_FORMAT_8BIT; 836175859bfSDavid Dillow if (!snd_pcm_format_signed(runtime->format)) 837175859bfSDavid Dillow format |= SIS_CAPTURE_DMA_FORMAT_UNSIGNED; 838175859bfSDavid Dillow if (runtime->channels == 1) 839175859bfSDavid Dillow format |= SIS_CAPTURE_DMA_FORMAT_MONO; 840175859bfSDavid Dillow 841175859bfSDavid Dillow dma_addr = runtime->dma_addr; 842175859bfSDavid Dillow leo = runtime->buffer_size - 1; 843175859bfSDavid Dillow control = leo | SIS_CAPTURE_DMA_LOOP; 844175859bfSDavid Dillow 845175859bfSDavid Dillow /* If we've got more than two periods per buffer, then we have 846175859bfSDavid Dillow * use a timing voice to clock out the periods. Otherwise, we can 847175859bfSDavid Dillow * use the capture channel's interrupts. 848175859bfSDavid Dillow */ 849175859bfSDavid Dillow if (voice->timing) { 850175859bfSDavid Dillow sis_prepare_timing_voice(voice, substream); 851175859bfSDavid Dillow } else { 852175859bfSDavid Dillow control |= SIS_CAPTURE_DMA_INTR_AT_LEO; 853175859bfSDavid Dillow if (runtime->period_size != runtime->buffer_size) 854175859bfSDavid Dillow control |= SIS_CAPTURE_DMA_INTR_AT_MLP; 855175859bfSDavid Dillow } 856175859bfSDavid Dillow 857175859bfSDavid Dillow writel(format, rec_base + SIS_CAPTURE_DMA_FORMAT_CSO); 858175859bfSDavid Dillow writel(dma_addr, rec_base + SIS_CAPTURE_DMA_BASE); 859175859bfSDavid Dillow writel(control, rec_base + SIS_CAPTURE_DMA_CONTROL); 860175859bfSDavid Dillow 861175859bfSDavid Dillow /* Force the writes to post. */ 862175859bfSDavid Dillow readl(rec_base); 863175859bfSDavid Dillow 864175859bfSDavid Dillow return 0; 865175859bfSDavid Dillow } 866175859bfSDavid Dillow 867175859bfSDavid Dillow static struct snd_pcm_ops sis_playback_ops = { 868175859bfSDavid Dillow .open = sis_playback_open, 869175859bfSDavid Dillow .close = sis_substream_close, 870175859bfSDavid Dillow .ioctl = snd_pcm_lib_ioctl, 871175859bfSDavid Dillow .hw_params = sis_playback_hw_params, 872175859bfSDavid Dillow .hw_free = sis_hw_free, 873175859bfSDavid Dillow .prepare = sis_pcm_playback_prepare, 874175859bfSDavid Dillow .trigger = sis_pcm_trigger, 875175859bfSDavid Dillow .pointer = sis_pcm_pointer, 876175859bfSDavid Dillow }; 877175859bfSDavid Dillow 878175859bfSDavid Dillow static struct snd_pcm_ops sis_capture_ops = { 879175859bfSDavid Dillow .open = sis_capture_open, 880175859bfSDavid Dillow .close = sis_substream_close, 881175859bfSDavid Dillow .ioctl = snd_pcm_lib_ioctl, 882175859bfSDavid Dillow .hw_params = sis_capture_hw_params, 883175859bfSDavid Dillow .hw_free = sis_hw_free, 884175859bfSDavid Dillow .prepare = sis_pcm_capture_prepare, 885175859bfSDavid Dillow .trigger = sis_pcm_trigger, 886175859bfSDavid Dillow .pointer = sis_pcm_pointer, 887175859bfSDavid Dillow }; 888175859bfSDavid Dillow 889175859bfSDavid Dillow static int __devinit sis_pcm_create(struct sis7019 *sis) 890175859bfSDavid Dillow { 891175859bfSDavid Dillow struct snd_pcm *pcm; 892175859bfSDavid Dillow int rc; 893175859bfSDavid Dillow 894175859bfSDavid Dillow /* We have 64 voices, and the driver currently records from 895175859bfSDavid Dillow * only one channel, though that could change in the future. 896175859bfSDavid Dillow */ 897175859bfSDavid Dillow rc = snd_pcm_new(sis->card, "SiS7019", 0, 64, 1, &pcm); 898175859bfSDavid Dillow if (rc) 899175859bfSDavid Dillow return rc; 900175859bfSDavid Dillow 901175859bfSDavid Dillow pcm->private_data = sis; 902175859bfSDavid Dillow strcpy(pcm->name, "SiS7019"); 903175859bfSDavid Dillow sis->pcm = pcm; 904175859bfSDavid Dillow 905175859bfSDavid Dillow snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &sis_playback_ops); 906175859bfSDavid Dillow snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &sis_capture_ops); 907175859bfSDavid Dillow 908175859bfSDavid Dillow /* Try to preallocate some memory, but it's not the end of the 909175859bfSDavid Dillow * world if this fails. 910175859bfSDavid Dillow */ 911175859bfSDavid Dillow snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 912175859bfSDavid Dillow snd_dma_pci_data(sis->pci), 64*1024, 128*1024); 913175859bfSDavid Dillow 914175859bfSDavid Dillow return 0; 915175859bfSDavid Dillow } 916175859bfSDavid Dillow 917175859bfSDavid Dillow static unsigned short sis_ac97_rw(struct sis7019 *sis, int codec, u32 cmd) 918175859bfSDavid Dillow { 919175859bfSDavid Dillow unsigned long io = sis->ioport; 920175859bfSDavid Dillow unsigned short val = 0xffff; 921175859bfSDavid Dillow u16 status; 922175859bfSDavid Dillow u16 rdy; 923175859bfSDavid Dillow int count; 924175859bfSDavid Dillow const static u16 codec_ready[3] = { 925175859bfSDavid Dillow SIS_AC97_STATUS_CODEC_READY, 926175859bfSDavid Dillow SIS_AC97_STATUS_CODEC2_READY, 927175859bfSDavid Dillow SIS_AC97_STATUS_CODEC3_READY, 928175859bfSDavid Dillow }; 929175859bfSDavid Dillow 930175859bfSDavid Dillow rdy = codec_ready[codec]; 931175859bfSDavid Dillow 932175859bfSDavid Dillow 933175859bfSDavid Dillow /* Get the AC97 semaphore -- software first, so we don't spin 934175859bfSDavid Dillow * pounding out IO reads on the hardware semaphore... 935175859bfSDavid Dillow */ 936175859bfSDavid Dillow mutex_lock(&sis->ac97_mutex); 937175859bfSDavid Dillow 938175859bfSDavid Dillow count = 0xffff; 939175859bfSDavid Dillow while ((inw(io + SIS_AC97_SEMA) & SIS_AC97_SEMA_BUSY) && --count) 940175859bfSDavid Dillow udelay(1); 941175859bfSDavid Dillow 942175859bfSDavid Dillow if (!count) 943175859bfSDavid Dillow goto timeout; 944175859bfSDavid Dillow 945175859bfSDavid Dillow /* ... and wait for any outstanding commands to complete ... 946175859bfSDavid Dillow */ 947175859bfSDavid Dillow count = 0xffff; 948175859bfSDavid Dillow do { 949175859bfSDavid Dillow status = inw(io + SIS_AC97_STATUS); 950175859bfSDavid Dillow if ((status & rdy) && !(status & SIS_AC97_STATUS_BUSY)) 951175859bfSDavid Dillow break; 952175859bfSDavid Dillow 953175859bfSDavid Dillow udelay(1); 954175859bfSDavid Dillow } while (--count); 955175859bfSDavid Dillow 956175859bfSDavid Dillow if (!count) 957175859bfSDavid Dillow goto timeout_sema; 958175859bfSDavid Dillow 959175859bfSDavid Dillow /* ... before sending our command and waiting for it to finish ... 960175859bfSDavid Dillow */ 961175859bfSDavid Dillow outl(cmd, io + SIS_AC97_CMD); 962175859bfSDavid Dillow udelay(10); 963175859bfSDavid Dillow 964175859bfSDavid Dillow count = 0xffff; 965175859bfSDavid Dillow while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count) 966175859bfSDavid Dillow udelay(1); 967175859bfSDavid Dillow 968175859bfSDavid Dillow /* ... and reading the results (if any). 969175859bfSDavid Dillow */ 970175859bfSDavid Dillow val = inl(io + SIS_AC97_CMD) >> 16; 971175859bfSDavid Dillow 972175859bfSDavid Dillow timeout_sema: 973175859bfSDavid Dillow outl(SIS_AC97_SEMA_RELEASE, io + SIS_AC97_SEMA); 974175859bfSDavid Dillow timeout: 975175859bfSDavid Dillow mutex_unlock(&sis->ac97_mutex); 976175859bfSDavid Dillow 977175859bfSDavid Dillow if (!count) { 978175859bfSDavid Dillow printk(KERN_ERR "sis7019: ac97 codec %d timeout cmd 0x%08x\n", 979175859bfSDavid Dillow codec, cmd); 980175859bfSDavid Dillow } 981175859bfSDavid Dillow 982175859bfSDavid Dillow return val; 983175859bfSDavid Dillow } 984175859bfSDavid Dillow 985175859bfSDavid Dillow static void sis_ac97_write(struct snd_ac97 *ac97, unsigned short reg, 986175859bfSDavid Dillow unsigned short val) 987175859bfSDavid Dillow { 988175859bfSDavid Dillow const static u32 cmd[3] = { 989175859bfSDavid Dillow SIS_AC97_CMD_CODEC_WRITE, 990175859bfSDavid Dillow SIS_AC97_CMD_CODEC2_WRITE, 991175859bfSDavid Dillow SIS_AC97_CMD_CODEC3_WRITE, 992175859bfSDavid Dillow }; 993175859bfSDavid Dillow sis_ac97_rw(ac97->private_data, ac97->num, 994175859bfSDavid Dillow (val << 16) | (reg << 8) | cmd[ac97->num]); 995175859bfSDavid Dillow } 996175859bfSDavid Dillow 997175859bfSDavid Dillow static unsigned short sis_ac97_read(struct snd_ac97 *ac97, unsigned short reg) 998175859bfSDavid Dillow { 999175859bfSDavid Dillow const static u32 cmd[3] = { 1000175859bfSDavid Dillow SIS_AC97_CMD_CODEC_READ, 1001175859bfSDavid Dillow SIS_AC97_CMD_CODEC2_READ, 1002175859bfSDavid Dillow SIS_AC97_CMD_CODEC3_READ, 1003175859bfSDavid Dillow }; 1004175859bfSDavid Dillow return sis_ac97_rw(ac97->private_data, ac97->num, 1005175859bfSDavid Dillow (reg << 8) | cmd[ac97->num]); 1006175859bfSDavid Dillow } 1007175859bfSDavid Dillow 1008175859bfSDavid Dillow static int __devinit sis_mixer_create(struct sis7019 *sis) 1009175859bfSDavid Dillow { 1010175859bfSDavid Dillow struct snd_ac97_bus *bus; 1011175859bfSDavid Dillow struct snd_ac97_template ac97; 1012175859bfSDavid Dillow static struct snd_ac97_bus_ops ops = { 1013175859bfSDavid Dillow .write = sis_ac97_write, 1014175859bfSDavid Dillow .read = sis_ac97_read, 1015175859bfSDavid Dillow }; 1016175859bfSDavid Dillow int rc; 1017175859bfSDavid Dillow 1018175859bfSDavid Dillow memset(&ac97, 0, sizeof(ac97)); 1019175859bfSDavid Dillow ac97.private_data = sis; 1020175859bfSDavid Dillow 1021175859bfSDavid Dillow rc = snd_ac97_bus(sis->card, 0, &ops, NULL, &bus); 1022175859bfSDavid Dillow if (!rc && sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT) 1023175859bfSDavid Dillow rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[0]); 1024175859bfSDavid Dillow ac97.num = 1; 1025175859bfSDavid Dillow if (!rc && (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT)) 1026175859bfSDavid Dillow rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[1]); 1027175859bfSDavid Dillow ac97.num = 2; 1028175859bfSDavid Dillow if (!rc && (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT)) 1029175859bfSDavid Dillow rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[2]); 1030175859bfSDavid Dillow 1031175859bfSDavid Dillow /* If we return an error here, then snd_card_free() should 1032175859bfSDavid Dillow * free up any ac97 codecs that got created, as well as the bus. 1033175859bfSDavid Dillow */ 1034175859bfSDavid Dillow return rc; 1035175859bfSDavid Dillow } 1036175859bfSDavid Dillow 1037175859bfSDavid Dillow static void sis_free_suspend(struct sis7019 *sis) 1038175859bfSDavid Dillow { 1039175859bfSDavid Dillow int i; 1040175859bfSDavid Dillow 1041175859bfSDavid Dillow for (i = 0; i < SIS_SUSPEND_PAGES; i++) 1042175859bfSDavid Dillow kfree(sis->suspend_state[i]); 1043175859bfSDavid Dillow } 1044175859bfSDavid Dillow 1045175859bfSDavid Dillow static int sis_chip_free(struct sis7019 *sis) 1046175859bfSDavid Dillow { 1047175859bfSDavid Dillow /* Reset the chip, and disable all interrputs. 1048175859bfSDavid Dillow */ 1049175859bfSDavid Dillow outl(SIS_GCR_SOFTWARE_RESET, sis->ioport + SIS_GCR); 1050175859bfSDavid Dillow udelay(10); 1051175859bfSDavid Dillow outl(0, sis->ioport + SIS_GCR); 1052175859bfSDavid Dillow outl(0, sis->ioport + SIS_GIER); 1053175859bfSDavid Dillow 1054175859bfSDavid Dillow /* Now, free everything we allocated. 1055175859bfSDavid Dillow */ 1056175859bfSDavid Dillow if (sis->irq >= 0) 1057175859bfSDavid Dillow free_irq(sis->irq, sis); 1058175859bfSDavid Dillow 1059175859bfSDavid Dillow if (sis->ioaddr) 1060175859bfSDavid Dillow iounmap(sis->ioaddr); 1061175859bfSDavid Dillow 1062175859bfSDavid Dillow pci_release_regions(sis->pci); 1063175859bfSDavid Dillow pci_disable_device(sis->pci); 1064175859bfSDavid Dillow 1065175859bfSDavid Dillow sis_free_suspend(sis); 1066175859bfSDavid Dillow return 0; 1067175859bfSDavid Dillow } 1068175859bfSDavid Dillow 1069175859bfSDavid Dillow static int sis_dev_free(struct snd_device *dev) 1070175859bfSDavid Dillow { 1071175859bfSDavid Dillow struct sis7019 *sis = dev->device_data; 1072175859bfSDavid Dillow return sis_chip_free(sis); 1073175859bfSDavid Dillow } 1074175859bfSDavid Dillow 1075175859bfSDavid Dillow static int sis_chip_init(struct sis7019 *sis) 1076175859bfSDavid Dillow { 1077175859bfSDavid Dillow unsigned long io = sis->ioport; 1078175859bfSDavid Dillow void __iomem *ioaddr = sis->ioaddr; 1079175859bfSDavid Dillow u16 status; 1080175859bfSDavid Dillow int count; 1081175859bfSDavid Dillow int i; 1082175859bfSDavid Dillow 1083175859bfSDavid Dillow /* Reset the audio controller 1084175859bfSDavid Dillow */ 1085175859bfSDavid Dillow outl(SIS_GCR_SOFTWARE_RESET, io + SIS_GCR); 1086175859bfSDavid Dillow udelay(10); 1087175859bfSDavid Dillow outl(0, io + SIS_GCR); 1088175859bfSDavid Dillow 1089175859bfSDavid Dillow /* Get the AC-link semaphore, and reset the codecs 1090175859bfSDavid Dillow */ 1091175859bfSDavid Dillow count = 0xffff; 1092175859bfSDavid Dillow while ((inw(io + SIS_AC97_SEMA) & SIS_AC97_SEMA_BUSY) && --count) 1093175859bfSDavid Dillow udelay(1); 1094175859bfSDavid Dillow 1095175859bfSDavid Dillow if (!count) 1096175859bfSDavid Dillow return -EIO; 1097175859bfSDavid Dillow 1098175859bfSDavid Dillow outl(SIS_AC97_CMD_CODEC_COLD_RESET, io + SIS_AC97_CMD); 1099175859bfSDavid Dillow udelay(10); 1100175859bfSDavid Dillow 1101175859bfSDavid Dillow count = 0xffff; 1102175859bfSDavid Dillow while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count) 1103175859bfSDavid Dillow udelay(1); 1104175859bfSDavid Dillow 1105175859bfSDavid Dillow /* Now that we've finished the reset, find out what's attached. 1106175859bfSDavid Dillow */ 1107175859bfSDavid Dillow status = inl(io + SIS_AC97_STATUS); 1108175859bfSDavid Dillow if (status & SIS_AC97_STATUS_CODEC_READY) 1109175859bfSDavid Dillow sis->codecs_present |= SIS_PRIMARY_CODEC_PRESENT; 1110175859bfSDavid Dillow if (status & SIS_AC97_STATUS_CODEC2_READY) 1111175859bfSDavid Dillow sis->codecs_present |= SIS_SECONDARY_CODEC_PRESENT; 1112175859bfSDavid Dillow if (status & SIS_AC97_STATUS_CODEC3_READY) 1113175859bfSDavid Dillow sis->codecs_present |= SIS_TERTIARY_CODEC_PRESENT; 1114175859bfSDavid Dillow 1115175859bfSDavid Dillow /* All done, let go of the semaphore, and check for errors 1116175859bfSDavid Dillow */ 1117175859bfSDavid Dillow outl(SIS_AC97_SEMA_RELEASE, io + SIS_AC97_SEMA); 1118175859bfSDavid Dillow if (!sis->codecs_present || !count) 1119175859bfSDavid Dillow return -EIO; 1120175859bfSDavid Dillow 1121175859bfSDavid Dillow /* Let the hardware know that the audio driver is alive, 1122175859bfSDavid Dillow * and enable PCM slots on the AC-link for L/R playback (3 & 4) and 1123175859bfSDavid Dillow * record channels. We're going to want to use Variable Rate Audio 1124175859bfSDavid Dillow * for recording, to avoid needlessly resampling from 48kHZ. 1125175859bfSDavid Dillow */ 1126175859bfSDavid Dillow outl(SIS_AC97_CONF_AUDIO_ALIVE, io + SIS_AC97_CONF); 1127175859bfSDavid Dillow outl(SIS_AC97_CONF_AUDIO_ALIVE | SIS_AC97_CONF_PCM_LR_ENABLE | 1128175859bfSDavid Dillow SIS_AC97_CONF_PCM_CAP_MIC_ENABLE | 1129175859bfSDavid Dillow SIS_AC97_CONF_PCM_CAP_LR_ENABLE | 1130175859bfSDavid Dillow SIS_AC97_CONF_CODEC_VRA_ENABLE, io + SIS_AC97_CONF); 1131175859bfSDavid Dillow 1132175859bfSDavid Dillow /* All AC97 PCM slots should be sourced from sub-mixer 0. 1133175859bfSDavid Dillow */ 1134175859bfSDavid Dillow outl(0, io + SIS_AC97_PSR); 1135175859bfSDavid Dillow 1136175859bfSDavid Dillow /* There is only one valid DMA setup for a PCI environment. 1137175859bfSDavid Dillow */ 1138175859bfSDavid Dillow outl(SIS_DMA_CSR_PCI_SETTINGS, io + SIS_DMA_CSR); 1139175859bfSDavid Dillow 1140175859bfSDavid Dillow /* Reset the syncronization groups for all of the channels 1141175859bfSDavid Dillow * to be asyncronous. If we start doing SPDIF or 5.1 sound, etc. 1142175859bfSDavid Dillow * we'll need to change how we handle these. Until then, we just 1143175859bfSDavid Dillow * assign sub-mixer 0 to all playback channels, and avoid any 1144175859bfSDavid Dillow * attenuation on the audio. 1145175859bfSDavid Dillow */ 1146175859bfSDavid Dillow outl(0, io + SIS_PLAY_SYNC_GROUP_A); 1147175859bfSDavid Dillow outl(0, io + SIS_PLAY_SYNC_GROUP_B); 1148175859bfSDavid Dillow outl(0, io + SIS_PLAY_SYNC_GROUP_C); 1149175859bfSDavid Dillow outl(0, io + SIS_PLAY_SYNC_GROUP_D); 1150175859bfSDavid Dillow outl(0, io + SIS_MIXER_SYNC_GROUP); 1151175859bfSDavid Dillow 1152175859bfSDavid Dillow for (i = 0; i < 64; i++) { 1153175859bfSDavid Dillow writel(i, SIS_MIXER_START_ADDR(ioaddr, i)); 1154175859bfSDavid Dillow writel(SIS_MIXER_RIGHT_NO_ATTEN | SIS_MIXER_LEFT_NO_ATTEN | 1155175859bfSDavid Dillow SIS_MIXER_DEST_0, SIS_MIXER_ADDR(ioaddr, i)); 1156175859bfSDavid Dillow } 1157175859bfSDavid Dillow 1158175859bfSDavid Dillow /* Don't attenuate any audio set for the wave amplifier. 1159175859bfSDavid Dillow * 1160175859bfSDavid Dillow * FIXME: Maximum attenuation is set for the music amp, which will 1161175859bfSDavid Dillow * need to change if we start using the synth engine. 1162175859bfSDavid Dillow */ 1163175859bfSDavid Dillow outl(0xffff0000, io + SIS_WEVCR); 1164175859bfSDavid Dillow 1165175859bfSDavid Dillow /* Ensure that the wave engine is in normal operating mode. 1166175859bfSDavid Dillow */ 1167175859bfSDavid Dillow outl(0, io + SIS_WECCR); 1168175859bfSDavid Dillow 1169175859bfSDavid Dillow /* Go ahead and enable the DMA interrupts. They won't go live 1170175859bfSDavid Dillow * until we start a channel. 1171175859bfSDavid Dillow */ 1172175859bfSDavid Dillow outl(SIS_GIER_AUDIO_PLAY_DMA_IRQ_ENABLE | 1173175859bfSDavid Dillow SIS_GIER_AUDIO_RECORD_DMA_IRQ_ENABLE, io + SIS_GIER); 1174175859bfSDavid Dillow 1175175859bfSDavid Dillow return 0; 1176175859bfSDavid Dillow } 1177175859bfSDavid Dillow 1178175859bfSDavid Dillow #ifdef CONFIG_PM 1179175859bfSDavid Dillow static int sis_suspend(struct pci_dev *pci, pm_message_t state) 1180175859bfSDavid Dillow { 1181175859bfSDavid Dillow struct snd_card *card = pci_get_drvdata(pci); 1182175859bfSDavid Dillow struct sis7019 *sis = card->private_data; 1183175859bfSDavid Dillow void __iomem *ioaddr = sis->ioaddr; 1184175859bfSDavid Dillow int i; 1185175859bfSDavid Dillow 1186175859bfSDavid Dillow snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 1187175859bfSDavid Dillow snd_pcm_suspend_all(sis->pcm); 1188175859bfSDavid Dillow if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT) 1189175859bfSDavid Dillow snd_ac97_suspend(sis->ac97[0]); 1190175859bfSDavid Dillow if (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT) 1191175859bfSDavid Dillow snd_ac97_suspend(sis->ac97[1]); 1192175859bfSDavid Dillow if (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT) 1193175859bfSDavid Dillow snd_ac97_suspend(sis->ac97[2]); 1194175859bfSDavid Dillow 1195175859bfSDavid Dillow /* snd_pcm_suspend_all() stopped all channels, so we're quiescent. 1196175859bfSDavid Dillow */ 1197175859bfSDavid Dillow if (sis->irq >= 0) { 1198175859bfSDavid Dillow synchronize_irq(sis->irq); 1199175859bfSDavid Dillow free_irq(sis->irq, sis); 1200175859bfSDavid Dillow sis->irq = -1; 1201175859bfSDavid Dillow } 1202175859bfSDavid Dillow 1203175859bfSDavid Dillow /* Save the internal state away 1204175859bfSDavid Dillow */ 1205175859bfSDavid Dillow for (i = 0; i < 4; i++) { 1206175859bfSDavid Dillow memcpy_fromio(sis->suspend_state[i], ioaddr, 4096); 1207175859bfSDavid Dillow ioaddr += 4096; 1208175859bfSDavid Dillow } 1209175859bfSDavid Dillow 1210175859bfSDavid Dillow pci_disable_device(pci); 1211175859bfSDavid Dillow pci_save_state(pci); 1212175859bfSDavid Dillow pci_set_power_state(pci, pci_choose_state(pci, state)); 1213175859bfSDavid Dillow return 0; 1214175859bfSDavid Dillow } 1215175859bfSDavid Dillow 1216175859bfSDavid Dillow static int sis_resume(struct pci_dev *pci) 1217175859bfSDavid Dillow { 1218175859bfSDavid Dillow struct snd_card *card = pci_get_drvdata(pci); 1219175859bfSDavid Dillow struct sis7019 *sis = card->private_data; 1220175859bfSDavid Dillow void __iomem *ioaddr = sis->ioaddr; 1221175859bfSDavid Dillow int i; 1222175859bfSDavid Dillow 1223175859bfSDavid Dillow pci_set_power_state(pci, PCI_D0); 1224175859bfSDavid Dillow pci_restore_state(pci); 1225175859bfSDavid Dillow 1226175859bfSDavid Dillow if (pci_enable_device(pci) < 0) { 1227175859bfSDavid Dillow printk(KERN_ERR "sis7019: unable to re-enable device\n"); 1228175859bfSDavid Dillow goto error; 1229175859bfSDavid Dillow } 1230175859bfSDavid Dillow 1231175859bfSDavid Dillow if (sis_chip_init(sis)) { 1232175859bfSDavid Dillow printk(KERN_ERR "sis7019: unable to re-init controller\n"); 1233175859bfSDavid Dillow goto error; 1234175859bfSDavid Dillow } 1235175859bfSDavid Dillow 1236175859bfSDavid Dillow if (request_irq(pci->irq, sis_interrupt, IRQF_DISABLED|IRQF_SHARED, 1237175859bfSDavid Dillow card->shortname, sis)) { 1238175859bfSDavid Dillow printk(KERN_ERR "sis7019: unable to regain IRQ %d\n", pci->irq); 1239175859bfSDavid Dillow goto error; 1240175859bfSDavid Dillow } 1241175859bfSDavid Dillow 1242175859bfSDavid Dillow /* Restore saved state, then clear out the page we use for the 1243175859bfSDavid Dillow * silence buffer. 1244175859bfSDavid Dillow */ 1245175859bfSDavid Dillow for (i = 0; i < 4; i++) { 1246175859bfSDavid Dillow memcpy_toio(ioaddr, sis->suspend_state[i], 4096); 1247175859bfSDavid Dillow ioaddr += 4096; 1248175859bfSDavid Dillow } 1249175859bfSDavid Dillow 1250175859bfSDavid Dillow memset(sis->suspend_state[0], 0, 4096); 1251175859bfSDavid Dillow 1252175859bfSDavid Dillow sis->irq = pci->irq; 1253175859bfSDavid Dillow pci_set_master(pci); 1254175859bfSDavid Dillow 1255175859bfSDavid Dillow if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT) 1256175859bfSDavid Dillow snd_ac97_resume(sis->ac97[0]); 1257175859bfSDavid Dillow if (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT) 1258175859bfSDavid Dillow snd_ac97_resume(sis->ac97[1]); 1259175859bfSDavid Dillow if (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT) 1260175859bfSDavid Dillow snd_ac97_resume(sis->ac97[2]); 1261175859bfSDavid Dillow 1262175859bfSDavid Dillow snd_power_change_state(card, SNDRV_CTL_POWER_D0); 1263175859bfSDavid Dillow return 0; 1264175859bfSDavid Dillow 1265175859bfSDavid Dillow error: 1266175859bfSDavid Dillow snd_card_disconnect(card); 1267175859bfSDavid Dillow return -EIO; 1268175859bfSDavid Dillow } 1269175859bfSDavid Dillow #endif /* CONFIG_PM */ 1270175859bfSDavid Dillow 1271175859bfSDavid Dillow static int sis_alloc_suspend(struct sis7019 *sis) 1272175859bfSDavid Dillow { 1273175859bfSDavid Dillow int i; 1274175859bfSDavid Dillow 1275175859bfSDavid Dillow /* We need 16K to store the internal wave engine state during a 1276175859bfSDavid Dillow * suspend, but we don't need it to be contiguous, so play nice 1277175859bfSDavid Dillow * with the memory system. We'll also use this area for a silence 1278175859bfSDavid Dillow * buffer. 1279175859bfSDavid Dillow */ 1280175859bfSDavid Dillow for (i = 0; i < SIS_SUSPEND_PAGES; i++) { 1281175859bfSDavid Dillow sis->suspend_state[i] = kmalloc(4096, GFP_KERNEL); 1282175859bfSDavid Dillow if (!sis->suspend_state[i]) 1283175859bfSDavid Dillow return -ENOMEM; 1284175859bfSDavid Dillow } 1285175859bfSDavid Dillow memset(sis->suspend_state[0], 0, 4096); 1286175859bfSDavid Dillow 1287175859bfSDavid Dillow return 0; 1288175859bfSDavid Dillow } 1289175859bfSDavid Dillow 1290175859bfSDavid Dillow static int __devinit sis_chip_create(struct snd_card *card, 1291175859bfSDavid Dillow struct pci_dev *pci) 1292175859bfSDavid Dillow { 1293175859bfSDavid Dillow struct sis7019 *sis = card->private_data; 1294175859bfSDavid Dillow struct voice *voice; 1295175859bfSDavid Dillow static struct snd_device_ops ops = { 1296175859bfSDavid Dillow .dev_free = sis_dev_free, 1297175859bfSDavid Dillow }; 1298175859bfSDavid Dillow int rc; 1299175859bfSDavid Dillow int i; 1300175859bfSDavid Dillow 1301175859bfSDavid Dillow rc = pci_enable_device(pci); 1302175859bfSDavid Dillow if (rc) 1303175859bfSDavid Dillow goto error_out; 1304175859bfSDavid Dillow 1305175859bfSDavid Dillow if (pci_set_dma_mask(pci, DMA_30BIT_MASK) < 0) { 1306175859bfSDavid Dillow printk(KERN_ERR "sis7019: architecture does not support " 1307175859bfSDavid Dillow "30-bit PCI busmaster DMA"); 1308175859bfSDavid Dillow goto error_out_enabled; 1309175859bfSDavid Dillow } 1310175859bfSDavid Dillow 1311175859bfSDavid Dillow memset(sis, 0, sizeof(*sis)); 1312175859bfSDavid Dillow mutex_init(&sis->ac97_mutex); 1313175859bfSDavid Dillow spin_lock_init(&sis->voice_lock); 1314175859bfSDavid Dillow sis->card = card; 1315175859bfSDavid Dillow sis->pci = pci; 1316175859bfSDavid Dillow sis->irq = -1; 1317175859bfSDavid Dillow sis->ioport = pci_resource_start(pci, 0); 1318175859bfSDavid Dillow 1319175859bfSDavid Dillow rc = pci_request_regions(pci, "SiS7019"); 1320175859bfSDavid Dillow if (rc) { 1321175859bfSDavid Dillow printk(KERN_ERR "sis7019: unable request regions\n"); 1322175859bfSDavid Dillow goto error_out_enabled; 1323175859bfSDavid Dillow } 1324175859bfSDavid Dillow 1325175859bfSDavid Dillow rc = -EIO; 1326175859bfSDavid Dillow sis->ioaddr = ioremap_nocache(pci_resource_start(pci, 1), 0x4000); 1327175859bfSDavid Dillow if (!sis->ioaddr) { 1328175859bfSDavid Dillow printk(KERN_ERR "sis7019: unable to remap MMIO, aborting\n"); 1329175859bfSDavid Dillow goto error_out_cleanup; 1330175859bfSDavid Dillow } 1331175859bfSDavid Dillow 1332175859bfSDavid Dillow rc = sis_alloc_suspend(sis); 1333175859bfSDavid Dillow if (rc < 0) { 1334175859bfSDavid Dillow printk(KERN_ERR "sis7019: unable to allocate state storage\n"); 1335175859bfSDavid Dillow goto error_out_cleanup; 1336175859bfSDavid Dillow } 1337175859bfSDavid Dillow 1338175859bfSDavid Dillow rc = sis_chip_init(sis); 1339175859bfSDavid Dillow if (rc) 1340175859bfSDavid Dillow goto error_out_cleanup; 1341175859bfSDavid Dillow 1342175859bfSDavid Dillow if (request_irq(pci->irq, sis_interrupt, IRQF_DISABLED|IRQF_SHARED, 1343175859bfSDavid Dillow card->shortname, sis)) { 1344175859bfSDavid Dillow printk(KERN_ERR "unable to allocate irq %d\n", sis->irq); 1345175859bfSDavid Dillow goto error_out_cleanup; 1346175859bfSDavid Dillow } 1347175859bfSDavid Dillow 1348175859bfSDavid Dillow sis->irq = pci->irq; 1349175859bfSDavid Dillow pci_set_master(pci); 1350175859bfSDavid Dillow 1351175859bfSDavid Dillow for (i = 0; i < 64; i++) { 1352175859bfSDavid Dillow voice = &sis->voices[i]; 1353175859bfSDavid Dillow voice->num = i; 1354175859bfSDavid Dillow voice->ctrl_base = SIS_PLAY_DMA_ADDR(sis->ioaddr, i); 1355175859bfSDavid Dillow voice->wave_base = SIS_WAVE_ADDR(sis->ioaddr, i); 1356175859bfSDavid Dillow } 1357175859bfSDavid Dillow 1358175859bfSDavid Dillow voice = &sis->capture_voice; 1359175859bfSDavid Dillow voice->flags = VOICE_CAPTURE; 1360175859bfSDavid Dillow voice->num = SIS_CAPTURE_CHAN_AC97_PCM_IN; 1361175859bfSDavid Dillow voice->ctrl_base = SIS_CAPTURE_DMA_ADDR(sis->ioaddr, voice->num); 1362175859bfSDavid Dillow 1363175859bfSDavid Dillow rc = snd_device_new(card, SNDRV_DEV_LOWLEVEL, sis, &ops); 1364175859bfSDavid Dillow if (rc) 1365175859bfSDavid Dillow goto error_out_cleanup; 1366175859bfSDavid Dillow 1367175859bfSDavid Dillow snd_card_set_dev(card, &pci->dev); 1368175859bfSDavid Dillow 1369175859bfSDavid Dillow return 0; 1370175859bfSDavid Dillow 1371175859bfSDavid Dillow error_out_cleanup: 1372175859bfSDavid Dillow sis_chip_free(sis); 1373175859bfSDavid Dillow 1374175859bfSDavid Dillow error_out_enabled: 1375175859bfSDavid Dillow pci_disable_device(pci); 1376175859bfSDavid Dillow 1377175859bfSDavid Dillow error_out: 1378175859bfSDavid Dillow return rc; 1379175859bfSDavid Dillow } 1380175859bfSDavid Dillow 1381175859bfSDavid Dillow static int __devinit snd_sis7019_probe(struct pci_dev *pci, 1382175859bfSDavid Dillow const struct pci_device_id *pci_id) 1383175859bfSDavid Dillow { 1384175859bfSDavid Dillow struct snd_card *card; 1385175859bfSDavid Dillow struct sis7019 *sis; 1386175859bfSDavid Dillow int rc; 1387175859bfSDavid Dillow 1388175859bfSDavid Dillow rc = -ENOENT; 1389175859bfSDavid Dillow if (!enable) 1390175859bfSDavid Dillow goto error_out; 1391175859bfSDavid Dillow 1392175859bfSDavid Dillow rc = -ENOMEM; 1393175859bfSDavid Dillow card = snd_card_new(index, id, THIS_MODULE, sizeof(*sis)); 1394175859bfSDavid Dillow if (!card) 1395175859bfSDavid Dillow goto error_out; 1396175859bfSDavid Dillow 1397175859bfSDavid Dillow strcpy(card->driver, "SiS7019"); 1398175859bfSDavid Dillow strcpy(card->shortname, "SiS7019"); 1399175859bfSDavid Dillow rc = sis_chip_create(card, pci); 1400175859bfSDavid Dillow if (rc) 1401175859bfSDavid Dillow goto card_error_out; 1402175859bfSDavid Dillow 1403175859bfSDavid Dillow sis = card->private_data; 1404175859bfSDavid Dillow 1405175859bfSDavid Dillow rc = sis_mixer_create(sis); 1406175859bfSDavid Dillow if (rc) 1407175859bfSDavid Dillow goto card_error_out; 1408175859bfSDavid Dillow 1409175859bfSDavid Dillow rc = sis_pcm_create(sis); 1410175859bfSDavid Dillow if (rc) 1411175859bfSDavid Dillow goto card_error_out; 1412175859bfSDavid Dillow 1413175859bfSDavid Dillow snprintf(card->longname, sizeof(card->longname), 1414175859bfSDavid Dillow "%s Audio Accelerator with %s at 0x%lx, irq %d", 1415175859bfSDavid Dillow card->shortname, snd_ac97_get_short_name(sis->ac97[0]), 1416175859bfSDavid Dillow sis->ioport, sis->irq); 1417175859bfSDavid Dillow 1418175859bfSDavid Dillow rc = snd_card_register(card); 1419175859bfSDavid Dillow if (rc) 1420175859bfSDavid Dillow goto card_error_out; 1421175859bfSDavid Dillow 1422175859bfSDavid Dillow pci_set_drvdata(pci, card); 1423175859bfSDavid Dillow return 0; 1424175859bfSDavid Dillow 1425175859bfSDavid Dillow card_error_out: 1426175859bfSDavid Dillow snd_card_free(card); 1427175859bfSDavid Dillow 1428175859bfSDavid Dillow error_out: 1429175859bfSDavid Dillow return rc; 1430175859bfSDavid Dillow } 1431175859bfSDavid Dillow 1432175859bfSDavid Dillow static void __devexit snd_sis7019_remove(struct pci_dev *pci) 1433175859bfSDavid Dillow { 1434175859bfSDavid Dillow snd_card_free(pci_get_drvdata(pci)); 1435175859bfSDavid Dillow pci_set_drvdata(pci, NULL); 1436175859bfSDavid Dillow } 1437175859bfSDavid Dillow 1438175859bfSDavid Dillow static struct pci_driver sis7019_driver = { 1439175859bfSDavid Dillow .name = "SiS7019", 1440175859bfSDavid Dillow .id_table = snd_sis7019_ids, 1441175859bfSDavid Dillow .probe = snd_sis7019_probe, 1442175859bfSDavid Dillow .remove = __devexit_p(snd_sis7019_remove), 1443175859bfSDavid Dillow 1444175859bfSDavid Dillow #ifdef CONFIG_PM 1445175859bfSDavid Dillow .suspend = sis_suspend, 1446175859bfSDavid Dillow .resume = sis_resume, 1447175859bfSDavid Dillow #endif 1448175859bfSDavid Dillow }; 1449175859bfSDavid Dillow 1450175859bfSDavid Dillow static int __init sis7019_init(void) 1451175859bfSDavid Dillow { 1452175859bfSDavid Dillow return pci_register_driver(&sis7019_driver); 1453175859bfSDavid Dillow } 1454175859bfSDavid Dillow 1455175859bfSDavid Dillow static void __exit sis7019_exit(void) 1456175859bfSDavid Dillow { 1457175859bfSDavid Dillow pci_unregister_driver(&sis7019_driver); 1458175859bfSDavid Dillow } 1459175859bfSDavid Dillow 1460175859bfSDavid Dillow module_init(sis7019_init); 1461175859bfSDavid Dillow module_exit(sis7019_exit); 1462