static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io, struct rsnd_mod *mod) { struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io); struct rsnd_mod *src = rsnd_io_to_mod_src(io); struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); const u8 *entry = NULL; int id = rsnd_mod_id(mod); int size = 0; if (mod == ssi) { entry = gen2_id_table_ssiu; size = ARRAY_SIZE(gen2_id_table_ssiu); } else if (mod == src) { entry = gen2_id_table_scu; size = ARRAY_SIZE(gen2_id_table_scu); } else if (mod == dvc) { entry = gen2_id_table_cmd; size = ARRAY_SIZE(gen2_id_table_cmd); } if ((!entry) || (size <= id)) { struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); dev_err(dev, "unknown connection (%s[%d])\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); /* use non-prohibited SRS number as error */ return 0x00; /* SSI00 */ } return entry[id]; }
char *rsnd_mod_name(struct rsnd_mod *mod) { static char names[MOD_NAME_NUM][MOD_NAME_SIZE]; static int num; char *name = names[num]; num++; if (num >= MOD_NAME_NUM) num = 0; /* * Let's use same char to avoid pointlessness memory * Thus, rsnd_mod_name() should be used immediately * Don't keep pointer */ if ((mod)->ops->id_sub) { snprintf(name, MOD_NAME_SIZE, "%s[%d%d]", mod->ops->name, rsnd_mod_id(mod), rsnd_mod_id_sub(mod)); } else { snprintf(name, MOD_NAME_SIZE, "%s[%d]", mod->ops->name, rsnd_mod_id(mod)); } return name; }
static u32 rsnd_ssi_run_mods(struct rsnd_dai_stream *io) { struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io); struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io); return rsnd_ssi_multi_slaves_runtime(io) | 1 << rsnd_mod_id(ssi_mod) | 1 << rsnd_mod_id(ssi_parent_mod); }
void rsnd_write(struct rsnd_priv *priv, struct rsnd_mod *mod, enum rsnd_reg reg, u32 data) { struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_gen *gen = rsnd_priv_to_gen(priv); if (!rsnd_is_accessible_reg(priv, gen, reg)) return; dev_dbg(dev, "w %s[%d] - %4d : %08x\n", rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data); regmap_fields_write(gen->regs[reg], rsnd_mod_id(mod), data); }
static void rsnd_adg_set_ssi_clk(struct rsnd_mod *ssi_mod, u32 val) { struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); struct rsnd_adg *adg = rsnd_priv_to_adg(priv); struct rsnd_mod *adg_mod = rsnd_mod_get(adg); int id = rsnd_mod_id(ssi_mod); int shift = (id % 4) * 8; u32 mask = 0xFF << shift; rsnd_mod_confirm_ssi(ssi_mod); val = val << shift; /* * SSI 8 is not connected to ADG. * it works with SSI 7 */ if (id == 8) return; switch (id / 4) { case 0: rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL0, mask, val); break; case 1: rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL1, mask, val); break; case 2: rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL2, mask, val); break; } }
/* * SSI PIO */ static void rsnd_ssi_parent_attach(struct rsnd_mod *mod, struct rsnd_dai_stream *io) { struct rsnd_dai *rdai = rsnd_io_to_rdai(io); struct rsnd_priv *priv = rsnd_mod_to_priv(mod); if (!__rsnd_ssi_is_pin_sharing(mod)) return; if (!rsnd_rdai_is_clk_master(rdai)) return; switch (rsnd_mod_id(mod)) { case 1: case 2: rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP); break; case 4: rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP); break; case 8: rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP); break; } }
static int rsnd_ssi_quit(struct rsnd_mod *mod, struct rsnd_dai_stream *io, struct rsnd_priv *priv) { struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); struct device *dev = rsnd_priv_to_dev(priv); if (!rsnd_ssi_is_run_mods(mod, io)) return 0; if (!ssi->usrcnt) { dev_err(dev, "%s[%d] usrcnt error\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); return -EIO; } if (!rsnd_ssi_is_parent(mod, io)) ssi->cr_own = 0; rsnd_ssi_master_clk_stop(mod, io); rsnd_mod_power_off(mod); ssi->usrcnt--; return 0; }
static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi, struct rsnd_dai *rdai, struct rsnd_dai_stream *io) { struct rsnd_priv *priv = rsnd_mod_to_priv(&ssi->mod); struct device *dev = rsnd_priv_to_dev(priv); u32 cr; if (0 == ssi->usrcnt) { clk_enable(ssi->clk); if (rsnd_rdai_is_clk_master(rdai)) { if (rsnd_ssi_clk_from_parent(ssi)) rsnd_ssi_hw_start(ssi->parent, rdai, io); else rsnd_ssi_master_clk_start(ssi, io); } } cr = ssi->cr_own | ssi->cr_clk | ssi->cr_etc | EN; rsnd_mod_write(&ssi->mod, SSICR, cr); ssi->usrcnt++; dev_dbg(dev, "ssi%d hw started\n", rsnd_mod_id(&ssi->mod)); }
static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io, struct rsnd_mod *mod) { struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io); struct rsnd_mod *src = rsnd_io_to_mod_src(io); struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); const u8 *entry = NULL; int id = rsnd_mod_id(mod); int size = 0; if (mod == ssi) { entry = gen2_id_table_ssiu; size = ARRAY_SIZE(gen2_id_table_ssiu); } else if (mod == src) { entry = gen2_id_table_scu; size = ARRAY_SIZE(gen2_id_table_scu); } else if (mod == dvc) { entry = gen2_id_table_cmd; size = ARRAY_SIZE(gen2_id_table_cmd); } if (!entry) return 0xFF; if (size <= id) return 0xFF; return entry[id]; }
static dma_addr_t rsnd_gen2_dma_addr(struct rsnd_dai_stream *io, struct rsnd_mod *mod, int is_play, int is_from) { struct rsnd_priv *priv = rsnd_io_to_priv(io); struct device *dev = rsnd_priv_to_dev(priv); phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI); phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU); int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod); int use_src = !!rsnd_io_to_mod_src(io); int use_dvc = !!rsnd_io_to_mod_dvc(io); int id = rsnd_mod_id(mod); struct dma_addr { dma_addr_t out_addr; dma_addr_t in_addr; } dma_addrs[3][2][3] = { /* SRC */ {{{ 0, 0 }, /* Capture */ { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) }, { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } }, /* Playback */ {{ 0, 0, }, { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) }, { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } } }, /* SSI */ /* Capture */ {{{ RDMA_SSI_O_N(ssi, id), 0 }, { RDMA_SSIU_O_P(ssi, id), 0 }, { RDMA_SSIU_O_P(ssi, id), 0 } }, /* Playback */ {{ 0, RDMA_SSI_I_N(ssi, id) }, { 0, RDMA_SSIU_I_P(ssi, id) }, { 0, RDMA_SSIU_I_P(ssi, id) } } }, /* SSIU */ /* Capture */ {{{ RDMA_SSIU_O_N(ssi, id), 0 }, { RDMA_SSIU_O_P(ssi, id), 0 }, { RDMA_SSIU_O_P(ssi, id), 0 } }, /* Playback */ {{ 0, RDMA_SSIU_I_N(ssi, id) }, { 0, RDMA_SSIU_I_P(ssi, id) }, { 0, RDMA_SSIU_I_P(ssi, id) } } }, }; /* it shouldn't happen */ if (use_dvc && !use_src) dev_err(dev, "DVC is selected without SRC\n"); /* use SSIU or SSI ? */ if (is_ssi && rsnd_ssi_use_busif(io, mod)) is_ssi++; return (is_from) ? dma_addrs[is_ssi][is_play][use_src + use_dvc].out_addr : dma_addrs[is_ssi][is_play][use_src + use_dvc].in_addr; }
void __iomem *rsnd_gen_reg_get(struct rsnd_priv *priv, struct rsnd_mod *mod, enum rsnd_reg reg) { struct rsnd_gen *gen = rsnd_priv_to_gen(priv); struct device *dev = rsnd_priv_to_dev(priv); int index; u32 offset_id, offset_adr; if (reg >= RSND_REG_MAX) { dev_err(dev, "rsnd_reg reg error\n"); return NULL; } index = gen->reg_map[reg].index; offset_id = gen->reg_map[reg].offset_id; offset_adr = gen->reg_map[reg].offset_adr; if (index < 0) { dev_err(dev, "unsupported reg access %d\n", reg); return NULL; } if (offset_id && mod) offset_id *= rsnd_mod_id(mod); /* * index/offset were set on gen1/gen2 */ return gen->base[index] + offset_id + offset_adr; }
static void rsnd_src_error_clear_gen2(struct rsnd_mod *mod) { u32 val = OUF_SRC(rsnd_mod_id(mod)); rsnd_mod_bset(mod, SCU_SYS_STATUS0, val, val); rsnd_mod_bset(mod, SCU_SYS_STATUS1, val, val); }
static int rsnd_src_probe_gen2(struct rsnd_mod *mod, struct rsnd_dai *rdai, struct rsnd_dai_stream *io) { struct rsnd_priv *priv = rsnd_mod_to_priv(mod); struct rcar_snd_info *info = rsnd_priv_to_info(priv); struct rsnd_src *src = rsnd_mod_to_src(mod); struct rsnd_mod *ssi = rsnd_ssi_mod_get(priv, rsnd_mod_id(mod)); struct device *dev = rsnd_priv_to_dev(priv); int ret; int is_play; if (info->dai_info) is_play = rsnd_info_is_playback(priv, src); else is_play = rsnd_ssi_is_play(ssi); ret = rsnd_dma_init(priv, rsnd_mod_to_dma(mod), is_play, src->info->dma_id); if (ret < 0) dev_err(dev, "SRC DMA failed\n"); return ret; }
static void rsnd_src_irq_ctrol_gen2(struct rsnd_mod *mod, int enable) { struct rsnd_src *src = rsnd_mod_to_src(mod); u32 sys_int_val, int_val, sys_int_mask; int irq = src->info->irq; int id = rsnd_mod_id(mod); sys_int_val = sys_int_mask = OUF_SRC(id); int_val = 0x3300; /* * IRQ is not supported on non-DT * see * rsnd_src_probe_gen2() */ if ((irq <= 0) || !enable) { sys_int_val = 0; int_val = 0; } rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val); rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val); rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val); }
u32 rsnd_read(struct rsnd_priv *priv, struct rsnd_mod *mod, enum rsnd_reg reg) { struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_gen *gen = rsnd_priv_to_gen(priv); u32 val; if (!rsnd_is_accessible_reg(priv, gen, reg)) return 0; regmap_fields_read(gen->regs[reg], rsnd_mod_id(mod), &val); dev_dbg(dev, "r %s[%d] - %4d : %08x\n", rsnd_mod_name(mod), rsnd_mod_id(mod), reg, val); return val; }
void rsnd_bset(struct rsnd_priv *priv, struct rsnd_mod *mod, enum rsnd_reg reg, u32 mask, u32 data) { struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_gen *gen = rsnd_priv_to_gen(priv); if (!rsnd_is_accessible_reg(priv, gen, reg)) return; regmap_fields_update_bits(gen->regs[reg], rsnd_mod_id(mod), mask, data); dev_dbg(dev, "b %s[%d] - %-18s (%4d) : %08x/%08x\n", rsnd_mod_name(mod), rsnd_mod_id(mod), rsnd_reg_name(gen, reg), reg, data, mask); }
static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod, struct rsnd_dai *rdai, struct rsnd_dai_stream *io) { struct rsnd_priv *priv = rsnd_mod_to_priv(mod); struct rsnd_src *src = rsnd_mod_to_src(mod); struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); u32 convert_rate = rsnd_src_convert_rate(src); u32 mask; u32 val; int shift; int id = rsnd_mod_id(mod); int ret; /* * SRC_TIMING_SELECT */ shift = (id % 4) * 8; mask = 0x1F << shift; /* * ADG is used as source clock if SRC was used, * then, SSI WS is used as destination clock. * SSI WS is used as source clock if SRC is not used * (when playback, source/destination become reverse when capture) */ ret = 0; if (convert_rate) { /* use ADG */ val = 0; ret = rsnd_adg_set_convert_clk_gen1(priv, mod, runtime->rate, convert_rate); } else if (8 == id) { /* use SSI WS, but SRU8 is special */ val = id << shift; } else { /* use SSI WS */ val = (id + 1) << shift; } if (ret < 0) return ret; switch (id / 4) { case 0: rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val); break; case 1: rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val); break; case 2: rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val); break; } return 0; }
int rsnd_adg_ssi_clk_try_start(struct rsnd_mod *mod, unsigned int rate) { struct rsnd_priv *priv = rsnd_mod_to_priv(mod); struct rsnd_adg *adg = rsnd_priv_to_adg(priv); struct device *dev = rsnd_priv_to_dev(priv); struct clk *clk; int i; u32 data; int sel_table[] = { [CLKA] = 0x1, [CLKB] = 0x2, [CLKC] = 0x3, [CLKI] = 0x0, }; dev_dbg(dev, "request clock = %d\n", rate); /* * find suitable clock from * AUDIO_CLKA/AUDIO_CLKB/AUDIO_CLKC/AUDIO_CLKI. */ data = 0; for_each_rsnd_clk(clk, adg, i) { if (rate == clk_get_rate(clk)) { data = sel_table[i]; goto found_clock; } } /* * find divided clock from BRGA/BRGB */ if (rate == adg->rbga_rate_for_441khz) { data = 0x10; goto found_clock; } if (rate == adg->rbgb_rate_for_48khz) { data = 0x20; goto found_clock; } return -EIO; found_clock: /* * This "mod" = "ssi" here. * we can get "ssi id" from mod */ rsnd_adg_set_ssi_clk(mod, data); dev_dbg(dev, "ADG: %s[%d] selects 0x%x for %d\n", rsnd_mod_name(mod), rsnd_mod_id(mod), data, rate); return 0; }
/* * SSI mod common functions */ static int rsnd_ssi_init(struct rsnd_mod *mod, struct rsnd_dai *rdai, struct rsnd_dai_stream *io) { struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); struct rsnd_priv *priv = rsnd_mod_to_priv(mod); struct device *dev = rsnd_priv_to_dev(priv); struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); u32 cr; cr = FORCE; /* * always use 32bit system word for easy clock calculation. * see also rsnd_ssi_master_clk_enable() */ cr |= SWL_32; /* * init clock settings for SSICR */ switch (runtime->sample_bits) { case 16: cr |= DWL_16; break; case 32: cr |= DWL_24; break; default: return -EIO; } if (rdai->bit_clk_inv) cr |= SCKP; if (rdai->frm_clk_inv) cr |= SWSP; if (rdai->data_alignment) cr |= SDTA; if (rdai->sys_delay) cr |= DEL; if (rsnd_dai_is_play(rdai, io)) cr |= TRMD; /* * set ssi parameter */ ssi->rdai = rdai; ssi->io = io; ssi->cr_own = cr; ssi->err = -1; /* ignore 1st error */ rsnd_ssi_mode_set(priv, rdai, ssi); dev_dbg(dev, "%s.%d init\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); return 0; }
/* * Renesas sound Gen1 needs 1 DMAC, * Gen2 needs 2 DMAC. * In Gen2 case, it are Audio-DMAC, and Audio-DMAC-peri-peri. * But, Audio-DMAC-peri-peri doesn't have interrupt, * and this driver is assuming that here. * * If Audio-DMAC-peri-peri has interrpt, * rsnd_dai_pointer_update() will be called twice, * ant it will breaks io->byte_pos */ rsnd_dai_pointer_update(io, io->byte_per_period); } void rsnd_dma_start(struct rsnd_dma *dma) { struct rsnd_mod *mod = rsnd_dma_to_mod(dma); struct rsnd_priv *priv = rsnd_mod_to_priv(mod); struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); struct snd_pcm_substream *substream = io->substream; struct device *dev = rsnd_priv_to_dev(priv); struct dma_async_tx_descriptor *desc; desc = dmaengine_prep_dma_cyclic(dma->chan, (dma->addr) ? dma->addr : substream->runtime->dma_addr, snd_pcm_lib_buffer_bytes(substream), snd_pcm_lib_period_bytes(substream), dma->dir, DMA_PREP_INTERRUPT | DMA_CTRL_ACK); if (!desc) { dev_err(dev, "dmaengine_prep_slave_sg() fail\n"); return; } desc->callback = rsnd_dma_complete; desc->callback_param = dma; if (dmaengine_submit(desc) < 0) { dev_err(dev, "dmaengine_submit() fail\n"); return; } dma_async_issue_pending(dma->chan); } int rsnd_dma_available(struct rsnd_dma *dma) { return !!dma->chan; } #define DMA_NAME_SIZE 16 #define MOD_MAX 4 /* MEM/SSI/SRC/DVC */ static int _rsnd_dma_of_name(char *dma_name, struct rsnd_mod *mod) { if (mod) return snprintf(dma_name, DMA_NAME_SIZE / 2, "%s%d", rsnd_mod_dma_name(mod), rsnd_mod_id(mod)); else return snprintf(dma_name, DMA_NAME_SIZE / 2, "mem"); }
static int rsnd_src_start_gen1(struct rsnd_mod *mod, struct rsnd_dai *rdai) { int id = rsnd_mod_id(mod); rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id)); return rsnd_src_start(mod, rdai); }
static int rsnd_src_stop_gen1(struct rsnd_mod *mod, struct rsnd_priv *priv) { int id = rsnd_mod_id(mod); rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0); return rsnd_src_stop(mod); }
int rsnd_ssiu_attach(struct rsnd_dai_stream *io, struct rsnd_mod *ssi_mod) { struct rsnd_priv *priv = rsnd_io_to_priv(io); struct rsnd_mod *mod = rsnd_ssiu_mod_get(priv, rsnd_mod_id(ssi_mod)); rsnd_mod_confirm_ssi(ssi_mod); return rsnd_dai_connect(mod, io, mod->type); }
static int rsnd_src_probe_gen1(struct rsnd_mod *mod, struct rsnd_priv *priv) { struct device *dev = rsnd_priv_to_dev(priv); dev_dbg(dev, "%s[%d] (Gen1) is probed\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); return 0; }
static int rsnd_src_stop_gen1(struct rsnd_mod *mod, struct rsnd_dai *rdai, struct rsnd_dai_stream *io) { int id = rsnd_mod_id(mod); rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0); return rsnd_src_stop(mod, rdai, io); }
void rsnd_mod_make_sure(struct rsnd_mod *mod, enum rsnd_mod_type type) { if (mod->type != type) { struct rsnd_priv *priv = rsnd_mod_to_priv(mod); struct device *dev = rsnd_priv_to_dev(priv); dev_warn(dev, "%s[%d] is not your expected module\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); } }
static int rsnd_src_probe_gen2(struct rsnd_mod *mod, struct rsnd_dai *rdai) { struct rsnd_priv *priv = rsnd_mod_to_priv(mod); struct rsnd_src *src = rsnd_mod_to_src(mod); struct device *dev = rsnd_priv_to_dev(priv); int ret; ret = rsnd_dma_init(priv, rsnd_mod_to_dma(mod), rsnd_info_is_playback(priv, src), src->info->dma_id); if (ret < 0) dev_err(dev, "%s[%d] (Gen2) failed\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); else dev_dbg(dev, "%s[%d] (Gen2) is probed\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); return ret; }
static int rsnd_src_probe_gen2(struct rsnd_mod *mod, struct rsnd_priv *priv) { struct rsnd_src *src = rsnd_mod_to_src(mod); struct device *dev = rsnd_priv_to_dev(priv); int irq = src->info->irq; int ret; if (irq > 0) { /* * IRQ is not supported on non-DT * see * rsnd_src_irq_enable_gen2() */ ret = devm_request_irq(dev, irq, rsnd_src_interrupt_gen2, IRQF_SHARED, dev_name(dev), mod); if (ret) goto rsnd_src_probe_gen2_fail; } ret = rsnd_dma_init(priv, rsnd_mod_to_dma(mod), rsnd_info_is_playback(priv, src), src->info->dma_id); if (ret) goto rsnd_src_probe_gen2_fail; dev_dbg(dev, "%s[%d] (Gen2) is probed\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); return ret; rsnd_src_probe_gen2_fail: dev_err(dev, "%s[%d] (Gen2) failed\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); return ret; }
static irqreturn_t rsnd_ssi_interrupt(int irq, void *data) { struct rsnd_ssi *ssi = data; struct rsnd_mod *mod = &ssi->mod; struct rsnd_priv *priv = rsnd_mod_to_priv(mod); struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); int is_dma = rsnd_ssi_is_dma_mode(mod); u32 status = rsnd_mod_read(mod, SSISR); if (!io) return IRQ_NONE; /* PIO only */ if (!is_dma && (status & DIRQ)) { struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); u32 *buf = (u32 *)(runtime->dma_area + rsnd_dai_pointer_offset(io, 0)); /* * 8/16/32 data can be assesse to TDR/RDR register * directly as 32bit data * see rsnd_ssi_init() */ if (rsnd_io_is_play(io)) rsnd_mod_write(mod, SSITDR, *buf); else *buf = rsnd_mod_read(mod, SSIRDR); rsnd_dai_pointer_update(io, sizeof(*buf)); } /* PIO / DMA */ if (status & (UIRQ | OIRQ)) { struct device *dev = rsnd_priv_to_dev(priv); /* * restart SSI */ dev_dbg(dev, "%s[%d] restart\n", rsnd_mod_name(mod), rsnd_mod_id(mod)); rsnd_ssi_stop(mod, priv); if (ssi->err < 1024) rsnd_ssi_start(mod, priv); else dev_warn(dev, "no more SSI restart\n"); } rsnd_ssi_record_error(ssi, status); return IRQ_HANDLED; }
static int rsnd_soc_dai_trigger(struct snd_pcm_substream *substream, int cmd, struct snd_soc_dai *dai) { struct rsnd_priv *priv = snd_soc_dai_get_drvdata(dai); struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); int ssi_id = rsnd_mod_id(rsnd_io_to_mod_ssi(io)); int ret; unsigned long flags; rsnd_lock(priv, flags); switch (cmd) { case SNDRV_PCM_TRIGGER_START: ret = rsnd_dai_stream_init(io, substream); if (ret < 0) goto dai_trigger_end; ret = rsnd_platform_call(priv, dai, start, ssi_id); if (ret < 0) goto dai_trigger_end; ret = rsnd_dai_call(init, io, priv); if (ret < 0) goto dai_trigger_end; ret = rsnd_dai_call(start, io, priv); if (ret < 0) goto dai_trigger_end; break; case SNDRV_PCM_TRIGGER_STOP: ret = rsnd_dai_call(stop, io, priv); if (ret < 0) goto dai_trigger_end; ret = rsnd_dai_call(quit, io, priv); if (ret < 0) goto dai_trigger_end; ret = rsnd_platform_call(priv, dai, stop, ssi_id); if (ret < 0) goto dai_trigger_end; break; default: ret = -EINVAL; } dai_trigger_end: rsnd_unlock(priv, flags); return ret; }