C++ (Cpp) tegra_das_connect_dac_to_dap Beispiele

Beispiel #1

static int __devinit tegra_das_probe(struct platform_device *pdev)
{
	struct resource *res, *region;
	int ret = 0;

	if (das)
		return -ENODEV;

	das = devm_kzalloc(&pdev->dev, sizeof(struct tegra_das), GFP_KERNEL);
	if (!das) {
		dev_err(&pdev->dev, "Can't allocate tegra_das\n");
		ret = -ENOMEM;
		goto err;
	}
	das->dev = &pdev->dev;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(&pdev->dev, "No memory resource\n");
		ret = -ENODEV;
		goto err;
	}

	region = devm_request_mem_region(&pdev->dev, res->start,
					 resource_size(res), pdev->name);
	if (!region) {
		dev_err(&pdev->dev, "Memory region already claimed\n");
		ret = -EBUSY;
		goto err;
	}

	das->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
	if (!das->regs) {
		dev_err(&pdev->dev, "ioremap failed\n");
		ret = -ENOMEM;
		goto err;
	}

	ret = tegra_das_connect_dap_to_dac(TEGRA_DAS_DAP_ID_1,
					   TEGRA_DAS_DAP_SEL_DAC1);
	if (ret) {
		dev_err(&pdev->dev, "Can't set up DAS DAP connection\n");
		goto err;
	}
	ret = tegra_das_connect_dac_to_dap(TEGRA_DAS_DAC_ID_1,
					   TEGRA_DAS_DAC_SEL_DAP1);
	if (ret) {
		dev_err(&pdev->dev, "Can't set up DAS DAC connection\n");
		goto err;
	}

	tegra_das_debug_add(das);

	platform_set_drvdata(pdev, das);

	return 0;

err:
	das = NULL;
	return ret;
}

Beispiel #2

static __devinit int tegra_i2s_platform_probe(struct platform_device *pdev)
{
    struct tegra_i2s * i2s;
    char clk_name[12]; /* tegra-i2s.0 */
    struct resource *mem, *memregion, *dmareq;
    int ret;

    if ((pdev->id < 0) ||
            (pdev->id >= ARRAY_SIZE(tegra_i2s_dai))) {
        dev_err(&pdev->dev, "ID %d out of range\n", pdev->id);
        return -EINVAL;
    }

    /*
     * FIXME: Until a codec driver exists for the tegra DAS, hard-code a
     * 1:1 mapping between audio controllers and audio ports.
     */
    ret = tegra_das_connect_dap_to_dac(TEGRA_DAS_DAP_ID_1 + pdev->id,
                                       TEGRA_DAS_DAP_SEL_DAC1 + pdev->id);
    if (ret) {
        dev_err(&pdev->dev, "Can't set up DAP connection\n");
        return ret;
    }
    ret = tegra_das_connect_dac_to_dap(TEGRA_DAS_DAC_ID_1 + pdev->id,
                                       TEGRA_DAS_DAC_SEL_DAP1 + pdev->id);
    if (ret) {
        dev_err(&pdev->dev, "Can't set up DAC connection\n");
        return ret;
    }

    i2s = kzalloc(sizeof(struct tegra_i2s), GFP_KERNEL);
    if (!i2s) {
        dev_err(&pdev->dev, "Can't allocate tegra_i2s\n");
        ret = -ENOMEM;
        goto exit;
    }
    dev_set_drvdata(&pdev->dev, i2s);

    snprintf(clk_name, sizeof(clk_name), DRV_NAME ".%d", pdev->id);
    i2s->clk_i2s = clk_get_sys(clk_name, NULL);
    if (IS_ERR(i2s->clk_i2s)) {
        dev_err(&pdev->dev, "Can't retrieve i2s clock\n");
        ret = PTR_ERR(i2s->clk_i2s);
        goto err_free;
    }

    mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    if (!mem) {
        dev_err(&pdev->dev, "No memory resource\n");
        ret = -ENODEV;
        goto err_clk_put;
    }

    dmareq = platform_get_resource(pdev, IORESOURCE_DMA, 0);
    if (!dmareq) {
        dev_err(&pdev->dev, "No DMA resource\n");
        ret = -ENODEV;
        goto err_clk_put;
    }

    memregion = request_mem_region(mem->start, resource_size(mem),
                                   DRV_NAME);
    if (!memregion) {
        dev_err(&pdev->dev, "Memory region already claimed\n");
        ret = -EBUSY;
        goto err_clk_put;
    }

    i2s->regs = ioremap(mem->start, resource_size(mem));
    if (!i2s->regs) {
        dev_err(&pdev->dev, "ioremap failed\n");
        ret = -ENOMEM;
        goto err_release;
    }

    i2s->capture_dma_data.addr = mem->start + TEGRA_I2S_FIFO2;
    i2s->capture_dma_data.wrap = 4;
    i2s->capture_dma_data.width = 32;
    i2s->capture_dma_data.req_sel = dmareq->start;

    i2s->playback_dma_data.addr = mem->start + TEGRA_I2S_FIFO1;
    i2s->playback_dma_data.wrap = 4;
    i2s->playback_dma_data.width = 32;
    i2s->playback_dma_data.req_sel = dmareq->start;

    i2s->reg_ctrl = TEGRA_I2S_CTRL_FIFO_FORMAT_PACKED;

    ret = snd_soc_register_dai(&pdev->dev, &tegra_i2s_dai[pdev->id]);
    if (ret) {
        dev_err(&pdev->dev, "Could not register DAI: %d\n", ret);
        ret = -ENOMEM;
        goto err_unmap;
    }

    tegra_i2s_debug_add(i2s, pdev->id);

    return 0;

err_unmap:
    iounmap(i2s->regs);
err_release:
    release_mem_region(mem->start, resource_size(mem));
err_clk_put:
    clk_put(i2s->clk_i2s);
err_free:
    kfree(i2s);
exit:
    return ret;
}