/* trigger_playback callback */ static int snd_p16v_pcm_trigger_playback(snd_pcm_substream_t *substream, int cmd) { emu10k1_t *emu = snd_pcm_substream_chip(substream); snd_pcm_runtime_t *runtime; emu10k1_pcm_t *epcm; int channel; int result = 0; struct list_head *pos; snd_pcm_substream_t *s; u32 basic = 0; u32 inte = 0; int running=0; switch (cmd) { case SNDRV_PCM_TRIGGER_START: running=1; break; case SNDRV_PCM_TRIGGER_STOP: default: running=0; break; } snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); runtime = s->runtime; epcm = runtime->private_data; channel = substream->pcm->device-emu->p16v_device_offset; //snd_printk("p16v channel=%d\n",channel); epcm->running = running; basic |= (0x1<<channel); inte |= (INTE2_PLAYBACK_CH_0_LOOP<<channel); snd_pcm_trigger_done(s, substream); }
/* trigger_playback callback */ static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream *substream, int cmd) { struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime; struct snd_emu10k1_pcm *epcm; int channel; int result = 0; struct snd_pcm_substream *s; u32 basic = 0; u32 inte = 0; int running = 0; switch (cmd) { case SNDRV_PCM_TRIGGER_START: running=1; break; case SNDRV_PCM_TRIGGER_STOP: default: running = 0; break; } snd_pcm_group_for_each_entry(s, substream) { if (snd_pcm_substream_chip(s) != emu || s->stream != SNDRV_PCM_STREAM_PLAYBACK) continue; runtime = s->runtime; epcm = runtime->private_data; channel = substream->pcm->device-emu->p16v_device_offset; /* dev_dbg(emu->card->dev, "p16v channel=%d\n", channel); */ epcm->running = running; basic |= (0x1<<channel); inte |= (INTE2_PLAYBACK_CH_0_LOOP<<channel); snd_pcm_trigger_done(s, substream); } /* dev_dbg(emu->card->dev, "basic=0x%x, inte=0x%x\n", basic, inte); */ switch (cmd) { case SNDRV_PCM_TRIGGER_START: snd_p16v_intr_enable(emu, inte); snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0)| (basic)); break; case SNDRV_PCM_TRIGGER_STOP: snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & ~(basic)); snd_p16v_intr_disable(emu, inte); break; default: result = -EINVAL; break; } return result; }
static int snd_playback_trigger(snd_pcm_substream_t * substream, int cmd) { pcm_hw_t *chip = snd_pcm_substream_chip(substream); DEBUG_PRINT(("ALSA Core : <<< snd_playback_trigger \n ")); switch(cmd) { case SNDRV_PCM_TRIGGER_START: DEBUG_PRINT(("ALSA Core : snd_playback_trigger Start \n ")); chip->State = STAUD_ALSA_START; chip->NumberOfBytesCopied = 0; chip->NumberUsed =0; chip->playback_ops->start_playback(substream); DEBUG_PRINT((" Debug snd_playback_trigger_started \n")); break; case SNDRV_PCM_TRIGGER_STOP: DEBUG_PRINT(("ALSA Core : snd_playback_trigger Stop \n ")); //if (chip->State == STAUD_ALSA_STOP) //return 0; // Debug above two lines chip->State = STAUD_ALSA_STOP; chip->playback_ops->stop_playback(substream); chip->card_data->in_use = 0; chip->NumberOfBytesCopied = 0; chip->NumberUsed =0; chip->PrevReadPointer=chip->BaseAddress; chip->ReadPointer = chip->BaseAddress; DEBUG_PRINT((" Debug snd_playback_trigger_stopped \n")); chip->Copy = FALSE; // Reset the Write Pointer --- chip->WritePointer = (U8 *)substream->runtime->dma_addr; break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: DEBUG_PRINT(("ALSA Core : snd_playback_trigger Pause \n ")); chip->playback_ops->pause_playback(substream); DEBUG_PRINT((" Debug snd_playback_trigger_pause \n")); break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: DEBUG_PRINT(("ALSA Core : snd_playback_trigger resume \n ")); chip->playback_ops->unpause_playback(substream); DEBUG_PRINT((" Debug snd_playback_trigger_resume \n")); break; default: return -EINVAL; } snd_pcm_trigger_done(substream,substream); DEBUG_PRINT(("ALSA Core :>>> snd_playback_trigger \n ")); return 0; }
static int lola_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { struct lola *chip = snd_pcm_substream_chip(substream); struct lola_stream *str; struct snd_pcm_substream *s; unsigned int start; unsigned int tstamp; bool sync_streams; switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_RESUME: start = 1; break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_STOP: start = 0; break; default: return -EINVAL; } /* * sample correct synchronization is only needed starting several * streams. On stop or if only one stream do as quick as possible */ sync_streams = (start && snd_pcm_stream_linked(substream)); tstamp = lola_get_tstamp(chip, !sync_streams); spin_lock(&chip->reg_lock); snd_pcm_group_for_each_entry(s, substream) { if (s->pcm->card != substream->pcm->card) continue; str = lola_get_stream(s); if (start) lola_stream_start(chip, str, tstamp); else lola_stream_stop(chip, str, tstamp); str->running = start; str->paused = !start; snd_pcm_trigger_done(s, substream); } spin_unlock(&chip->reg_lock); return 0; }
static int oxygen_trigger(struct snd_pcm_substream *substream, int cmd) { struct oxygen *chip = snd_pcm_substream_chip(substream); struct snd_pcm_substream *s; unsigned int mask = 0; int pausing; switch (cmd) { case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_SUSPEND: pausing = 0; break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: pausing = 1; break; default: return -EINVAL; } snd_pcm_group_for_each_entry(s, substream) { if (snd_pcm_substream_chip(s) == chip) { mask |= 1 << oxygen_substream_channel(s); snd_pcm_trigger_done(s, substream); } } spin_lock(&chip->reg_lock); if (!pausing) { if (cmd == SNDRV_PCM_TRIGGER_START) chip->pcm_running |= mask; else chip->pcm_running &= ~mask; oxygen_write8(chip, OXYGEN_DMA_STATUS, chip->pcm_running); } else { if (cmd == SNDRV_PCM_TRIGGER_PAUSE_PUSH) oxygen_set_bits8(chip, OXYGEN_DMA_PAUSE, mask); else oxygen_clear_bits8(chip, OXYGEN_DMA_PAUSE, mask); } spin_unlock(&chip->reg_lock); return 0; }
static int snd_ali_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_ali *codec = snd_pcm_substream_chip(substream); struct snd_pcm_substream *s; unsigned int what, whati, capture_flag; struct snd_ali_voice *pvoice, *evoice; unsigned int val; int do_start; switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_RESUME: do_start = 1; break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_SUSPEND: do_start = 0; break; default: return -EINVAL; } what = whati = capture_flag = 0; snd_pcm_group_for_each_entry(s, substream) { if ((struct snd_ali *) snd_pcm_substream_chip(s) == codec) { pvoice = s->runtime->private_data; evoice = pvoice->extra; what |= 1 << (pvoice->number & 0x1f); if (evoice == NULL) whati |= 1 << (pvoice->number & 0x1f); else { whati |= 1 << (evoice->number & 0x1f); what |= 1 << (evoice->number & 0x1f); } if (do_start) { pvoice->running = 1; if (evoice != NULL) evoice->running = 1; } else { pvoice->running = 0; if (evoice != NULL) evoice->running = 0; } snd_pcm_trigger_done(s, substream); if (pvoice->mode) capture_flag = 1; } } spin_lock(&codec->reg_lock); if (!do_start) outl(what, ALI_REG(codec, ALI_STOP)); val = inl(ALI_REG(codec, ALI_AINTEN)); if (do_start) val |= whati; else val &= ~whati; outl(val, ALI_REG(codec, ALI_AINTEN)); if (do_start) outl(what, ALI_REG(codec, ALI_START)); dev_dbg(codec->card->dev, "trigger: what=%xh whati=%xh\n", what, whati); spin_unlock(&codec->reg_lock); return 0; }
static int skl_coupled_trigger(struct snd_pcm_substream *substream, int cmd) { struct hdac_ext_bus *ebus = get_bus_ctx(substream); struct hdac_bus *bus = ebus_to_hbus(ebus); struct hdac_ext_stream *stream; struct snd_pcm_substream *s; bool start; int sbits = 0; unsigned long cookie; struct hdac_stream *hstr; stream = get_hdac_ext_stream(substream); hstr = hdac_stream(stream); dev_dbg(bus->dev, "In %s cmd=%d\n", __func__, cmd); if (!hstr->prepared) return -EPIPE; switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_RESUME: start = true; break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_STOP: start = false; break; default: return -EINVAL; } snd_pcm_group_for_each_entry(s, substream) { if (s->pcm->card != substream->pcm->card) continue; stream = get_hdac_ext_stream(s); sbits |= 1 << hdac_stream(stream)->index; snd_pcm_trigger_done(s, substream); } spin_lock_irqsave(&bus->reg_lock, cookie); /* first, set SYNC bits of corresponding streams */ snd_hdac_stream_sync_trigger(hstr, true, sbits, AZX_REG_SSYNC); snd_pcm_group_for_each_entry(s, substream) { if (s->pcm->card != substream->pcm->card) continue; stream = get_hdac_ext_stream(s); if (start) snd_hdac_stream_start(hdac_stream(stream), true); else snd_hdac_stream_stop(hdac_stream(stream)); } spin_unlock_irqrestore(&bus->reg_lock, cookie); snd_hdac_stream_sync(hstr, start, sbits); spin_lock_irqsave(&bus->reg_lock, cookie); /* reset SYNC bits */ snd_hdac_stream_sync_trigger(hstr, false, sbits, AZX_REG_SSYNC); if (start) snd_hdac_stream_timecounter_init(hstr, sbits); spin_unlock_irqrestore(&bus->reg_lock, cookie); return 0; }