int rsnd_scu_probe(struct platform_device *pdev, struct rcar_snd_info *info, struct rsnd_priv *priv) { struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_scu *scu; int i, nr; /* * init SCU */ nr = info->scu_info_nr; scu = devm_kzalloc(dev, sizeof(*scu) * nr, GFP_KERNEL); if (!scu) { dev_err(dev, "SCU allocate failed\n"); return -ENOMEM; } priv->scu_nr = nr; priv->scu = scu; for_each_rsnd_scu(scu, priv, i) { rsnd_mod_init(priv, &scu->mod, &rsnd_scu_ops, i); scu->info = &info->scu_info[i]; dev_dbg(dev, "SCU%d probed\n", i); }
int rsnd_ssiu_probe(struct rsnd_priv *priv) { struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_ssiu *ssiu; static struct rsnd_mod_ops *ops; int i, nr, ret; /* same number to SSI */ nr = priv->ssi_nr; ssiu = devm_kzalloc(dev, sizeof(*ssiu) * nr, GFP_KERNEL); if (!ssiu) return -ENOMEM; priv->ssiu = ssiu; priv->ssiu_nr = nr; if (rsnd_is_gen1(priv)) ops = &rsnd_ssiu_ops_gen1; else ops = &rsnd_ssiu_ops_gen2; for_each_rsnd_ssiu(ssiu, priv, i) { ret = rsnd_mod_init(priv, rsnd_mod_get(ssiu), ops, NULL, rsnd_mod_get_status, RSND_MOD_SSIU, i); if (ret) return ret; }
int rsnd_src_probe(struct platform_device *pdev, const struct rsnd_of_data *of_data, struct rsnd_priv *priv) { struct rcar_snd_info *info = rsnd_priv_to_info(priv); struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_src *src; struct rsnd_mod_ops *ops; struct clk *clk; char name[RSND_SRC_NAME_SIZE]; int i, nr; rsnd_of_parse_src(pdev, of_data, priv); /* * init SRC */ nr = info->src_info_nr; if (!nr) return 0; src = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL); if (!src) { dev_err(dev, "SRC allocate failed\n"); return -ENOMEM; } priv->src_nr = nr; priv->src = src; for_each_rsnd_src(src, priv, i) { snprintf(name, RSND_SRC_NAME_SIZE, "src.%d", i); clk = devm_clk_get(dev, name); if (IS_ERR(clk)) { snprintf(name, RSND_SRC_NAME_SIZE, "scu.%d", i); clk = devm_clk_get(dev, name); } if (IS_ERR(clk)) return PTR_ERR(clk); src->info = &info->src_info[i]; src->clk = clk; ops = &rsnd_src_non_ops; if (rsnd_src_hpbif_is_enable(src)) { if (rsnd_is_gen1(priv)) ops = &rsnd_src_gen1_ops; if (rsnd_is_gen2(priv)) ops = &rsnd_src_gen2_ops; } rsnd_mod_init(priv, &src->mod, ops, RSND_MOD_SRC, i); dev_dbg(dev, "SRC%d probed\n", i); }
int rsnd_mix_probe(struct rsnd_priv *priv) { struct device_node *node; struct device_node *np; struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_mix *mix; struct clk *clk; char name[MIX_NAME_SIZE]; int i, nr, ret; /* This driver doesn't support Gen1 at this point */ if (rsnd_is_gen1(priv)) return 0; node = rsnd_mix_of_node(priv); if (!node) return 0; /* not used is not error */ nr = of_get_child_count(node); if (!nr) { ret = -EINVAL; goto rsnd_mix_probe_done; } mix = devm_kcalloc(dev, nr, sizeof(*mix), GFP_KERNEL); if (!mix) { ret = -ENOMEM; goto rsnd_mix_probe_done; } priv->mix_nr = nr; priv->mix = mix; i = 0; ret = 0; for_each_child_of_node(node, np) { mix = rsnd_mix_get(priv, i); snprintf(name, MIX_NAME_SIZE, "%s.%d", MIX_NAME, i); clk = devm_clk_get(dev, name); if (IS_ERR(clk)) { ret = PTR_ERR(clk); of_node_put(np); goto rsnd_mix_probe_done; } ret = rsnd_mod_init(priv, rsnd_mod_get(mix), &rsnd_mix_ops, clk, rsnd_mod_get_status, RSND_MOD_MIX, i); if (ret) { of_node_put(np); goto rsnd_mix_probe_done; } i++; }
int rsnd_dvc_probe(struct rsnd_priv *priv) { struct device_node *node; struct device_node *np; struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_dvc *dvc; struct clk *clk; char name[RSND_DVC_NAME_SIZE]; int i, nr, ret; /* This driver doesn't support Gen1 at this point */ if (rsnd_is_gen1(priv)) return 0; node = rsnd_dvc_of_node(priv); if (!node) return 0; /* not used is not error */ nr = of_get_child_count(node); if (!nr) { ret = -EINVAL; goto rsnd_dvc_probe_done; } dvc = devm_kzalloc(dev, sizeof(*dvc) * nr, GFP_KERNEL); if (!dvc) { ret = -ENOMEM; goto rsnd_dvc_probe_done; } priv->dvc_nr = nr; priv->dvc = dvc; i = 0; ret = 0; for_each_child_of_node(node, np) { dvc = rsnd_dvc_get(priv, i); snprintf(name, RSND_DVC_NAME_SIZE, "%s.%d", DVC_NAME, i); clk = devm_clk_get(dev, name); if (IS_ERR(clk)) { ret = PTR_ERR(clk); goto rsnd_dvc_probe_done; } ret = rsnd_mod_init(priv, rsnd_mod_get(dvc), &rsnd_dvc_ops, clk, rsnd_mod_get_status, RSND_MOD_DVC, i); if (ret) goto rsnd_dvc_probe_done; i++; }
int rsnd_ssi_probe(struct platform_device *pdev, const struct rsnd_of_data *of_data, struct rsnd_priv *priv) { struct rcar_snd_info *info = rsnd_priv_to_info(priv); struct rsnd_ssi_platform_info *pinfo; struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_mod_ops *ops; struct clk *clk; struct rsnd_ssi *ssi; char name[RSND_SSI_NAME_SIZE]; int i, nr, ret; rsnd_of_parse_ssi(pdev, of_data, priv); /* * init SSI */ nr = info->ssi_info_nr; ssi = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL); if (!ssi) { dev_err(dev, "SSI allocate failed\n"); return -ENOMEM; } priv->ssi = ssi; priv->ssi_nr = nr; for_each_rsnd_ssi(ssi, priv, i) { pinfo = &info->ssi_info[i]; snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d", SSI_NAME, i); clk = devm_clk_get(dev, name); if (IS_ERR(clk)) return PTR_ERR(clk); ssi->info = pinfo; ops = &rsnd_ssi_non_ops; if (pinfo->dma_id > 0) ops = &rsnd_ssi_dma_ops; else if (rsnd_ssi_pio_available(ssi)) ops = &rsnd_ssi_pio_ops; ret = rsnd_mod_init(&ssi->mod, ops, clk, RSND_MOD_SSI, i); if (ret) return ret; rsnd_ssi_parent_clk_setup(priv, ssi); }
int rsnd_ssi_probe(struct platform_device *pdev, struct rcar_snd_info *info, struct rsnd_priv *priv) { struct rsnd_ssi_platform_info *pinfo; struct device *dev = rsnd_priv_to_dev(priv); struct rsnd_mod_ops *ops; struct clk *clk; struct rsnd_ssiu *ssiu; struct rsnd_ssi *ssi; char name[RSND_SSI_NAME_SIZE]; int i, nr, ret; /* * init SSI */ nr = info->ssi_info_nr; ssiu = devm_kzalloc(dev, sizeof(*ssiu) + (sizeof(*ssi) * nr), GFP_KERNEL); if (!ssiu) { dev_err(dev, "SSI allocate failed\n"); return -ENOMEM; } priv->ssiu = ssiu; ssiu->ssi = (struct rsnd_ssi *)(ssiu + 1); ssiu->ssi_nr = nr; for_each_rsnd_ssi(ssi, priv, i) { pinfo = &info->ssi_info[i]; snprintf(name, RSND_SSI_NAME_SIZE, "ssi.%d", i); clk = devm_clk_get(dev, name); if (IS_ERR(clk)) return PTR_ERR(clk); ssi->info = pinfo; ssi->clk = clk; ops = &rsnd_ssi_non_ops; /* * SSI DMA case */ if (pinfo->dma_id > 0) { ret = rsnd_dma_init( priv, rsnd_mod_to_dma(&ssi->mod), (rsnd_ssi_mode_flags(ssi) & RSND_SSI_PLAY), pinfo->dma_id, rsnd_ssi_dma_inquiry, rsnd_ssi_dma_complete); if (ret < 0) dev_info(dev, "SSI DMA failed. try PIO transter\n"); else ops = &rsnd_ssi_dma_ops; dev_dbg(dev, "SSI%d use DMA transfer\n", i); } /* * SSI PIO case */ if (!rsnd_ssi_dma_available(ssi) && rsnd_ssi_pio_available(ssi)) { ret = devm_request_irq(dev, pinfo->pio_irq, &rsnd_ssi_pio_interrupt, IRQF_SHARED, dev_name(dev), ssi); if (ret) { dev_err(dev, "SSI request interrupt failed\n"); return ret; } ops = &rsnd_ssi_pio_ops; dev_dbg(dev, "SSI%d use PIO transfer\n", i); } rsnd_mod_init(priv, &ssi->mod, ops, i); }