nv-tegra-mirror/linux-nv-oot
1
0
Fork 0
mirror of git://nv-tegra.nvidia.com/linux-nv-oot.git synced 2025-12-24 10:11:26 +03:00
Code Issues Packages Projects Releases Wiki Activity

ASoC: tegra-alt: cleanup resource ioremap

Browse Source 
Currently drivers for resource ioremap does following explicit operations.
 * error check for platform_get_resource()
 * call devm_request_mem_region()
 * call devm_ioremap()

Instead of above explicit calls, devm_ioremap_resource() function can be
used, which covers all of the above. As per this scheme all drivers are
updated for memory region request and ioremapping.

Bug 200503387

Change-Id: I7b8df29742e8236d315369ef76aa57d47f47aac7
Signed-off-by: Sameer Pujar <spujar@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/2152456
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>
This commit is contained in:
Sameer Pujar
2019-07-12 20:42:18 +05:30
parent b289cafe0e
commit 87dc6dec32
18 changed files with 100 additions and 433 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
sound/soc/tegra-alt/tegra186_arad_alt.c
View File

@@ -745,7 +745,7 @@ void tegra186_arad_ahc_deferred_cb(void *data)
static int tegra186_arad_platform_probe(struct platform_device *pdev)
{
struct tegra186_arad *arad;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -769,33 +769,14 @@ static int tegra186_arad_platform_probe(struct platform_device *pdev)
dev_set_drvdata(&pdev->dev, arad);
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), DRV_NAME);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
arad->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra186_arad_regmap_config);
&tegra186_arad_regmap_config);
if (IS_ERR(arad->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(arad->regmap);
goto err;
return PTR_ERR(arad->regmap);
}
regcache_cache_only(arad->regmap, true);

31
sound/soc/tegra-alt/tegra186_asrc_alt.c
View File

@@ -1085,7 +1085,7 @@ static const struct of_device_id tegra186_asrc_of_match[] = {
static int tegra186_asrc_platform_probe(struct platform_device *pdev)
{
struct tegra186_asrc *asrc;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -1110,33 +1110,14 @@ static int tegra186_asrc_platform_probe(struct platform_device *pdev)
dev_set_drvdata(&pdev->dev, asrc);
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
asrc->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra186_asrc_regmap_config);
&tegra186_asrc_regmap_config);
if (IS_ERR(asrc->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(asrc->regmap);
goto err;
return PTR_ERR(asrc->regmap);
}
regcache_cache_only(asrc->regmap, true);

31
sound/soc/tegra-alt/tegra186_dspk_alt.c
View File

@@ -447,7 +447,7 @@ static int tegra186_dspk_platform_probe(struct platform_device *pdev)
{
struct tegra186_dspk *dspk;
struct device_node *np = pdev->dev.of_node;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -495,33 +495,14 @@ static int tegra186_dspk_platform_probe(struct platform_device *pdev)
}
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
dspk->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra186_dspk_regmap_config);
&tegra186_dspk_regmap_config);
if (IS_ERR(dspk->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(dspk->regmap);
goto err;
return PTR_ERR(dspk->regmap);
}
regcache_cache_only(dspk->regmap, true);

19
sound/soc/tegra-alt/tegra210_admaif_alt.c
View File

@@ -1205,26 +1205,15 @@ static int tegra_admaif_probe(struct platform_device *pdev)
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "No memory resource for admaif\n");
ret = -ENODEV;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, res);
if (!regs) {
dev_err(&pdev->dev, "request/iomap region failed\n");
ret = -ENODEV;
goto err;
}
if (IS_ERR(regs))
return PTR_ERR(regs);
admaif->base_addr = regs;
admaif->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
admaif->soc_data->regmap_conf);
admaif->soc_data->regmap_conf);
if (IS_ERR(admaif->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(admaif->regmap);
goto err;
return PTR_ERR(admaif->regmap);
}
regcache_cache_only(admaif->regmap, true);

29
sound/soc/tegra-alt/tegra210_adx_alt.c
View File

@@ -797,7 +797,7 @@ static const struct of_device_id tegra210_adx_of_match[] = {
static int tegra210_adx_platform_probe(struct platform_device *pdev)
{
struct tegra210_adx *adx;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -820,33 +820,14 @@ static int tegra210_adx_platform_probe(struct platform_device *pdev)
dev_set_drvdata(&pdev->dev, adx);
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), DRV_NAME);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
adx->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_adx_regmap_config);
if (IS_ERR(adx->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(adx->regmap);
goto err;
return PTR_ERR(adx->regmap);
}
regcache_cache_only(adx->regmap, true);

29
sound/soc/tegra-alt/tegra210_afc_alt.c
View File

@@ -512,7 +512,7 @@ static const struct of_device_id tegra210_afc_of_match[] = {
static int tegra210_afc_platform_probe(struct platform_device *pdev)
{
struct tegra210_afc *afc;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -539,33 +539,14 @@ static int tegra210_afc_platform_probe(struct platform_device *pdev)
dev_set_drvdata(&pdev->dev, afc);
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
afc->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_afc_regmap_config);
if (IS_ERR(afc->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(afc->regmap);
goto err;
return PTR_ERR(afc->regmap);
}
regcache_cache_only(afc->regmap, true);

29
sound/soc/tegra-alt/tegra210_amx_alt.c
View File

@@ -877,7 +877,7 @@ static const struct of_device_id tegra210_amx_of_match[] = {
static int tegra210_amx_platform_probe(struct platform_device *pdev)
{
struct tegra210_amx *amx;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret;
const struct of_device_id *match;
@@ -905,33 +905,14 @@ static int tegra210_amx_platform_probe(struct platform_device *pdev)
dev_set_drvdata(&pdev->dev, amx);
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), DRV_NAME);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
amx->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
soc_data->regmap_conf);
if (IS_ERR(amx->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(amx->regmap);
goto err;
return PTR_ERR(amx->regmap);
}
regcache_cache_only(amx->regmap, true);

31
sound/soc/tegra-alt/tegra210_dmic_alt.c
View File

@@ -560,7 +560,7 @@ static int tegra210_dmic_platform_probe(struct platform_device *pdev)
{
struct tegra210_dmic *dmic;
struct device_node *np = pdev->dev.of_node;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -608,33 +608,14 @@ static int tegra210_dmic_platform_probe(struct platform_device *pdev)
}
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
dmic->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_dmic_regmap_config);
&tegra210_dmic_regmap_config);
if (IS_ERR(dmic->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(dmic->regmap);
goto err;
return PTR_ERR(dmic->regmap);
}
regcache_cache_only(dmic->regmap, true);

31
sound/soc/tegra-alt/tegra210_i2s_alt.c
View File

@@ -1059,7 +1059,7 @@ static int tegra210_i2s_platform_probe(struct platform_device *pdev)
const struct of_device_id *match;
struct device_node *np = pdev->dev.of_node;
struct tegra210_i2s *i2s;
struct resource *mem, *memregion;
struct resource *mem;
struct property *prop;
void __iomem *regs;
int ret = 0, count = 0, num_supplies;
@@ -1111,36 +1111,17 @@ static int tegra210_i2s_platform_probe(struct platform_device *pdev)
goto err;
}
}
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
i2s->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_i2s_regmap_config);
if (IS_ERR(i2s->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(i2s->regmap);
goto err;
return PTR_ERR(i2s->regmap);
}
regcache_cache_only(i2s->regmap, true);
if (of_property_read_u32(np, "nvidia,ahub-i2s-id",

29
sound/soc/tegra-alt/tegra210_iqc_alt.c
View File

@@ -292,7 +292,7 @@ static const struct of_device_id tegra210_iqc_of_match[] = {
static int tegra210_iqc_platform_probe(struct platform_device *pdev)
{
struct tegra210_iqc *iqc;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -323,33 +323,14 @@ static int tegra210_iqc_platform_probe(struct platform_device *pdev)
}
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
iqc->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_iqc_regmap_config);
if (IS_ERR(iqc->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(iqc->regmap);
goto err;
return PTR_ERR(iqc->regmap);
}
regcache_cache_only(iqc->regmap, true);

39
sound/soc/tegra-alt/tegra210_mbdrc_alt.c
View File

@@ -1,7 +1,7 @@
/*
* tegra210_mbdrc_alt.c - Tegra210 MBDRC driver
*
* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved.
* Copyright (c) 2014-2019, NVIDIA CORPORATION. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
@@ -837,43 +837,22 @@ EXPORT_SYMBOL_GPL(tegra210_mbdrc_codec_init);
int tegra210_mbdrc_init(struct platform_device *pdev, int id)
{
struct tegra210_ope *ope = dev_get_drvdata(&pdev->dev);
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
mem = platform_get_resource(pdev, IORESOURCE_MEM, id);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
ope->mbdrc_regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_mbdrc_regmap_config);
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
ope->mbdrc_regmap =
devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_mbdrc_regmap_config);
if (IS_ERR(ope->mbdrc_regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(ope->mbdrc_regmap);
goto err;
return PTR_ERR(ope->mbdrc_regmap);
}
return 0;
err:
return ret;
}
EXPORT_SYMBOL_GPL(tegra210_mbdrc_init);

31
sound/soc/tegra-alt/tegra210_mixer_alt.c
View File

@@ -680,7 +680,7 @@ static const struct of_device_id tegra210_mixer_of_match[] = {
static int tegra210_mixer_platform_probe(struct platform_device *pdev)
{
struct tegra210_mixer *mixer;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret, i;
const struct of_device_id *match;
@@ -721,33 +721,14 @@ static int tegra210_mixer_platform_probe(struct platform_device *pdev)
mixer->gain_value[i] = 0x10000;
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), DRV_NAME);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
mixer->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_mixer_regmap_config);
&tegra210_mixer_regmap_config);
if (IS_ERR(mixer->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(mixer->regmap);
goto err;
return PTR_ERR(mixer->regmap);
}
regcache_cache_only(mixer->regmap, true);

29
sound/soc/tegra-alt/tegra210_mvc_alt.c
View File

@@ -619,7 +619,7 @@ static const struct of_device_id tegra210_mvc_of_match[] = {
static int tegra210_mvc_platform_probe(struct platform_device *pdev)
{
struct tegra210_mvc *mvc;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -658,33 +658,14 @@ static int tegra210_mvc_platform_probe(struct platform_device *pdev)
mvc->volume = TEGRA210_MVC_INIT_VOL_DEFAULT_LINEAR;
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
mvc->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_mvc_regmap_config);
if (IS_ERR(mvc->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(mvc->regmap);
goto err;
return PTR_ERR(mvc->regmap);
}
regcache_cache_only(mvc->regmap, true);

29
sound/soc/tegra-alt/tegra210_ope_alt.c
View File

@@ -316,7 +316,7 @@ static const struct of_device_id tegra210_ope_of_match[] = {
static int tegra210_ope_platform_probe(struct platform_device *pdev)
{
struct tegra210_ope *ope;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -340,33 +340,14 @@ static int tegra210_ope_platform_probe(struct platform_device *pdev)
ope->is_shutdown = false;
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
ope->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_ope_regmap_config);
if (IS_ERR(ope->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(ope->regmap);
goto err;
return PTR_ERR(ope->regmap);
}
regcache_cache_only(ope->regmap, true);

36
sound/soc/tegra-alt/tegra210_peq_alt.c
View File

@@ -1,7 +1,7 @@
/*
* tegra210_peq_alt.c - Tegra210 PEQ driver
*
* Copyright (c) 2014-2018, NVIDIA CORPORATION. All rights reserved.
* Copyright (c) 2014-2019, NVIDIA CORPORATION. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
@@ -370,43 +370,21 @@ EXPORT_SYMBOL_GPL(tegra210_peq_codec_init);
int tegra210_peq_init(struct platform_device *pdev, int id)
{
struct tegra210_ope *ope = dev_get_drvdata(&pdev->dev);
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
mem = platform_get_resource(pdev, IORESOURCE_MEM, id);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
ope->peq_regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_peq_regmap_config);
&tegra210_peq_regmap_config);
if (IS_ERR(ope->peq_regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(ope->peq_regmap);
goto err;
return PTR_ERR(ope->peq_regmap);
}
return 0;
err:
return ret;
}
EXPORT_SYMBOL_GPL(tegra210_peq_init);

29
sound/soc/tegra-alt/tegra210_sfc_alt.c
View File

@@ -3547,7 +3547,7 @@ static const struct of_device_id tegra210_sfc_of_match[] = {
static int tegra210_sfc_platform_probe(struct platform_device *pdev)
{
struct tegra210_sfc *sfc;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
int ret = 0;
const struct of_device_id *match;
@@ -3574,33 +3574,14 @@ static int tegra210_sfc_platform_probe(struct platform_device *pdev)
dev_set_drvdata(&pdev->dev, sfc);
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), pdev->name);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
sfc->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_sfc_regmap_config);
if (IS_ERR(sfc->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(sfc->regmap);
goto err;
return PTR_ERR(sfc->regmap);
}
regcache_cache_only(sfc->regmap, true);

31
sound/soc/tegra-alt/tegra210_spdif_alt.c
View File

@@ -415,7 +415,7 @@ static int tegra210_spdif_platform_probe(struct platform_device *pdev)
{
struct tegra210_spdif *spdif;
struct device_node *np = pdev->dev.of_node;
struct resource *mem, *memregion;
struct resource *mem;
void __iomem *regs;
const struct of_device_id *match;
const char *prod_name;
@@ -470,33 +470,14 @@ static int tegra210_spdif_platform_probe(struct platform_device *pdev)
}
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "No memory resource\n");
ret = -ENODEV;
goto err;
}
memregion = devm_request_mem_region(&pdev->dev, mem->start,
resource_size(mem), DRV_NAME);
if (!memregion) {
dev_err(&pdev->dev, "Memory region already claimed\n");
ret = -EBUSY;
goto err;
}
regs = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
if (!regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, mem);
if (IS_ERR(regs))
return PTR_ERR(regs);
spdif->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
&tegra210_spdif_regmap_config);
&tegra210_spdif_regmap_config);
if (IS_ERR(spdif->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(spdif->regmap);
goto err;
return PTR_ERR(spdif->regmap);
}
regcache_cache_only(spdif->regmap, true);

19
sound/soc/tegra-alt/utils/tegra210_xbar_utils_alt.c
View File

@@ -377,25 +377,14 @@ int tegra_xbar_probe(struct platform_device *pdev,
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "No memory resource for admaif\n");
ret = -ENODEV;
goto err;
}
regs = devm_ioremap_resource(&pdev->dev, res);
if (!regs) {
dev_err(&pdev->dev, "request/iomap region failed\n");
ret = -ENODEV;
goto err_clk_set_parent;
}
if (IS_ERR(regs))
return PTR_ERR(regs);
xbar->regmap = devm_regmap_init_mmio(&pdev->dev, regs,
soc_data->regmap_config);
if (IS_ERR(xbar->regmap)) {
dev_err(&pdev->dev, "regmap init failed\n");
ret = PTR_ERR(xbar->regmap);
goto err_clk_set_parent;
return PTR_ERR(xbar->regmap);
}
regcache_cache_only(xbar->regmap, true);
@@ -420,8 +409,6 @@ err_suspend:
err_pm_disable:
pm_runtime_disable(&pdev->dev);
tegra_pd_remove_device(&pdev->dev);
err_clk_set_parent:
clk_set_parent(xbar->clk, parent_clk);
err:
return ret;
}