17614a55eSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2175859bfSDavid Dillow /* 3175859bfSDavid Dillow * Driver for SiS7019 Audio Accelerator 4175859bfSDavid Dillow * 5175859bfSDavid Dillow * Copyright (C) 2004-2007, David Dillow 6175859bfSDavid Dillow * Written by David Dillow <dave@thedillows.org> 7175859bfSDavid Dillow * Inspired by the Trident 4D-WaveDX/NX driver. 8175859bfSDavid Dillow * 9175859bfSDavid Dillow * All rights reserved. 10175859bfSDavid Dillow */ 11175859bfSDavid Dillow 12175859bfSDavid Dillow #include <linux/init.h> 13175859bfSDavid Dillow #include <linux/pci.h> 14175859bfSDavid Dillow #include <linux/time.h> 155a0e3ad6STejun Heo #include <linux/slab.h> 1665a77217SPaul Gortmaker #include <linux/module.h> 17175859bfSDavid Dillow #include <linux/interrupt.h> 18175859bfSDavid Dillow #include <linux/delay.h> 19175859bfSDavid Dillow #include <sound/core.h> 20175859bfSDavid Dillow #include <sound/ac97_codec.h> 21175859bfSDavid Dillow #include <sound/initval.h> 22175859bfSDavid Dillow #include "sis7019.h" 23175859bfSDavid Dillow 24175859bfSDavid Dillow MODULE_AUTHOR("David Dillow <dave@thedillows.org>"); 25175859bfSDavid Dillow MODULE_DESCRIPTION("SiS7019"); 26175859bfSDavid Dillow MODULE_LICENSE("GPL"); 27175859bfSDavid Dillow 28175859bfSDavid Dillow static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ 29175859bfSDavid Dillow static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 30a67ff6a5SRusty Russell static bool enable = 1; 31fc084e0bSDavid Dillow static int codecs = 1; 32175859bfSDavid Dillow 33175859bfSDavid Dillow module_param(index, int, 0444); 34175859bfSDavid Dillow MODULE_PARM_DESC(index, "Index value for SiS7019 Audio Accelerator."); 35175859bfSDavid Dillow module_param(id, charp, 0444); 36175859bfSDavid Dillow MODULE_PARM_DESC(id, "ID string for SiS7019 Audio Accelerator."); 37175859bfSDavid Dillow module_param(enable, bool, 0444); 38175859bfSDavid Dillow MODULE_PARM_DESC(enable, "Enable SiS7019 Audio Accelerator."); 39fc084e0bSDavid Dillow module_param(codecs, int, 0444); 40fc084e0bSDavid Dillow MODULE_PARM_DESC(codecs, "Set bit to indicate that codec number is expected to be present (default 1)"); 41175859bfSDavid Dillow 429baa3c34SBenoit Taine static const struct pci_device_id snd_sis7019_ids[] = { 43175859bfSDavid Dillow { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x7019) }, 44175859bfSDavid Dillow { 0, } 45175859bfSDavid Dillow }; 46175859bfSDavid Dillow 47175859bfSDavid Dillow MODULE_DEVICE_TABLE(pci, snd_sis7019_ids); 48175859bfSDavid Dillow 49175859bfSDavid Dillow /* There are three timing modes for the voices. 50175859bfSDavid Dillow * 51175859bfSDavid Dillow * For both playback and capture, when the buffer is one or two periods long, 52175859bfSDavid Dillow * we use the hardware's built-in Mid-Loop Interrupt and End-Loop Interrupt 53175859bfSDavid Dillow * to let us know when the periods have ended. 54175859bfSDavid Dillow * 55175859bfSDavid Dillow * When performing playback with more than two periods per buffer, we set 56175859bfSDavid Dillow * the "Stop Sample Offset" and tell the hardware to interrupt us when we 57175859bfSDavid Dillow * reach it. We then update the offset and continue on until we are 58175859bfSDavid Dillow * interrupted for the next period. 59175859bfSDavid Dillow * 60175859bfSDavid Dillow * Capture channels do not have a SSO, so we allocate a playback channel to 61175859bfSDavid Dillow * use as a timer for the capture periods. We use the SSO on the playback 62175859bfSDavid Dillow * channel to clock out virtual periods, and adjust the virtual period length 63175859bfSDavid Dillow * to maintain synchronization. This algorithm came from the Trident driver. 64175859bfSDavid Dillow * 65175859bfSDavid Dillow * FIXME: It'd be nice to make use of some of the synth features in the 66175859bfSDavid Dillow * hardware, but a woeful lack of documentation is a significant roadblock. 67175859bfSDavid Dillow */ 68175859bfSDavid Dillow struct voice { 69175859bfSDavid Dillow u16 flags; 70175859bfSDavid Dillow #define VOICE_IN_USE 1 71175859bfSDavid Dillow #define VOICE_CAPTURE 2 72175859bfSDavid Dillow #define VOICE_SSO_TIMING 4 73175859bfSDavid Dillow #define VOICE_SYNC_TIMING 8 74175859bfSDavid Dillow u16 sync_cso; 75175859bfSDavid Dillow u16 period_size; 76175859bfSDavid Dillow u16 buffer_size; 77175859bfSDavid Dillow u16 sync_period_size; 78175859bfSDavid Dillow u16 sync_buffer_size; 79175859bfSDavid Dillow u32 sso; 80175859bfSDavid Dillow u32 vperiod; 81175859bfSDavid Dillow struct snd_pcm_substream *substream; 82175859bfSDavid Dillow struct voice *timing; 83175859bfSDavid Dillow void __iomem *ctrl_base; 84175859bfSDavid Dillow void __iomem *wave_base; 85175859bfSDavid Dillow void __iomem *sync_base; 86175859bfSDavid Dillow int num; 87175859bfSDavid Dillow }; 88175859bfSDavid Dillow 89175859bfSDavid Dillow /* We need four pages to store our wave parameters during a suspend. If 90175859bfSDavid Dillow * we're not doing power management, we still need to allocate a page 91175859bfSDavid Dillow * for the silence buffer. 92175859bfSDavid Dillow */ 93c7561cd8STakashi Iwai #ifdef CONFIG_PM_SLEEP 94175859bfSDavid Dillow #define SIS_SUSPEND_PAGES 4 95175859bfSDavid Dillow #else 96175859bfSDavid Dillow #define SIS_SUSPEND_PAGES 1 97175859bfSDavid Dillow #endif 98175859bfSDavid Dillow 99175859bfSDavid Dillow struct sis7019 { 100175859bfSDavid Dillow unsigned long ioport; 101175859bfSDavid Dillow void __iomem *ioaddr; 102175859bfSDavid Dillow int irq; 103175859bfSDavid Dillow int codecs_present; 104175859bfSDavid Dillow 105175859bfSDavid Dillow struct pci_dev *pci; 106175859bfSDavid Dillow struct snd_pcm *pcm; 107175859bfSDavid Dillow struct snd_card *card; 108175859bfSDavid Dillow struct snd_ac97 *ac97[3]; 109175859bfSDavid Dillow 110175859bfSDavid Dillow /* Protect against more than one thread hitting the AC97 111175859bfSDavid Dillow * registers (in a more polite manner than pounding the hardware 112175859bfSDavid Dillow * semaphore) 113175859bfSDavid Dillow */ 114175859bfSDavid Dillow struct mutex ac97_mutex; 115175859bfSDavid Dillow 116175859bfSDavid Dillow /* voice_lock protects allocation/freeing of the voice descriptions 117175859bfSDavid Dillow */ 118175859bfSDavid Dillow spinlock_t voice_lock; 119175859bfSDavid Dillow 120175859bfSDavid Dillow struct voice voices[64]; 121175859bfSDavid Dillow struct voice capture_voice; 122175859bfSDavid Dillow 123175859bfSDavid Dillow /* Allocate pages to store the internal wave state during 124175859bfSDavid Dillow * suspends. When we're operating, this can be used as a silence 125175859bfSDavid Dillow * buffer for a timing channel. 126175859bfSDavid Dillow */ 127175859bfSDavid Dillow void *suspend_state[SIS_SUSPEND_PAGES]; 128175859bfSDavid Dillow 129175859bfSDavid Dillow int silence_users; 130175859bfSDavid Dillow dma_addr_t silence_dma_addr; 131175859bfSDavid Dillow }; 132175859bfSDavid Dillow 133fc084e0bSDavid Dillow /* These values are also used by the module param 'codecs' to indicate 134fc084e0bSDavid Dillow * which codecs should be present. 135fc084e0bSDavid Dillow */ 136175859bfSDavid Dillow #define SIS_PRIMARY_CODEC_PRESENT 0x0001 137175859bfSDavid Dillow #define SIS_SECONDARY_CODEC_PRESENT 0x0002 138175859bfSDavid Dillow #define SIS_TERTIARY_CODEC_PRESENT 0x0004 139175859bfSDavid Dillow 140175859bfSDavid Dillow /* The HW offset parameters (Loop End, Stop Sample, End Sample) have a 141175859bfSDavid Dillow * documented range of 8-0xfff8 samples. Given that they are 0-based, 142175859bfSDavid Dillow * that places our period/buffer range at 9-0xfff9 samples. That makes the 143175859bfSDavid Dillow * max buffer size 0xfff9 samples * 2 channels * 2 bytes per sample, and 144175859bfSDavid Dillow * max samples / min samples gives us the max periods in a buffer. 145175859bfSDavid Dillow * 146175859bfSDavid Dillow * We'll add a constraint upon open that limits the period and buffer sample 147175859bfSDavid Dillow * size to values that are legal for the hardware. 148175859bfSDavid Dillow */ 149dee49895SBhumika Goyal static const struct snd_pcm_hardware sis_playback_hw_info = { 150175859bfSDavid Dillow .info = (SNDRV_PCM_INFO_MMAP | 151175859bfSDavid Dillow SNDRV_PCM_INFO_MMAP_VALID | 152175859bfSDavid Dillow SNDRV_PCM_INFO_INTERLEAVED | 153175859bfSDavid Dillow SNDRV_PCM_INFO_BLOCK_TRANSFER | 154175859bfSDavid Dillow SNDRV_PCM_INFO_SYNC_START | 155175859bfSDavid Dillow SNDRV_PCM_INFO_RESUME), 156175859bfSDavid Dillow .formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 | 157175859bfSDavid Dillow SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE), 158175859bfSDavid Dillow .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_CONTINUOUS, 159175859bfSDavid Dillow .rate_min = 4000, 160175859bfSDavid Dillow .rate_max = 48000, 161175859bfSDavid Dillow .channels_min = 1, 162175859bfSDavid Dillow .channels_max = 2, 163175859bfSDavid Dillow .buffer_bytes_max = (0xfff9 * 4), 164175859bfSDavid Dillow .period_bytes_min = 9, 165175859bfSDavid Dillow .period_bytes_max = (0xfff9 * 4), 166175859bfSDavid Dillow .periods_min = 1, 167175859bfSDavid Dillow .periods_max = (0xfff9 / 9), 168175859bfSDavid Dillow }; 169175859bfSDavid Dillow 170dee49895SBhumika Goyal static const struct snd_pcm_hardware sis_capture_hw_info = { 171175859bfSDavid Dillow .info = (SNDRV_PCM_INFO_MMAP | 172175859bfSDavid Dillow SNDRV_PCM_INFO_MMAP_VALID | 173175859bfSDavid Dillow SNDRV_PCM_INFO_INTERLEAVED | 174175859bfSDavid Dillow SNDRV_PCM_INFO_BLOCK_TRANSFER | 175175859bfSDavid Dillow SNDRV_PCM_INFO_SYNC_START | 176175859bfSDavid Dillow SNDRV_PCM_INFO_RESUME), 177175859bfSDavid Dillow .formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 | 178175859bfSDavid Dillow SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE), 179175859bfSDavid Dillow .rates = SNDRV_PCM_RATE_48000, 180175859bfSDavid Dillow .rate_min = 4000, 181175859bfSDavid Dillow .rate_max = 48000, 182175859bfSDavid Dillow .channels_min = 1, 183175859bfSDavid Dillow .channels_max = 2, 184175859bfSDavid Dillow .buffer_bytes_max = (0xfff9 * 4), 185175859bfSDavid Dillow .period_bytes_min = 9, 186175859bfSDavid Dillow .period_bytes_max = (0xfff9 * 4), 187175859bfSDavid Dillow .periods_min = 1, 188175859bfSDavid Dillow .periods_max = (0xfff9 / 9), 189175859bfSDavid Dillow }; 190175859bfSDavid Dillow 191175859bfSDavid Dillow static void sis_update_sso(struct voice *voice, u16 period) 192175859bfSDavid Dillow { 193175859bfSDavid Dillow void __iomem *base = voice->ctrl_base; 194175859bfSDavid Dillow 195175859bfSDavid Dillow voice->sso += period; 196175859bfSDavid Dillow if (voice->sso >= voice->buffer_size) 197175859bfSDavid Dillow voice->sso -= voice->buffer_size; 198175859bfSDavid Dillow 199175859bfSDavid Dillow /* Enforce the documented hardware minimum offset */ 200175859bfSDavid Dillow if (voice->sso < 8) 201175859bfSDavid Dillow voice->sso = 8; 202175859bfSDavid Dillow 203175859bfSDavid Dillow /* The SSO is in the upper 16 bits of the register. */ 204175859bfSDavid Dillow writew(voice->sso & 0xffff, base + SIS_PLAY_DMA_SSO_ESO + 2); 205175859bfSDavid Dillow } 206175859bfSDavid Dillow 207175859bfSDavid Dillow static void sis_update_voice(struct voice *voice) 208175859bfSDavid Dillow { 209175859bfSDavid Dillow if (voice->flags & VOICE_SSO_TIMING) { 210175859bfSDavid Dillow sis_update_sso(voice, voice->period_size); 211175859bfSDavid Dillow } else if (voice->flags & VOICE_SYNC_TIMING) { 212175859bfSDavid Dillow int sync; 213175859bfSDavid Dillow 214175859bfSDavid Dillow /* If we've not hit the end of the virtual period, update 215175859bfSDavid Dillow * our records and keep going. 216175859bfSDavid Dillow */ 217175859bfSDavid Dillow if (voice->vperiod > voice->period_size) { 218175859bfSDavid Dillow voice->vperiod -= voice->period_size; 219175859bfSDavid Dillow if (voice->vperiod < voice->period_size) 220175859bfSDavid Dillow sis_update_sso(voice, voice->vperiod); 221175859bfSDavid Dillow else 222175859bfSDavid Dillow sis_update_sso(voice, voice->period_size); 223175859bfSDavid Dillow return; 224175859bfSDavid Dillow } 225175859bfSDavid Dillow 226175859bfSDavid Dillow /* Calculate our relative offset between the target and 227175859bfSDavid Dillow * the actual CSO value. Since we're operating in a loop, 228175859bfSDavid Dillow * if the value is more than half way around, we can 229175859bfSDavid Dillow * consider ourselves wrapped. 230175859bfSDavid Dillow */ 231175859bfSDavid Dillow sync = voice->sync_cso; 232175859bfSDavid Dillow sync -= readw(voice->sync_base + SIS_CAPTURE_DMA_FORMAT_CSO); 233175859bfSDavid Dillow if (sync > (voice->sync_buffer_size / 2)) 234175859bfSDavid Dillow sync -= voice->sync_buffer_size; 235175859bfSDavid Dillow 236175859bfSDavid Dillow /* If sync is positive, then we interrupted too early, and 237175859bfSDavid Dillow * we'll need to come back in a few samples and try again. 238175859bfSDavid Dillow * There's a minimum wait, as it takes some time for the DMA 239175859bfSDavid Dillow * engine to startup, etc... 240175859bfSDavid Dillow */ 241175859bfSDavid Dillow if (sync > 0) { 242175859bfSDavid Dillow if (sync < 16) 243175859bfSDavid Dillow sync = 16; 244175859bfSDavid Dillow sis_update_sso(voice, sync); 245175859bfSDavid Dillow return; 246175859bfSDavid Dillow } 247175859bfSDavid Dillow 248175859bfSDavid Dillow /* Ok, we interrupted right on time, or (hopefully) just 249175859bfSDavid Dillow * a bit late. We'll adjst our next waiting period based 250175859bfSDavid Dillow * on how close we got. 251175859bfSDavid Dillow * 252175859bfSDavid Dillow * We need to stay just behind the actual channel to ensure 253175859bfSDavid Dillow * it really is past a period when we get our interrupt -- 254175859bfSDavid Dillow * otherwise we'll fall into the early code above and have 255175859bfSDavid Dillow * a minimum wait time, which makes us quite late here, 256175859bfSDavid Dillow * eating into the user's time to refresh the buffer, esp. 257175859bfSDavid Dillow * if using small periods. 258175859bfSDavid Dillow * 259175859bfSDavid Dillow * If we're less than 9 samples behind, we're on target. 2603a3d5fd1SDavid Dillow * Otherwise, shorten the next vperiod by the amount we've 2613a3d5fd1SDavid Dillow * been delayed. 262175859bfSDavid Dillow */ 263175859bfSDavid Dillow if (sync > -9) 264175859bfSDavid Dillow voice->vperiod = voice->sync_period_size + 1; 265175859bfSDavid Dillow else 2663a3d5fd1SDavid Dillow voice->vperiod = voice->sync_period_size + sync + 10; 267175859bfSDavid Dillow 268175859bfSDavid Dillow if (voice->vperiod < voice->buffer_size) { 269175859bfSDavid Dillow sis_update_sso(voice, voice->vperiod); 270175859bfSDavid Dillow voice->vperiod = 0; 271175859bfSDavid Dillow } else 272175859bfSDavid Dillow sis_update_sso(voice, voice->period_size); 273175859bfSDavid Dillow 274175859bfSDavid Dillow sync = voice->sync_cso + voice->sync_period_size; 275175859bfSDavid Dillow if (sync >= voice->sync_buffer_size) 276175859bfSDavid Dillow sync -= voice->sync_buffer_size; 277175859bfSDavid Dillow voice->sync_cso = sync; 278175859bfSDavid Dillow } 279175859bfSDavid Dillow 280175859bfSDavid Dillow snd_pcm_period_elapsed(voice->substream); 281175859bfSDavid Dillow } 282175859bfSDavid Dillow 283175859bfSDavid Dillow static void sis_voice_irq(u32 status, struct voice *voice) 284175859bfSDavid Dillow { 285175859bfSDavid Dillow int bit; 286175859bfSDavid Dillow 287175859bfSDavid Dillow while (status) { 288175859bfSDavid Dillow bit = __ffs(status); 289175859bfSDavid Dillow status >>= bit + 1; 290175859bfSDavid Dillow voice += bit; 291175859bfSDavid Dillow sis_update_voice(voice); 292175859bfSDavid Dillow voice++; 293175859bfSDavid Dillow } 294175859bfSDavid Dillow } 295175859bfSDavid Dillow 296175859bfSDavid Dillow static irqreturn_t sis_interrupt(int irq, void *dev) 297175859bfSDavid Dillow { 298175859bfSDavid Dillow struct sis7019 *sis = dev; 299175859bfSDavid Dillow unsigned long io = sis->ioport; 300175859bfSDavid Dillow struct voice *voice; 301175859bfSDavid Dillow u32 intr, status; 302175859bfSDavid Dillow 303175859bfSDavid Dillow /* We only use the DMA interrupts, and we don't enable any other 30425985edcSLucas De Marchi * source of interrupts. But, it is possible to see an interrupt 305175859bfSDavid Dillow * status that didn't actually interrupt us, so eliminate anything 306175859bfSDavid Dillow * we're not expecting to avoid falsely claiming an IRQ, and an 307175859bfSDavid Dillow * ensuing endless loop. 308175859bfSDavid Dillow */ 309175859bfSDavid Dillow intr = inl(io + SIS_GISR); 310175859bfSDavid Dillow intr &= SIS_GISR_AUDIO_PLAY_DMA_IRQ_STATUS | 311175859bfSDavid Dillow SIS_GISR_AUDIO_RECORD_DMA_IRQ_STATUS; 312175859bfSDavid Dillow if (!intr) 313175859bfSDavid Dillow return IRQ_NONE; 314175859bfSDavid Dillow 315175859bfSDavid Dillow do { 316175859bfSDavid Dillow status = inl(io + SIS_PISR_A); 317175859bfSDavid Dillow if (status) { 318175859bfSDavid Dillow sis_voice_irq(status, sis->voices); 319175859bfSDavid Dillow outl(status, io + SIS_PISR_A); 320175859bfSDavid Dillow } 321175859bfSDavid Dillow 322175859bfSDavid Dillow status = inl(io + SIS_PISR_B); 323175859bfSDavid Dillow if (status) { 324175859bfSDavid Dillow sis_voice_irq(status, &sis->voices[32]); 325175859bfSDavid Dillow outl(status, io + SIS_PISR_B); 326175859bfSDavid Dillow } 327175859bfSDavid Dillow 328175859bfSDavid Dillow status = inl(io + SIS_RISR); 329175859bfSDavid Dillow if (status) { 330175859bfSDavid Dillow voice = &sis->capture_voice; 331175859bfSDavid Dillow if (!voice->timing) 332175859bfSDavid Dillow snd_pcm_period_elapsed(voice->substream); 333175859bfSDavid Dillow 334175859bfSDavid Dillow outl(status, io + SIS_RISR); 335175859bfSDavid Dillow } 336175859bfSDavid Dillow 337175859bfSDavid Dillow outl(intr, io + SIS_GISR); 338175859bfSDavid Dillow intr = inl(io + SIS_GISR); 339175859bfSDavid Dillow intr &= SIS_GISR_AUDIO_PLAY_DMA_IRQ_STATUS | 340175859bfSDavid Dillow SIS_GISR_AUDIO_RECORD_DMA_IRQ_STATUS; 341175859bfSDavid Dillow } while (intr); 342175859bfSDavid Dillow 343175859bfSDavid Dillow return IRQ_HANDLED; 344175859bfSDavid Dillow } 345175859bfSDavid Dillow 346175859bfSDavid Dillow static u32 sis_rate_to_delta(unsigned int rate) 347175859bfSDavid Dillow { 348175859bfSDavid Dillow u32 delta; 349175859bfSDavid Dillow 350175859bfSDavid Dillow /* This was copied from the trident driver, but it seems its gotten 351175859bfSDavid Dillow * around a bit... nevertheless, it works well. 352175859bfSDavid Dillow * 353175859bfSDavid Dillow * We special case 44100 and 8000 since rounding with the equation 354175859bfSDavid Dillow * does not give us an accurate enough value. For 11025 and 22050 355175859bfSDavid Dillow * the equation gives us the best answer. All other frequencies will 356175859bfSDavid Dillow * also use the equation. JDW 357175859bfSDavid Dillow */ 358175859bfSDavid Dillow if (rate == 44100) 359175859bfSDavid Dillow delta = 0xeb3; 360175859bfSDavid Dillow else if (rate == 8000) 361175859bfSDavid Dillow delta = 0x2ab; 362175859bfSDavid Dillow else if (rate == 48000) 363175859bfSDavid Dillow delta = 0x1000; 364175859bfSDavid Dillow else 365e08eaf40SLars-Peter Clausen delta = DIV_ROUND_CLOSEST(rate << 12, 48000) & 0x0000ffff; 366175859bfSDavid Dillow return delta; 367175859bfSDavid Dillow } 368175859bfSDavid Dillow 369175859bfSDavid Dillow static void __sis_map_silence(struct sis7019 *sis) 370175859bfSDavid Dillow { 371175859bfSDavid Dillow /* Helper function: must hold sis->voice_lock on entry */ 372175859bfSDavid Dillow if (!sis->silence_users) 373412b979cSQuentin Lambert sis->silence_dma_addr = dma_map_single(&sis->pci->dev, 374175859bfSDavid Dillow sis->suspend_state[0], 375412b979cSQuentin Lambert 4096, DMA_TO_DEVICE); 376175859bfSDavid Dillow sis->silence_users++; 377175859bfSDavid Dillow } 378175859bfSDavid Dillow 379175859bfSDavid Dillow static void __sis_unmap_silence(struct sis7019 *sis) 380175859bfSDavid Dillow { 381175859bfSDavid Dillow /* Helper function: must hold sis->voice_lock on entry */ 382175859bfSDavid Dillow sis->silence_users--; 383175859bfSDavid Dillow if (!sis->silence_users) 384412b979cSQuentin Lambert dma_unmap_single(&sis->pci->dev, sis->silence_dma_addr, 4096, 385412b979cSQuentin Lambert DMA_TO_DEVICE); 386175859bfSDavid Dillow } 387175859bfSDavid Dillow 388175859bfSDavid Dillow static void sis_free_voice(struct sis7019 *sis, struct voice *voice) 389175859bfSDavid Dillow { 390175859bfSDavid Dillow unsigned long flags; 391175859bfSDavid Dillow 392175859bfSDavid Dillow spin_lock_irqsave(&sis->voice_lock, flags); 393175859bfSDavid Dillow if (voice->timing) { 394175859bfSDavid Dillow __sis_unmap_silence(sis); 395175859bfSDavid Dillow voice->timing->flags &= ~(VOICE_IN_USE | VOICE_SSO_TIMING | 396175859bfSDavid Dillow VOICE_SYNC_TIMING); 397175859bfSDavid Dillow voice->timing = NULL; 398175859bfSDavid Dillow } 399175859bfSDavid Dillow voice->flags &= ~(VOICE_IN_USE | VOICE_SSO_TIMING | VOICE_SYNC_TIMING); 400175859bfSDavid Dillow spin_unlock_irqrestore(&sis->voice_lock, flags); 401175859bfSDavid Dillow } 402175859bfSDavid Dillow 403175859bfSDavid Dillow static struct voice *__sis_alloc_playback_voice(struct sis7019 *sis) 404175859bfSDavid Dillow { 405175859bfSDavid Dillow /* Must hold the voice_lock on entry */ 406175859bfSDavid Dillow struct voice *voice; 407175859bfSDavid Dillow int i; 408175859bfSDavid Dillow 409175859bfSDavid Dillow for (i = 0; i < 64; i++) { 410175859bfSDavid Dillow voice = &sis->voices[i]; 411175859bfSDavid Dillow if (voice->flags & VOICE_IN_USE) 412175859bfSDavid Dillow continue; 413175859bfSDavid Dillow voice->flags |= VOICE_IN_USE; 414175859bfSDavid Dillow goto found_one; 415175859bfSDavid Dillow } 416175859bfSDavid Dillow voice = NULL; 417175859bfSDavid Dillow 418175859bfSDavid Dillow found_one: 419175859bfSDavid Dillow return voice; 420175859bfSDavid Dillow } 421175859bfSDavid Dillow 422175859bfSDavid Dillow static struct voice *sis_alloc_playback_voice(struct sis7019 *sis) 423175859bfSDavid Dillow { 424175859bfSDavid Dillow struct voice *voice; 425175859bfSDavid Dillow unsigned long flags; 426175859bfSDavid Dillow 427175859bfSDavid Dillow spin_lock_irqsave(&sis->voice_lock, flags); 428175859bfSDavid Dillow voice = __sis_alloc_playback_voice(sis); 429175859bfSDavid Dillow spin_unlock_irqrestore(&sis->voice_lock, flags); 430175859bfSDavid Dillow 431175859bfSDavid Dillow return voice; 432175859bfSDavid Dillow } 433175859bfSDavid Dillow 434175859bfSDavid Dillow static int sis_alloc_timing_voice(struct snd_pcm_substream *substream, 435175859bfSDavid Dillow struct snd_pcm_hw_params *hw_params) 436175859bfSDavid Dillow { 437175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 438175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 439175859bfSDavid Dillow struct voice *voice = runtime->private_data; 440175859bfSDavid Dillow unsigned int period_size, buffer_size; 441175859bfSDavid Dillow unsigned long flags; 442175859bfSDavid Dillow int needed; 443175859bfSDavid Dillow 444175859bfSDavid Dillow /* If there are one or two periods per buffer, we don't need a 445175859bfSDavid Dillow * timing voice, as we can use the capture channel's interrupts 446175859bfSDavid Dillow * to clock out the periods. 447175859bfSDavid Dillow */ 448175859bfSDavid Dillow period_size = params_period_size(hw_params); 449175859bfSDavid Dillow buffer_size = params_buffer_size(hw_params); 450175859bfSDavid Dillow needed = (period_size != buffer_size && 451175859bfSDavid Dillow period_size != (buffer_size / 2)); 452175859bfSDavid Dillow 453175859bfSDavid Dillow if (needed && !voice->timing) { 454175859bfSDavid Dillow spin_lock_irqsave(&sis->voice_lock, flags); 455175859bfSDavid Dillow voice->timing = __sis_alloc_playback_voice(sis); 456175859bfSDavid Dillow if (voice->timing) 457175859bfSDavid Dillow __sis_map_silence(sis); 458175859bfSDavid Dillow spin_unlock_irqrestore(&sis->voice_lock, flags); 459175859bfSDavid Dillow if (!voice->timing) 460175859bfSDavid Dillow return -ENOMEM; 461175859bfSDavid Dillow voice->timing->substream = substream; 462175859bfSDavid Dillow } else if (!needed && voice->timing) { 463175859bfSDavid Dillow sis_free_voice(sis, voice); 464175859bfSDavid Dillow voice->timing = NULL; 465175859bfSDavid Dillow } 466175859bfSDavid Dillow 467175859bfSDavid Dillow return 0; 468175859bfSDavid Dillow } 469175859bfSDavid Dillow 470175859bfSDavid Dillow static int sis_playback_open(struct snd_pcm_substream *substream) 471175859bfSDavid Dillow { 472175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 473175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 474175859bfSDavid Dillow struct voice *voice; 475175859bfSDavid Dillow 476175859bfSDavid Dillow voice = sis_alloc_playback_voice(sis); 477175859bfSDavid Dillow if (!voice) 478175859bfSDavid Dillow return -EAGAIN; 479175859bfSDavid Dillow 480175859bfSDavid Dillow voice->substream = substream; 481175859bfSDavid Dillow runtime->private_data = voice; 482175859bfSDavid Dillow runtime->hw = sis_playback_hw_info; 483175859bfSDavid Dillow snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 484175859bfSDavid Dillow 9, 0xfff9); 485175859bfSDavid Dillow snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 486175859bfSDavid Dillow 9, 0xfff9); 487175859bfSDavid Dillow snd_pcm_set_sync(substream); 488175859bfSDavid Dillow return 0; 489175859bfSDavid Dillow } 490175859bfSDavid Dillow 491175859bfSDavid Dillow static int sis_substream_close(struct snd_pcm_substream *substream) 492175859bfSDavid Dillow { 493175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 494175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 495175859bfSDavid Dillow struct voice *voice = runtime->private_data; 496175859bfSDavid Dillow 497175859bfSDavid Dillow sis_free_voice(sis, voice); 498175859bfSDavid Dillow return 0; 499175859bfSDavid Dillow } 500175859bfSDavid Dillow 501175859bfSDavid Dillow static int sis_pcm_playback_prepare(struct snd_pcm_substream *substream) 502175859bfSDavid Dillow { 503175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 504175859bfSDavid Dillow struct voice *voice = runtime->private_data; 505175859bfSDavid Dillow void __iomem *ctrl_base = voice->ctrl_base; 506175859bfSDavid Dillow void __iomem *wave_base = voice->wave_base; 507175859bfSDavid Dillow u32 format, dma_addr, control, sso_eso, delta, reg; 508175859bfSDavid Dillow u16 leo; 509175859bfSDavid Dillow 510175859bfSDavid Dillow /* We rely on the PCM core to ensure that the parameters for this 511175859bfSDavid Dillow * substream do not change on us while we're programming the HW. 512175859bfSDavid Dillow */ 513175859bfSDavid Dillow format = 0; 514175859bfSDavid Dillow if (snd_pcm_format_width(runtime->format) == 8) 515175859bfSDavid Dillow format |= SIS_PLAY_DMA_FORMAT_8BIT; 516175859bfSDavid Dillow if (!snd_pcm_format_signed(runtime->format)) 517175859bfSDavid Dillow format |= SIS_PLAY_DMA_FORMAT_UNSIGNED; 518175859bfSDavid Dillow if (runtime->channels == 1) 519175859bfSDavid Dillow format |= SIS_PLAY_DMA_FORMAT_MONO; 520175859bfSDavid Dillow 521175859bfSDavid Dillow /* The baseline setup is for a single period per buffer, and 522175859bfSDavid Dillow * we add bells and whistles as needed from there. 523175859bfSDavid Dillow */ 524175859bfSDavid Dillow dma_addr = runtime->dma_addr; 525175859bfSDavid Dillow leo = runtime->buffer_size - 1; 526175859bfSDavid Dillow control = leo | SIS_PLAY_DMA_LOOP | SIS_PLAY_DMA_INTR_AT_LEO; 527175859bfSDavid Dillow sso_eso = leo; 528175859bfSDavid Dillow 529175859bfSDavid Dillow if (runtime->period_size == (runtime->buffer_size / 2)) { 530175859bfSDavid Dillow control |= SIS_PLAY_DMA_INTR_AT_MLP; 531175859bfSDavid Dillow } else if (runtime->period_size != runtime->buffer_size) { 532175859bfSDavid Dillow voice->flags |= VOICE_SSO_TIMING; 533175859bfSDavid Dillow voice->sso = runtime->period_size - 1; 534175859bfSDavid Dillow voice->period_size = runtime->period_size; 535175859bfSDavid Dillow voice->buffer_size = runtime->buffer_size; 536175859bfSDavid Dillow 537175859bfSDavid Dillow control &= ~SIS_PLAY_DMA_INTR_AT_LEO; 538175859bfSDavid Dillow control |= SIS_PLAY_DMA_INTR_AT_SSO; 539175859bfSDavid Dillow sso_eso |= (runtime->period_size - 1) << 16; 540175859bfSDavid Dillow } 541175859bfSDavid Dillow 542175859bfSDavid Dillow delta = sis_rate_to_delta(runtime->rate); 543175859bfSDavid Dillow 544175859bfSDavid Dillow /* Ok, we're ready to go, set up the channel. 545175859bfSDavid Dillow */ 546175859bfSDavid Dillow writel(format, ctrl_base + SIS_PLAY_DMA_FORMAT_CSO); 547175859bfSDavid Dillow writel(dma_addr, ctrl_base + SIS_PLAY_DMA_BASE); 548175859bfSDavid Dillow writel(control, ctrl_base + SIS_PLAY_DMA_CONTROL); 549175859bfSDavid Dillow writel(sso_eso, ctrl_base + SIS_PLAY_DMA_SSO_ESO); 550175859bfSDavid Dillow 551175859bfSDavid Dillow for (reg = 0; reg < SIS_WAVE_SIZE; reg += 4) 552175859bfSDavid Dillow writel(0, wave_base + reg); 553175859bfSDavid Dillow 554175859bfSDavid Dillow writel(SIS_WAVE_GENERAL_WAVE_VOLUME, wave_base + SIS_WAVE_GENERAL); 555175859bfSDavid Dillow writel(delta << 16, wave_base + SIS_WAVE_GENERAL_ARTICULATION); 556175859bfSDavid Dillow writel(SIS_WAVE_CHANNEL_CONTROL_FIRST_SAMPLE | 557175859bfSDavid Dillow SIS_WAVE_CHANNEL_CONTROL_AMP_ENABLE | 558175859bfSDavid Dillow SIS_WAVE_CHANNEL_CONTROL_INTERPOLATE_ENABLE, 559175859bfSDavid Dillow wave_base + SIS_WAVE_CHANNEL_CONTROL); 560175859bfSDavid Dillow 561175859bfSDavid Dillow /* Force PCI writes to post. */ 562175859bfSDavid Dillow readl(ctrl_base); 563175859bfSDavid Dillow 564175859bfSDavid Dillow return 0; 565175859bfSDavid Dillow } 566175859bfSDavid Dillow 567175859bfSDavid Dillow static int sis_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 568175859bfSDavid Dillow { 569175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 570175859bfSDavid Dillow unsigned long io = sis->ioport; 571175859bfSDavid Dillow struct snd_pcm_substream *s; 572175859bfSDavid Dillow struct voice *voice; 573175859bfSDavid Dillow void *chip; 574175859bfSDavid Dillow int starting; 575175859bfSDavid Dillow u32 record = 0; 576175859bfSDavid Dillow u32 play[2] = { 0, 0 }; 577175859bfSDavid Dillow 578175859bfSDavid Dillow /* No locks needed, as the PCM core will hold the locks on the 579175859bfSDavid Dillow * substreams, and the HW will only start/stop the indicated voices 580175859bfSDavid Dillow * without changing the state of the others. 581175859bfSDavid Dillow */ 582175859bfSDavid Dillow switch (cmd) { 583175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_START: 584175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 585175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_RESUME: 586175859bfSDavid Dillow starting = 1; 587175859bfSDavid Dillow break; 588175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_STOP: 589175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 590175859bfSDavid Dillow case SNDRV_PCM_TRIGGER_SUSPEND: 591175859bfSDavid Dillow starting = 0; 592175859bfSDavid Dillow break; 593175859bfSDavid Dillow default: 594175859bfSDavid Dillow return -EINVAL; 595175859bfSDavid Dillow } 596175859bfSDavid Dillow 597175859bfSDavid Dillow snd_pcm_group_for_each_entry(s, substream) { 598175859bfSDavid Dillow /* Make sure it is for us... */ 599175859bfSDavid Dillow chip = snd_pcm_substream_chip(s); 600175859bfSDavid Dillow if (chip != sis) 601175859bfSDavid Dillow continue; 602175859bfSDavid Dillow 603175859bfSDavid Dillow voice = s->runtime->private_data; 604175859bfSDavid Dillow if (voice->flags & VOICE_CAPTURE) { 605175859bfSDavid Dillow record |= 1 << voice->num; 606175859bfSDavid Dillow voice = voice->timing; 607175859bfSDavid Dillow } 608175859bfSDavid Dillow 609175859bfSDavid Dillow /* voice could be NULL if this a recording stream, and it 610175859bfSDavid Dillow * doesn't have an external timing channel. 611175859bfSDavid Dillow */ 612175859bfSDavid Dillow if (voice) 613175859bfSDavid Dillow play[voice->num / 32] |= 1 << (voice->num & 0x1f); 614175859bfSDavid Dillow 615175859bfSDavid Dillow snd_pcm_trigger_done(s, substream); 616175859bfSDavid Dillow } 617175859bfSDavid Dillow 618175859bfSDavid Dillow if (starting) { 619175859bfSDavid Dillow if (record) 620175859bfSDavid Dillow outl(record, io + SIS_RECORD_START_REG); 621175859bfSDavid Dillow if (play[0]) 622175859bfSDavid Dillow outl(play[0], io + SIS_PLAY_START_A_REG); 623175859bfSDavid Dillow if (play[1]) 624175859bfSDavid Dillow outl(play[1], io + SIS_PLAY_START_B_REG); 625175859bfSDavid Dillow } else { 626175859bfSDavid Dillow if (record) 627175859bfSDavid Dillow outl(record, io + SIS_RECORD_STOP_REG); 628175859bfSDavid Dillow if (play[0]) 629175859bfSDavid Dillow outl(play[0], io + SIS_PLAY_STOP_A_REG); 630175859bfSDavid Dillow if (play[1]) 631175859bfSDavid Dillow outl(play[1], io + SIS_PLAY_STOP_B_REG); 632175859bfSDavid Dillow } 633175859bfSDavid Dillow return 0; 634175859bfSDavid Dillow } 635175859bfSDavid Dillow 636175859bfSDavid Dillow static snd_pcm_uframes_t sis_pcm_pointer(struct snd_pcm_substream *substream) 637175859bfSDavid Dillow { 638175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 639175859bfSDavid Dillow struct voice *voice = runtime->private_data; 640175859bfSDavid Dillow u32 cso; 641175859bfSDavid Dillow 642175859bfSDavid Dillow cso = readl(voice->ctrl_base + SIS_PLAY_DMA_FORMAT_CSO); 643175859bfSDavid Dillow cso &= 0xffff; 644175859bfSDavid Dillow return cso; 645175859bfSDavid Dillow } 646175859bfSDavid Dillow 647175859bfSDavid Dillow static int sis_capture_open(struct snd_pcm_substream *substream) 648175859bfSDavid Dillow { 649175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 650175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 651175859bfSDavid Dillow struct voice *voice = &sis->capture_voice; 652175859bfSDavid Dillow unsigned long flags; 653175859bfSDavid Dillow 654175859bfSDavid Dillow /* FIXME: The driver only supports recording from one channel 655175859bfSDavid Dillow * at the moment, but it could support more. 656175859bfSDavid Dillow */ 657175859bfSDavid Dillow spin_lock_irqsave(&sis->voice_lock, flags); 658175859bfSDavid Dillow if (voice->flags & VOICE_IN_USE) 659175859bfSDavid Dillow voice = NULL; 660175859bfSDavid Dillow else 661175859bfSDavid Dillow voice->flags |= VOICE_IN_USE; 662175859bfSDavid Dillow spin_unlock_irqrestore(&sis->voice_lock, flags); 663175859bfSDavid Dillow 664175859bfSDavid Dillow if (!voice) 665175859bfSDavid Dillow return -EAGAIN; 666175859bfSDavid Dillow 667175859bfSDavid Dillow voice->substream = substream; 668175859bfSDavid Dillow runtime->private_data = voice; 669175859bfSDavid Dillow runtime->hw = sis_capture_hw_info; 670175859bfSDavid Dillow runtime->hw.rates = sis->ac97[0]->rates[AC97_RATES_ADC]; 671175859bfSDavid Dillow snd_pcm_limit_hw_rates(runtime); 672175859bfSDavid Dillow snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 673175859bfSDavid Dillow 9, 0xfff9); 674175859bfSDavid Dillow snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 675175859bfSDavid Dillow 9, 0xfff9); 676175859bfSDavid Dillow snd_pcm_set_sync(substream); 677175859bfSDavid Dillow return 0; 678175859bfSDavid Dillow } 679175859bfSDavid Dillow 680175859bfSDavid Dillow static int sis_capture_hw_params(struct snd_pcm_substream *substream, 681175859bfSDavid Dillow struct snd_pcm_hw_params *hw_params) 682175859bfSDavid Dillow { 683175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 684175859bfSDavid Dillow int rc; 685175859bfSDavid Dillow 686175859bfSDavid Dillow rc = snd_ac97_set_rate(sis->ac97[0], AC97_PCM_LR_ADC_RATE, 687175859bfSDavid Dillow params_rate(hw_params)); 688175859bfSDavid Dillow if (rc) 689175859bfSDavid Dillow goto out; 690175859bfSDavid Dillow 691175859bfSDavid Dillow rc = sis_alloc_timing_voice(substream, hw_params); 692175859bfSDavid Dillow 693175859bfSDavid Dillow out: 694175859bfSDavid Dillow return rc; 695175859bfSDavid Dillow } 696175859bfSDavid Dillow 697175859bfSDavid Dillow static void sis_prepare_timing_voice(struct voice *voice, 698175859bfSDavid Dillow struct snd_pcm_substream *substream) 699175859bfSDavid Dillow { 700175859bfSDavid Dillow struct sis7019 *sis = snd_pcm_substream_chip(substream); 701175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 702175859bfSDavid Dillow struct voice *timing = voice->timing; 703175859bfSDavid Dillow void __iomem *play_base = timing->ctrl_base; 704175859bfSDavid Dillow void __iomem *wave_base = timing->wave_base; 705175859bfSDavid Dillow u16 buffer_size, period_size; 706175859bfSDavid Dillow u32 format, control, sso_eso, delta; 707175859bfSDavid Dillow u32 vperiod, sso, reg; 708175859bfSDavid Dillow 709175859bfSDavid Dillow /* Set our initial buffer and period as large as we can given a 710175859bfSDavid Dillow * single page of silence. 711175859bfSDavid Dillow */ 712175859bfSDavid Dillow buffer_size = 4096 / runtime->channels; 713175859bfSDavid Dillow buffer_size /= snd_pcm_format_size(runtime->format, 1); 714175859bfSDavid Dillow period_size = buffer_size; 715175859bfSDavid Dillow 716175859bfSDavid Dillow /* Initially, we want to interrupt just a bit behind the end of 7173a3d5fd1SDavid Dillow * the period we're clocking out. 12 samples seems to give a good 718175859bfSDavid Dillow * delay. 719175859bfSDavid Dillow * 720175859bfSDavid Dillow * We want to spread our interrupts throughout the virtual period, 721175859bfSDavid Dillow * so that we don't end up with two interrupts back to back at the 722175859bfSDavid Dillow * end -- this helps minimize the effects of any jitter. Adjust our 723175859bfSDavid Dillow * clocking period size so that the last period is at least a fourth 724175859bfSDavid Dillow * of a full period. 725175859bfSDavid Dillow * 726175859bfSDavid Dillow * This is all moot if we don't need to use virtual periods. 727175859bfSDavid Dillow */ 7283a3d5fd1SDavid Dillow vperiod = runtime->period_size + 12; 729175859bfSDavid Dillow if (vperiod > period_size) { 730175859bfSDavid Dillow u16 tail = vperiod % period_size; 731175859bfSDavid Dillow u16 quarter_period = period_size / 4; 732175859bfSDavid Dillow 733175859bfSDavid Dillow if (tail && tail < quarter_period) { 734175859bfSDavid Dillow u16 loops = vperiod / period_size; 735175859bfSDavid Dillow 736175859bfSDavid Dillow tail = quarter_period - tail; 737175859bfSDavid Dillow tail += loops - 1; 738175859bfSDavid Dillow tail /= loops; 739175859bfSDavid Dillow period_size -= tail; 740175859bfSDavid Dillow } 741175859bfSDavid Dillow 742175859bfSDavid Dillow sso = period_size - 1; 743175859bfSDavid Dillow } else { 744175859bfSDavid Dillow /* The initial period will fit inside the buffer, so we 745175859bfSDavid Dillow * don't need to use virtual periods -- disable them. 746175859bfSDavid Dillow */ 747175859bfSDavid Dillow period_size = runtime->period_size; 748175859bfSDavid Dillow sso = vperiod - 1; 749175859bfSDavid Dillow vperiod = 0; 750175859bfSDavid Dillow } 751175859bfSDavid Dillow 75225985edcSLucas De Marchi /* The interrupt handler implements the timing synchronization, so 753175859bfSDavid Dillow * setup its state. 754175859bfSDavid Dillow */ 755175859bfSDavid Dillow timing->flags |= VOICE_SYNC_TIMING; 756175859bfSDavid Dillow timing->sync_base = voice->ctrl_base; 7573a3d5fd1SDavid Dillow timing->sync_cso = runtime->period_size; 758175859bfSDavid Dillow timing->sync_period_size = runtime->period_size; 759175859bfSDavid Dillow timing->sync_buffer_size = runtime->buffer_size; 760175859bfSDavid Dillow timing->period_size = period_size; 761175859bfSDavid Dillow timing->buffer_size = buffer_size; 762175859bfSDavid Dillow timing->sso = sso; 763175859bfSDavid Dillow timing->vperiod = vperiod; 764175859bfSDavid Dillow 765175859bfSDavid Dillow /* Using unsigned samples with the all-zero silence buffer 766175859bfSDavid Dillow * forces the output to the lower rail, killing playback. 767175859bfSDavid Dillow * So ignore unsigned vs signed -- it doesn't change the timing. 768175859bfSDavid Dillow */ 769175859bfSDavid Dillow format = 0; 770175859bfSDavid Dillow if (snd_pcm_format_width(runtime->format) == 8) 771175859bfSDavid Dillow format = SIS_CAPTURE_DMA_FORMAT_8BIT; 772175859bfSDavid Dillow if (runtime->channels == 1) 773175859bfSDavid Dillow format |= SIS_CAPTURE_DMA_FORMAT_MONO; 774175859bfSDavid Dillow 775175859bfSDavid Dillow control = timing->buffer_size - 1; 776175859bfSDavid Dillow control |= SIS_PLAY_DMA_LOOP | SIS_PLAY_DMA_INTR_AT_SSO; 777175859bfSDavid Dillow sso_eso = timing->buffer_size - 1; 778175859bfSDavid Dillow sso_eso |= timing->sso << 16; 779175859bfSDavid Dillow 780175859bfSDavid Dillow delta = sis_rate_to_delta(runtime->rate); 781175859bfSDavid Dillow 782175859bfSDavid Dillow /* We've done the math, now configure the channel. 783175859bfSDavid Dillow */ 784175859bfSDavid Dillow writel(format, play_base + SIS_PLAY_DMA_FORMAT_CSO); 785175859bfSDavid Dillow writel(sis->silence_dma_addr, play_base + SIS_PLAY_DMA_BASE); 786175859bfSDavid Dillow writel(control, play_base + SIS_PLAY_DMA_CONTROL); 787175859bfSDavid Dillow writel(sso_eso, play_base + SIS_PLAY_DMA_SSO_ESO); 788175859bfSDavid Dillow 789175859bfSDavid Dillow for (reg = 0; reg < SIS_WAVE_SIZE; reg += 4) 790175859bfSDavid Dillow writel(0, wave_base + reg); 791175859bfSDavid Dillow 792175859bfSDavid Dillow writel(SIS_WAVE_GENERAL_WAVE_VOLUME, wave_base + SIS_WAVE_GENERAL); 793175859bfSDavid Dillow writel(delta << 16, wave_base + SIS_WAVE_GENERAL_ARTICULATION); 794175859bfSDavid Dillow writel(SIS_WAVE_CHANNEL_CONTROL_FIRST_SAMPLE | 795175859bfSDavid Dillow SIS_WAVE_CHANNEL_CONTROL_AMP_ENABLE | 796175859bfSDavid Dillow SIS_WAVE_CHANNEL_CONTROL_INTERPOLATE_ENABLE, 797175859bfSDavid Dillow wave_base + SIS_WAVE_CHANNEL_CONTROL); 798175859bfSDavid Dillow } 799175859bfSDavid Dillow 800175859bfSDavid Dillow static int sis_pcm_capture_prepare(struct snd_pcm_substream *substream) 801175859bfSDavid Dillow { 802175859bfSDavid Dillow struct snd_pcm_runtime *runtime = substream->runtime; 803175859bfSDavid Dillow struct voice *voice = runtime->private_data; 804175859bfSDavid Dillow void __iomem *rec_base = voice->ctrl_base; 805175859bfSDavid Dillow u32 format, dma_addr, control; 806175859bfSDavid Dillow u16 leo; 807175859bfSDavid Dillow 808175859bfSDavid Dillow /* We rely on the PCM core to ensure that the parameters for this 809175859bfSDavid Dillow * substream do not change on us while we're programming the HW. 810175859bfSDavid Dillow */ 811175859bfSDavid Dillow format = 0; 812175859bfSDavid Dillow if (snd_pcm_format_width(runtime->format) == 8) 813175859bfSDavid Dillow format = SIS_CAPTURE_DMA_FORMAT_8BIT; 814175859bfSDavid Dillow if (!snd_pcm_format_signed(runtime->format)) 815175859bfSDavid Dillow format |= SIS_CAPTURE_DMA_FORMAT_UNSIGNED; 816175859bfSDavid Dillow if (runtime->channels == 1) 817175859bfSDavid Dillow format |= SIS_CAPTURE_DMA_FORMAT_MONO; 818175859bfSDavid Dillow 819175859bfSDavid Dillow dma_addr = runtime->dma_addr; 820175859bfSDavid Dillow leo = runtime->buffer_size - 1; 821175859bfSDavid Dillow control = leo | SIS_CAPTURE_DMA_LOOP; 822175859bfSDavid Dillow 823175859bfSDavid Dillow /* If we've got more than two periods per buffer, then we have 824175859bfSDavid Dillow * use a timing voice to clock out the periods. Otherwise, we can 825175859bfSDavid Dillow * use the capture channel's interrupts. 826175859bfSDavid Dillow */ 827175859bfSDavid Dillow if (voice->timing) { 828175859bfSDavid Dillow sis_prepare_timing_voice(voice, substream); 829175859bfSDavid Dillow } else { 830175859bfSDavid Dillow control |= SIS_CAPTURE_DMA_INTR_AT_LEO; 831175859bfSDavid Dillow if (runtime->period_size != runtime->buffer_size) 832175859bfSDavid Dillow control |= SIS_CAPTURE_DMA_INTR_AT_MLP; 833175859bfSDavid Dillow } 834175859bfSDavid Dillow 835175859bfSDavid Dillow writel(format, rec_base + SIS_CAPTURE_DMA_FORMAT_CSO); 836175859bfSDavid Dillow writel(dma_addr, rec_base + SIS_CAPTURE_DMA_BASE); 837175859bfSDavid Dillow writel(control, rec_base + SIS_CAPTURE_DMA_CONTROL); 838175859bfSDavid Dillow 839175859bfSDavid Dillow /* Force the writes to post. */ 840175859bfSDavid Dillow readl(rec_base); 841175859bfSDavid Dillow 842175859bfSDavid Dillow return 0; 843175859bfSDavid Dillow } 844175859bfSDavid Dillow 8452aa0eae9SArvind Yadav static const struct snd_pcm_ops sis_playback_ops = { 846175859bfSDavid Dillow .open = sis_playback_open, 847175859bfSDavid Dillow .close = sis_substream_close, 848175859bfSDavid Dillow .prepare = sis_pcm_playback_prepare, 849175859bfSDavid Dillow .trigger = sis_pcm_trigger, 850175859bfSDavid Dillow .pointer = sis_pcm_pointer, 851175859bfSDavid Dillow }; 852175859bfSDavid Dillow 8532aa0eae9SArvind Yadav static const struct snd_pcm_ops sis_capture_ops = { 854175859bfSDavid Dillow .open = sis_capture_open, 855175859bfSDavid Dillow .close = sis_substream_close, 856175859bfSDavid Dillow .hw_params = sis_capture_hw_params, 857175859bfSDavid Dillow .prepare = sis_pcm_capture_prepare, 858175859bfSDavid Dillow .trigger = sis_pcm_trigger, 859175859bfSDavid Dillow .pointer = sis_pcm_pointer, 860175859bfSDavid Dillow }; 861175859bfSDavid Dillow 862e23e7a14SBill Pemberton static int sis_pcm_create(struct sis7019 *sis) 863175859bfSDavid Dillow { 864175859bfSDavid Dillow struct snd_pcm *pcm; 865175859bfSDavid Dillow int rc; 866175859bfSDavid Dillow 867175859bfSDavid Dillow /* We have 64 voices, and the driver currently records from 868175859bfSDavid Dillow * only one channel, though that could change in the future. 869175859bfSDavid Dillow */ 870175859bfSDavid Dillow rc = snd_pcm_new(sis->card, "SiS7019", 0, 64, 1, &pcm); 871175859bfSDavid Dillow if (rc) 872175859bfSDavid Dillow return rc; 873175859bfSDavid Dillow 874175859bfSDavid Dillow pcm->private_data = sis; 875175859bfSDavid Dillow strcpy(pcm->name, "SiS7019"); 876175859bfSDavid Dillow sis->pcm = pcm; 877175859bfSDavid Dillow 878175859bfSDavid Dillow snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &sis_playback_ops); 879175859bfSDavid Dillow snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &sis_capture_ops); 880175859bfSDavid Dillow 881175859bfSDavid Dillow /* Try to preallocate some memory, but it's not the end of the 882175859bfSDavid Dillow * world if this fails. 883175859bfSDavid Dillow */ 884ff3eb3d5STakashi Iwai snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, 885ff3eb3d5STakashi Iwai &sis->pci->dev, 64*1024, 128*1024); 886175859bfSDavid Dillow 887175859bfSDavid Dillow return 0; 888175859bfSDavid Dillow } 889175859bfSDavid Dillow 890175859bfSDavid Dillow static unsigned short sis_ac97_rw(struct sis7019 *sis, int codec, u32 cmd) 891175859bfSDavid Dillow { 892175859bfSDavid Dillow unsigned long io = sis->ioport; 893175859bfSDavid Dillow unsigned short val = 0xffff; 894175859bfSDavid Dillow u16 status; 895175859bfSDavid Dillow u16 rdy; 896175859bfSDavid Dillow int count; 8973f76d984STobias Klauser static const u16 codec_ready[3] = { 898175859bfSDavid Dillow SIS_AC97_STATUS_CODEC_READY, 899175859bfSDavid Dillow SIS_AC97_STATUS_CODEC2_READY, 900175859bfSDavid Dillow SIS_AC97_STATUS_CODEC3_READY, 901175859bfSDavid Dillow }; 902175859bfSDavid Dillow 903175859bfSDavid Dillow rdy = codec_ready[codec]; 904175859bfSDavid Dillow 905175859bfSDavid Dillow 906175859bfSDavid Dillow /* Get the AC97 semaphore -- software first, so we don't spin 907175859bfSDavid Dillow * pounding out IO reads on the hardware semaphore... 908175859bfSDavid Dillow */ 909175859bfSDavid Dillow mutex_lock(&sis->ac97_mutex); 910175859bfSDavid Dillow 911175859bfSDavid Dillow count = 0xffff; 912175859bfSDavid Dillow while ((inw(io + SIS_AC97_SEMA) & SIS_AC97_SEMA_BUSY) && --count) 913175859bfSDavid Dillow udelay(1); 914175859bfSDavid Dillow 915175859bfSDavid Dillow if (!count) 916175859bfSDavid Dillow goto timeout; 917175859bfSDavid Dillow 918175859bfSDavid Dillow /* ... and wait for any outstanding commands to complete ... 919175859bfSDavid Dillow */ 920175859bfSDavid Dillow count = 0xffff; 921175859bfSDavid Dillow do { 922175859bfSDavid Dillow status = inw(io + SIS_AC97_STATUS); 923175859bfSDavid Dillow if ((status & rdy) && !(status & SIS_AC97_STATUS_BUSY)) 924175859bfSDavid Dillow break; 925175859bfSDavid Dillow 926175859bfSDavid Dillow udelay(1); 927175859bfSDavid Dillow } while (--count); 928175859bfSDavid Dillow 929175859bfSDavid Dillow if (!count) 930175859bfSDavid Dillow goto timeout_sema; 931175859bfSDavid Dillow 932175859bfSDavid Dillow /* ... before sending our command and waiting for it to finish ... 933175859bfSDavid Dillow */ 934175859bfSDavid Dillow outl(cmd, io + SIS_AC97_CMD); 935175859bfSDavid Dillow udelay(10); 936175859bfSDavid Dillow 937175859bfSDavid Dillow count = 0xffff; 938175859bfSDavid Dillow while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count) 939175859bfSDavid Dillow udelay(1); 940175859bfSDavid Dillow 941175859bfSDavid Dillow /* ... and reading the results (if any). 942175859bfSDavid Dillow */ 943175859bfSDavid Dillow val = inl(io + SIS_AC97_CMD) >> 16; 944175859bfSDavid Dillow 945175859bfSDavid Dillow timeout_sema: 946175859bfSDavid Dillow outl(SIS_AC97_SEMA_RELEASE, io + SIS_AC97_SEMA); 947175859bfSDavid Dillow timeout: 948175859bfSDavid Dillow mutex_unlock(&sis->ac97_mutex); 949175859bfSDavid Dillow 950175859bfSDavid Dillow if (!count) { 95170597851SDavid Dillow dev_err(&sis->pci->dev, "ac97 codec %d timeout cmd 0x%08x\n", 952175859bfSDavid Dillow codec, cmd); 953175859bfSDavid Dillow } 954175859bfSDavid Dillow 955175859bfSDavid Dillow return val; 956175859bfSDavid Dillow } 957175859bfSDavid Dillow 958175859bfSDavid Dillow static void sis_ac97_write(struct snd_ac97 *ac97, unsigned short reg, 959175859bfSDavid Dillow unsigned short val) 960175859bfSDavid Dillow { 9613f76d984STobias Klauser static const u32 cmd[3] = { 962175859bfSDavid Dillow SIS_AC97_CMD_CODEC_WRITE, 963175859bfSDavid Dillow SIS_AC97_CMD_CODEC2_WRITE, 964175859bfSDavid Dillow SIS_AC97_CMD_CODEC3_WRITE, 965175859bfSDavid Dillow }; 966175859bfSDavid Dillow sis_ac97_rw(ac97->private_data, ac97->num, 967175859bfSDavid Dillow (val << 16) | (reg << 8) | cmd[ac97->num]); 968175859bfSDavid Dillow } 969175859bfSDavid Dillow 970175859bfSDavid Dillow static unsigned short sis_ac97_read(struct snd_ac97 *ac97, unsigned short reg) 971175859bfSDavid Dillow { 9723f76d984STobias Klauser static const u32 cmd[3] = { 973175859bfSDavid Dillow SIS_AC97_CMD_CODEC_READ, 974175859bfSDavid Dillow SIS_AC97_CMD_CODEC2_READ, 975175859bfSDavid Dillow SIS_AC97_CMD_CODEC3_READ, 976175859bfSDavid Dillow }; 977175859bfSDavid Dillow return sis_ac97_rw(ac97->private_data, ac97->num, 978175859bfSDavid Dillow (reg << 8) | cmd[ac97->num]); 979175859bfSDavid Dillow } 980175859bfSDavid Dillow 981e23e7a14SBill Pemberton static int sis_mixer_create(struct sis7019 *sis) 982175859bfSDavid Dillow { 983175859bfSDavid Dillow struct snd_ac97_bus *bus; 984175859bfSDavid Dillow struct snd_ac97_template ac97; 98551055da5STakashi Iwai static const struct snd_ac97_bus_ops ops = { 986175859bfSDavid Dillow .write = sis_ac97_write, 987175859bfSDavid Dillow .read = sis_ac97_read, 988175859bfSDavid Dillow }; 989175859bfSDavid Dillow int rc; 990175859bfSDavid Dillow 991175859bfSDavid Dillow memset(&ac97, 0, sizeof(ac97)); 992175859bfSDavid Dillow ac97.private_data = sis; 993175859bfSDavid Dillow 994175859bfSDavid Dillow rc = snd_ac97_bus(sis->card, 0, &ops, NULL, &bus); 995175859bfSDavid Dillow if (!rc && sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT) 996175859bfSDavid Dillow rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[0]); 997175859bfSDavid Dillow ac97.num = 1; 998175859bfSDavid Dillow if (!rc && (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT)) 999175859bfSDavid Dillow rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[1]); 1000175859bfSDavid Dillow ac97.num = 2; 1001175859bfSDavid Dillow if (!rc && (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT)) 1002175859bfSDavid Dillow rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[2]); 1003175859bfSDavid Dillow 1004175859bfSDavid Dillow /* If we return an error here, then snd_card_free() should 1005175859bfSDavid Dillow * free up any ac97 codecs that got created, as well as the bus. 1006175859bfSDavid Dillow */ 1007175859bfSDavid Dillow return rc; 1008175859bfSDavid Dillow } 1009175859bfSDavid Dillow 1010*499ddc16STakashi Iwai static void sis_chip_free(struct snd_card *card) 1011175859bfSDavid Dillow { 1012*499ddc16STakashi Iwai struct sis7019 *sis = card->private_data; 1013175859bfSDavid Dillow 1014175859bfSDavid Dillow /* Reset the chip, and disable all interrputs. 1015175859bfSDavid Dillow */ 1016175859bfSDavid Dillow outl(SIS_GCR_SOFTWARE_RESET, sis->ioport + SIS_GCR); 101708b45098SDavid Dillow udelay(25); 1018175859bfSDavid Dillow outl(0, sis->ioport + SIS_GCR); 1019175859bfSDavid Dillow outl(0, sis->ioport + SIS_GIER); 1020175859bfSDavid Dillow 1021175859bfSDavid Dillow /* Now, free everything we allocated. 1022175859bfSDavid Dillow */ 1023175859bfSDavid Dillow if (sis->irq >= 0) 1024175859bfSDavid Dillow free_irq(sis->irq, sis); 1025175859bfSDavid Dillow } 1026175859bfSDavid Dillow 1027175859bfSDavid Dillow static int sis_chip_init(struct sis7019 *sis) 1028175859bfSDavid Dillow { 1029175859bfSDavid Dillow unsigned long io = sis->ioport; 1030175859bfSDavid Dillow void __iomem *ioaddr = sis->ioaddr; 1031fc084e0bSDavid Dillow unsigned long timeout; 1032175859bfSDavid Dillow u16 status; 1033175859bfSDavid Dillow int count; 1034175859bfSDavid Dillow int i; 1035175859bfSDavid Dillow 1036175859bfSDavid Dillow /* Reset the audio controller 1037175859bfSDavid Dillow */ 1038175859bfSDavid Dillow outl(SIS_GCR_SOFTWARE_RESET, io + SIS_GCR); 103908b45098SDavid Dillow udelay(25); 1040175859bfSDavid Dillow outl(0, io + SIS_GCR); 1041175859bfSDavid Dillow 1042175859bfSDavid Dillow /* Get the AC-link semaphore, and reset the codecs 1043175859bfSDavid Dillow */ 1044175859bfSDavid Dillow count = 0xffff; 1045175859bfSDavid Dillow while ((inw(io + SIS_AC97_SEMA) & SIS_AC97_SEMA_BUSY) && --count) 1046175859bfSDavid Dillow udelay(1); 1047175859bfSDavid Dillow 1048175859bfSDavid Dillow if (!count) 1049175859bfSDavid Dillow return -EIO; 1050175859bfSDavid Dillow 1051175859bfSDavid Dillow outl(SIS_AC97_CMD_CODEC_COLD_RESET, io + SIS_AC97_CMD); 105208b45098SDavid Dillow udelay(250); 1053175859bfSDavid Dillow 1054175859bfSDavid Dillow count = 0xffff; 1055175859bfSDavid Dillow while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count) 1056175859bfSDavid Dillow udelay(1); 1057175859bfSDavid Dillow 1058fc084e0bSDavid Dillow /* Command complete, we can let go of the semaphore now. 1059175859bfSDavid Dillow */ 1060fc084e0bSDavid Dillow outl(SIS_AC97_SEMA_RELEASE, io + SIS_AC97_SEMA); 1061fc084e0bSDavid Dillow if (!count) 1062fc084e0bSDavid Dillow return -EIO; 1063fc084e0bSDavid Dillow 1064fc084e0bSDavid Dillow /* Now that we've finished the reset, find out what's attached. 1065fc084e0bSDavid Dillow * There are some codec/board combinations that take an extremely 1066fc084e0bSDavid Dillow * long time to come up. 350+ ms has been observed in the field, 1067fc084e0bSDavid Dillow * so we'll give them up to 500ms. 1068fc084e0bSDavid Dillow */ 1069fc084e0bSDavid Dillow sis->codecs_present = 0; 1070fc084e0bSDavid Dillow timeout = msecs_to_jiffies(500) + jiffies; 1071fc084e0bSDavid Dillow while (time_before_eq(jiffies, timeout)) { 1072175859bfSDavid Dillow status = inl(io + SIS_AC97_STATUS); 1073175859bfSDavid Dillow if (status & SIS_AC97_STATUS_CODEC_READY) 1074175859bfSDavid Dillow sis->codecs_present |= SIS_PRIMARY_CODEC_PRESENT; 1075175859bfSDavid Dillow if (status & SIS_AC97_STATUS_CODEC2_READY) 1076175859bfSDavid Dillow sis->codecs_present |= SIS_SECONDARY_CODEC_PRESENT; 1077175859bfSDavid Dillow if (status & SIS_AC97_STATUS_CODEC3_READY) 1078175859bfSDavid Dillow sis->codecs_present |= SIS_TERTIARY_CODEC_PRESENT; 1079175859bfSDavid Dillow 1080fc084e0bSDavid Dillow if (sis->codecs_present == codecs) 1081fc084e0bSDavid Dillow break; 1082fc084e0bSDavid Dillow 1083fc084e0bSDavid Dillow msleep(1); 1084fc084e0bSDavid Dillow } 1085fc084e0bSDavid Dillow 1086fc084e0bSDavid Dillow /* All done, check for errors. 1087175859bfSDavid Dillow */ 1088fc084e0bSDavid Dillow if (!sis->codecs_present) { 108970597851SDavid Dillow dev_err(&sis->pci->dev, "could not find any codecs\n"); 1090175859bfSDavid Dillow return -EIO; 1091fc084e0bSDavid Dillow } 1092fc084e0bSDavid Dillow 1093fc084e0bSDavid Dillow if (sis->codecs_present != codecs) { 109470597851SDavid Dillow dev_warn(&sis->pci->dev, "missing codecs, found %0x, expected %0x\n", 1095fc084e0bSDavid Dillow sis->codecs_present, codecs); 1096fc084e0bSDavid Dillow } 1097175859bfSDavid Dillow 1098175859bfSDavid Dillow /* Let the hardware know that the audio driver is alive, 1099175859bfSDavid Dillow * and enable PCM slots on the AC-link for L/R playback (3 & 4) and 1100175859bfSDavid Dillow * record channels. We're going to want to use Variable Rate Audio 1101175859bfSDavid Dillow * for recording, to avoid needlessly resampling from 48kHZ. 1102175859bfSDavid Dillow */ 1103175859bfSDavid Dillow outl(SIS_AC97_CONF_AUDIO_ALIVE, io + SIS_AC97_CONF); 1104175859bfSDavid Dillow outl(SIS_AC97_CONF_AUDIO_ALIVE | SIS_AC97_CONF_PCM_LR_ENABLE | 1105175859bfSDavid Dillow SIS_AC97_CONF_PCM_CAP_MIC_ENABLE | 1106175859bfSDavid Dillow SIS_AC97_CONF_PCM_CAP_LR_ENABLE | 1107175859bfSDavid Dillow SIS_AC97_CONF_CODEC_VRA_ENABLE, io + SIS_AC97_CONF); 1108175859bfSDavid Dillow 1109175859bfSDavid Dillow /* All AC97 PCM slots should be sourced from sub-mixer 0. 1110175859bfSDavid Dillow */ 1111175859bfSDavid Dillow outl(0, io + SIS_AC97_PSR); 1112175859bfSDavid Dillow 1113175859bfSDavid Dillow /* There is only one valid DMA setup for a PCI environment. 1114175859bfSDavid Dillow */ 1115175859bfSDavid Dillow outl(SIS_DMA_CSR_PCI_SETTINGS, io + SIS_DMA_CSR); 1116175859bfSDavid Dillow 111725985edcSLucas De Marchi /* Reset the synchronization groups for all of the channels 1118b3834be5SAdam Buchbinder * to be asynchronous. If we start doing SPDIF or 5.1 sound, etc. 1119175859bfSDavid Dillow * we'll need to change how we handle these. Until then, we just 1120175859bfSDavid Dillow * assign sub-mixer 0 to all playback channels, and avoid any 1121175859bfSDavid Dillow * attenuation on the audio. 1122175859bfSDavid Dillow */ 1123175859bfSDavid Dillow outl(0, io + SIS_PLAY_SYNC_GROUP_A); 1124175859bfSDavid Dillow outl(0, io + SIS_PLAY_SYNC_GROUP_B); 1125175859bfSDavid Dillow outl(0, io + SIS_PLAY_SYNC_GROUP_C); 1126175859bfSDavid Dillow outl(0, io + SIS_PLAY_SYNC_GROUP_D); 1127175859bfSDavid Dillow outl(0, io + SIS_MIXER_SYNC_GROUP); 1128175859bfSDavid Dillow 1129175859bfSDavid Dillow for (i = 0; i < 64; i++) { 1130175859bfSDavid Dillow writel(i, SIS_MIXER_START_ADDR(ioaddr, i)); 1131175859bfSDavid Dillow writel(SIS_MIXER_RIGHT_NO_ATTEN | SIS_MIXER_LEFT_NO_ATTEN | 1132175859bfSDavid Dillow SIS_MIXER_DEST_0, SIS_MIXER_ADDR(ioaddr, i)); 1133175859bfSDavid Dillow } 1134175859bfSDavid Dillow 1135175859bfSDavid Dillow /* Don't attenuate any audio set for the wave amplifier. 1136175859bfSDavid Dillow * 1137175859bfSDavid Dillow * FIXME: Maximum attenuation is set for the music amp, which will 1138175859bfSDavid Dillow * need to change if we start using the synth engine. 1139175859bfSDavid Dillow */ 1140175859bfSDavid Dillow outl(0xffff0000, io + SIS_WEVCR); 1141175859bfSDavid Dillow 1142175859bfSDavid Dillow /* Ensure that the wave engine is in normal operating mode. 1143175859bfSDavid Dillow */ 1144175859bfSDavid Dillow outl(0, io + SIS_WECCR); 1145175859bfSDavid Dillow 1146175859bfSDavid Dillow /* Go ahead and enable the DMA interrupts. They won't go live 1147175859bfSDavid Dillow * until we start a channel. 1148175859bfSDavid Dillow */ 1149175859bfSDavid Dillow outl(SIS_GIER_AUDIO_PLAY_DMA_IRQ_ENABLE | 1150175859bfSDavid Dillow SIS_GIER_AUDIO_RECORD_DMA_IRQ_ENABLE, io + SIS_GIER); 1151175859bfSDavid Dillow 1152175859bfSDavid Dillow return 0; 1153175859bfSDavid Dillow } 1154175859bfSDavid Dillow 1155c7561cd8STakashi Iwai #ifdef CONFIG_PM_SLEEP 115668cb2b55STakashi Iwai static int sis_suspend(struct device *dev) 1157175859bfSDavid Dillow { 115868cb2b55STakashi Iwai struct snd_card *card = dev_get_drvdata(dev); 1159175859bfSDavid Dillow struct sis7019 *sis = card->private_data; 1160175859bfSDavid Dillow void __iomem *ioaddr = sis->ioaddr; 1161175859bfSDavid Dillow int i; 1162175859bfSDavid Dillow 1163175859bfSDavid Dillow snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 1164175859bfSDavid Dillow if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT) 1165175859bfSDavid Dillow snd_ac97_suspend(sis->ac97[0]); 1166175859bfSDavid Dillow if (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT) 1167175859bfSDavid Dillow snd_ac97_suspend(sis->ac97[1]); 1168175859bfSDavid Dillow if (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT) 1169175859bfSDavid Dillow snd_ac97_suspend(sis->ac97[2]); 1170175859bfSDavid Dillow 1171175859bfSDavid Dillow /* snd_pcm_suspend_all() stopped all channels, so we're quiescent. 1172175859bfSDavid Dillow */ 1173175859bfSDavid Dillow if (sis->irq >= 0) { 1174175859bfSDavid Dillow free_irq(sis->irq, sis); 1175175859bfSDavid Dillow sis->irq = -1; 1176175859bfSDavid Dillow } 1177175859bfSDavid Dillow 1178175859bfSDavid Dillow /* Save the internal state away 1179175859bfSDavid Dillow */ 1180175859bfSDavid Dillow for (i = 0; i < 4; i++) { 1181175859bfSDavid Dillow memcpy_fromio(sis->suspend_state[i], ioaddr, 4096); 1182175859bfSDavid Dillow ioaddr += 4096; 1183175859bfSDavid Dillow } 1184175859bfSDavid Dillow 1185175859bfSDavid Dillow return 0; 1186175859bfSDavid Dillow } 1187175859bfSDavid Dillow 118868cb2b55STakashi Iwai static int sis_resume(struct device *dev) 1189175859bfSDavid Dillow { 119068cb2b55STakashi Iwai struct pci_dev *pci = to_pci_dev(dev); 119168cb2b55STakashi Iwai struct snd_card *card = dev_get_drvdata(dev); 1192175859bfSDavid Dillow struct sis7019 *sis = card->private_data; 1193175859bfSDavid Dillow void __iomem *ioaddr = sis->ioaddr; 1194175859bfSDavid Dillow int i; 1195175859bfSDavid Dillow 1196175859bfSDavid Dillow if (sis_chip_init(sis)) { 119770597851SDavid Dillow dev_err(&pci->dev, "unable to re-init controller\n"); 1198175859bfSDavid Dillow goto error; 1199175859bfSDavid Dillow } 1200175859bfSDavid Dillow 120188e24c3aSYong Zhang if (request_irq(pci->irq, sis_interrupt, IRQF_SHARED, 1202934c2b6dSTakashi Iwai KBUILD_MODNAME, sis)) { 120370597851SDavid Dillow dev_err(&pci->dev, "unable to regain IRQ %d\n", pci->irq); 1204175859bfSDavid Dillow goto error; 1205175859bfSDavid Dillow } 1206175859bfSDavid Dillow 1207175859bfSDavid Dillow /* Restore saved state, then clear out the page we use for the 1208175859bfSDavid Dillow * silence buffer. 1209175859bfSDavid Dillow */ 1210175859bfSDavid Dillow for (i = 0; i < 4; i++) { 1211175859bfSDavid Dillow memcpy_toio(ioaddr, sis->suspend_state[i], 4096); 1212175859bfSDavid Dillow ioaddr += 4096; 1213175859bfSDavid Dillow } 1214175859bfSDavid Dillow 1215175859bfSDavid Dillow memset(sis->suspend_state[0], 0, 4096); 1216175859bfSDavid Dillow 1217175859bfSDavid Dillow sis->irq = pci->irq; 1218175859bfSDavid Dillow 1219175859bfSDavid Dillow if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT) 1220175859bfSDavid Dillow snd_ac97_resume(sis->ac97[0]); 1221175859bfSDavid Dillow if (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT) 1222175859bfSDavid Dillow snd_ac97_resume(sis->ac97[1]); 1223175859bfSDavid Dillow if (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT) 1224175859bfSDavid Dillow snd_ac97_resume(sis->ac97[2]); 1225175859bfSDavid Dillow 1226175859bfSDavid Dillow snd_power_change_state(card, SNDRV_CTL_POWER_D0); 1227175859bfSDavid Dillow return 0; 1228175859bfSDavid Dillow 1229175859bfSDavid Dillow error: 1230175859bfSDavid Dillow snd_card_disconnect(card); 1231175859bfSDavid Dillow return -EIO; 1232175859bfSDavid Dillow } 123368cb2b55STakashi Iwai 123468cb2b55STakashi Iwai static SIMPLE_DEV_PM_OPS(sis_pm, sis_suspend, sis_resume); 123568cb2b55STakashi Iwai #define SIS_PM_OPS &sis_pm 123668cb2b55STakashi Iwai #else 123768cb2b55STakashi Iwai #define SIS_PM_OPS NULL 1238c7561cd8STakashi Iwai #endif /* CONFIG_PM_SLEEP */ 1239175859bfSDavid Dillow 1240175859bfSDavid Dillow static int sis_alloc_suspend(struct sis7019 *sis) 1241175859bfSDavid Dillow { 1242175859bfSDavid Dillow int i; 1243175859bfSDavid Dillow 1244175859bfSDavid Dillow /* We need 16K to store the internal wave engine state during a 1245175859bfSDavid Dillow * suspend, but we don't need it to be contiguous, so play nice 1246175859bfSDavid Dillow * with the memory system. We'll also use this area for a silence 1247175859bfSDavid Dillow * buffer. 1248175859bfSDavid Dillow */ 1249175859bfSDavid Dillow for (i = 0; i < SIS_SUSPEND_PAGES; i++) { 1250*499ddc16STakashi Iwai sis->suspend_state[i] = devm_kmalloc(&sis->pci->dev, 4096, 1251*499ddc16STakashi Iwai GFP_KERNEL); 1252175859bfSDavid Dillow if (!sis->suspend_state[i]) 1253175859bfSDavid Dillow return -ENOMEM; 1254175859bfSDavid Dillow } 1255175859bfSDavid Dillow memset(sis->suspend_state[0], 0, 4096); 1256175859bfSDavid Dillow 1257175859bfSDavid Dillow return 0; 1258175859bfSDavid Dillow } 1259175859bfSDavid Dillow 1260e23e7a14SBill Pemberton static int sis_chip_create(struct snd_card *card, 1261175859bfSDavid Dillow struct pci_dev *pci) 1262175859bfSDavid Dillow { 1263175859bfSDavid Dillow struct sis7019 *sis = card->private_data; 1264175859bfSDavid Dillow struct voice *voice; 1265175859bfSDavid Dillow int rc; 1266175859bfSDavid Dillow int i; 1267175859bfSDavid Dillow 1268*499ddc16STakashi Iwai rc = pcim_enable_device(pci); 1269175859bfSDavid Dillow if (rc) 1270*499ddc16STakashi Iwai return rc; 1271175859bfSDavid Dillow 1272412b979cSQuentin Lambert rc = dma_set_mask(&pci->dev, DMA_BIT_MASK(30)); 12738b1dacb6SWei Yongjun if (rc < 0) { 127470597851SDavid Dillow dev_err(&pci->dev, "architecture does not support 30-bit PCI busmaster DMA"); 1275*499ddc16STakashi Iwai return -ENXIO; 1276175859bfSDavid Dillow } 1277175859bfSDavid Dillow 1278175859bfSDavid Dillow mutex_init(&sis->ac97_mutex); 1279175859bfSDavid Dillow spin_lock_init(&sis->voice_lock); 1280175859bfSDavid Dillow sis->card = card; 1281175859bfSDavid Dillow sis->pci = pci; 1282175859bfSDavid Dillow sis->irq = -1; 1283175859bfSDavid Dillow sis->ioport = pci_resource_start(pci, 0); 1284175859bfSDavid Dillow 1285175859bfSDavid Dillow rc = pci_request_regions(pci, "SiS7019"); 1286175859bfSDavid Dillow if (rc) { 128770597851SDavid Dillow dev_err(&pci->dev, "unable request regions\n"); 1288*499ddc16STakashi Iwai return rc; 1289175859bfSDavid Dillow } 1290175859bfSDavid Dillow 1291*499ddc16STakashi Iwai sis->ioaddr = devm_ioremap(&pci->dev, pci_resource_start(pci, 1), 0x4000); 1292175859bfSDavid Dillow if (!sis->ioaddr) { 129370597851SDavid Dillow dev_err(&pci->dev, "unable to remap MMIO, aborting\n"); 1294*499ddc16STakashi Iwai return -EIO; 1295175859bfSDavid Dillow } 1296175859bfSDavid Dillow 1297175859bfSDavid Dillow rc = sis_alloc_suspend(sis); 1298175859bfSDavid Dillow if (rc < 0) { 129970597851SDavid Dillow dev_err(&pci->dev, "unable to allocate state storage\n"); 1300*499ddc16STakashi Iwai return rc; 1301175859bfSDavid Dillow } 1302175859bfSDavid Dillow 1303175859bfSDavid Dillow rc = sis_chip_init(sis); 1304175859bfSDavid Dillow if (rc) 1305*499ddc16STakashi Iwai return rc; 1306*499ddc16STakashi Iwai card->private_free = sis_chip_free; 1307175859bfSDavid Dillow 1308ae970eb4SJulia Lawall rc = request_irq(pci->irq, sis_interrupt, IRQF_SHARED, KBUILD_MODNAME, 1309ae970eb4SJulia Lawall sis); 1310ae970eb4SJulia Lawall if (rc) { 131170597851SDavid Dillow dev_err(&pci->dev, "unable to allocate irq %d\n", sis->irq); 1312*499ddc16STakashi Iwai return rc; 1313175859bfSDavid Dillow } 1314175859bfSDavid Dillow 1315175859bfSDavid Dillow sis->irq = pci->irq; 131639b77268STakashi Iwai card->sync_irq = sis->irq; 1317175859bfSDavid Dillow pci_set_master(pci); 1318175859bfSDavid Dillow 1319175859bfSDavid Dillow for (i = 0; i < 64; i++) { 1320175859bfSDavid Dillow voice = &sis->voices[i]; 1321175859bfSDavid Dillow voice->num = i; 1322175859bfSDavid Dillow voice->ctrl_base = SIS_PLAY_DMA_ADDR(sis->ioaddr, i); 1323175859bfSDavid Dillow voice->wave_base = SIS_WAVE_ADDR(sis->ioaddr, i); 1324175859bfSDavid Dillow } 1325175859bfSDavid Dillow 1326175859bfSDavid Dillow voice = &sis->capture_voice; 1327175859bfSDavid Dillow voice->flags = VOICE_CAPTURE; 1328175859bfSDavid Dillow voice->num = SIS_CAPTURE_CHAN_AC97_PCM_IN; 1329175859bfSDavid Dillow voice->ctrl_base = SIS_CAPTURE_DMA_ADDR(sis->ioaddr, voice->num); 1330175859bfSDavid Dillow 1331175859bfSDavid Dillow return 0; 1332175859bfSDavid Dillow } 1333175859bfSDavid Dillow 1334e23e7a14SBill Pemberton static int snd_sis7019_probe(struct pci_dev *pci, 1335175859bfSDavid Dillow const struct pci_device_id *pci_id) 1336175859bfSDavid Dillow { 1337175859bfSDavid Dillow struct snd_card *card; 1338175859bfSDavid Dillow struct sis7019 *sis; 1339175859bfSDavid Dillow int rc; 1340175859bfSDavid Dillow 1341175859bfSDavid Dillow if (!enable) 1342*499ddc16STakashi Iwai return -ENOENT; 1343175859bfSDavid Dillow 1344fc084e0bSDavid Dillow /* The user can specify which codecs should be present so that we 1345fc084e0bSDavid Dillow * can wait for them to show up if they are slow to recover from 1346fc084e0bSDavid Dillow * the AC97 cold reset. We default to a single codec, the primary. 1347fc084e0bSDavid Dillow * 1348fc084e0bSDavid Dillow * We assume that SIS_PRIMARY_*_PRESENT matches bits 0-2. 1349fc084e0bSDavid Dillow */ 1350fc084e0bSDavid Dillow codecs &= SIS_PRIMARY_CODEC_PRESENT | SIS_SECONDARY_CODEC_PRESENT | 1351fc084e0bSDavid Dillow SIS_TERTIARY_CODEC_PRESENT; 1352fc084e0bSDavid Dillow if (!codecs) 1353fc084e0bSDavid Dillow codecs = SIS_PRIMARY_CODEC_PRESENT; 1354fc084e0bSDavid Dillow 135560c5772bSTakashi Iwai rc = snd_card_new(&pci->dev, index, id, THIS_MODULE, 135660c5772bSTakashi Iwai sizeof(*sis), &card); 1357e58de7baSTakashi Iwai if (rc < 0) 1358*499ddc16STakashi Iwai return rc; 1359175859bfSDavid Dillow 1360175859bfSDavid Dillow strcpy(card->driver, "SiS7019"); 1361175859bfSDavid Dillow strcpy(card->shortname, "SiS7019"); 1362175859bfSDavid Dillow rc = sis_chip_create(card, pci); 1363175859bfSDavid Dillow if (rc) 1364*499ddc16STakashi Iwai return rc; 1365175859bfSDavid Dillow 1366175859bfSDavid Dillow sis = card->private_data; 1367175859bfSDavid Dillow 1368175859bfSDavid Dillow rc = sis_mixer_create(sis); 1369175859bfSDavid Dillow if (rc) 1370*499ddc16STakashi Iwai return rc; 1371175859bfSDavid Dillow 1372175859bfSDavid Dillow rc = sis_pcm_create(sis); 1373175859bfSDavid Dillow if (rc) 1374*499ddc16STakashi Iwai return rc; 1375175859bfSDavid Dillow 1376175859bfSDavid Dillow snprintf(card->longname, sizeof(card->longname), 1377175859bfSDavid Dillow "%s Audio Accelerator with %s at 0x%lx, irq %d", 1378175859bfSDavid Dillow card->shortname, snd_ac97_get_short_name(sis->ac97[0]), 1379175859bfSDavid Dillow sis->ioport, sis->irq); 1380175859bfSDavid Dillow 1381175859bfSDavid Dillow rc = snd_card_register(card); 1382175859bfSDavid Dillow if (rc) 1383*499ddc16STakashi Iwai return rc; 1384175859bfSDavid Dillow 1385175859bfSDavid Dillow pci_set_drvdata(pci, card); 1386175859bfSDavid Dillow return 0; 1387175859bfSDavid Dillow } 1388175859bfSDavid Dillow 1389175859bfSDavid Dillow static struct pci_driver sis7019_driver = { 13903733e424STakashi Iwai .name = KBUILD_MODNAME, 1391175859bfSDavid Dillow .id_table = snd_sis7019_ids, 1392175859bfSDavid Dillow .probe = snd_sis7019_probe, 139368cb2b55STakashi Iwai .driver = { 139468cb2b55STakashi Iwai .pm = SIS_PM_OPS, 139568cb2b55STakashi Iwai }, 1396175859bfSDavid Dillow }; 1397175859bfSDavid Dillow 1398e9f66d9bSTakashi Iwai module_pci_driver(sis7019_driver); 1399