mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-15 16:24:13 +08:00
e17465f78e
PCI and platform buses have different defaults for runtime PM. In particular PCI probe is assumed to be called when PM runtime is enabled by the PCI core. In this case if we try enable it again the PM runtime complaints with pxa2xx_spi_pci 0000:00:07.0: Unbalanced pm_runtime_enable! Fix this by moving PM runtime handling from the SPI PXA2xx core to the glue drivers. Fixes:cc160697a5
("spi: pxa2xx: Convert PCI driver to use spi-pxa2xx code directly") Fixes:3d8f037fbc
("spi: pxa2xx: Move platform driver to a separate file") Fixes:20ade9b977
("spi: pxa2xx: Extract pxa2xx_spi_platform_*() callbacks") Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com> Link: https://patch.msgid.link/20240822113408.750831-3-andriy.shevchenko@linux.intel.com Signed-off-by: Mark Brown <broonie@kernel.org>
231 lines
5.2 KiB
C
231 lines
5.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include <linux/acpi.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/init.h>
|
|
#include <linux/mod_devicetable.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include <linux/property.h>
|
|
#include <linux/types.h>
|
|
|
|
#include "spi-pxa2xx.h"
|
|
|
|
static bool pxa2xx_spi_idma_filter(struct dma_chan *chan, void *param)
|
|
{
|
|
return param == chan->device->dev;
|
|
}
|
|
|
|
static int
|
|
pxa2xx_spi_init_ssp(struct platform_device *pdev, struct ssp_device *ssp, enum pxa_ssp_type type)
|
|
{
|
|
struct device *dev = &pdev->dev;
|
|
struct resource *res;
|
|
int status;
|
|
u64 uid;
|
|
|
|
ssp->mmio_base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
|
|
if (IS_ERR(ssp->mmio_base))
|
|
return PTR_ERR(ssp->mmio_base);
|
|
|
|
ssp->phys_base = res->start;
|
|
|
|
ssp->clk = devm_clk_get(dev, NULL);
|
|
if (IS_ERR(ssp->clk))
|
|
return PTR_ERR(ssp->clk);
|
|
|
|
ssp->irq = platform_get_irq(pdev, 0);
|
|
if (ssp->irq < 0)
|
|
return ssp->irq;
|
|
|
|
ssp->type = type;
|
|
ssp->dev = dev;
|
|
|
|
status = acpi_dev_uid_to_integer(ACPI_COMPANION(dev), &uid);
|
|
if (status)
|
|
ssp->port_id = -1;
|
|
else
|
|
ssp->port_id = uid;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void pxa2xx_spi_ssp_release(void *ssp)
|
|
{
|
|
pxa_ssp_free(ssp);
|
|
}
|
|
|
|
static struct ssp_device *pxa2xx_spi_ssp_request(struct platform_device *pdev)
|
|
{
|
|
struct ssp_device *ssp;
|
|
int status;
|
|
|
|
ssp = pxa_ssp_request(pdev->id, pdev->name);
|
|
if (!ssp)
|
|
return NULL;
|
|
|
|
status = devm_add_action_or_reset(&pdev->dev, pxa2xx_spi_ssp_release, ssp);
|
|
if (status)
|
|
return ERR_PTR(status);
|
|
|
|
return ssp;
|
|
}
|
|
|
|
static struct pxa2xx_spi_controller *
|
|
pxa2xx_spi_init_pdata(struct platform_device *pdev)
|
|
{
|
|
struct pxa2xx_spi_controller *pdata;
|
|
struct device *dev = &pdev->dev;
|
|
struct device *parent = dev->parent;
|
|
const void *match = device_get_match_data(dev);
|
|
enum pxa_ssp_type type = SSP_UNDEFINED;
|
|
struct ssp_device *ssp;
|
|
bool is_lpss_priv;
|
|
u32 num_cs = 1;
|
|
int status;
|
|
|
|
ssp = pxa2xx_spi_ssp_request(pdev);
|
|
if (IS_ERR(ssp))
|
|
return ERR_CAST(ssp);
|
|
if (ssp) {
|
|
type = ssp->type;
|
|
} else if (match) {
|
|
type = (enum pxa_ssp_type)(uintptr_t)match;
|
|
} else {
|
|
u32 value;
|
|
|
|
status = device_property_read_u32(dev, "intel,spi-pxa2xx-type", &value);
|
|
if (status)
|
|
return ERR_PTR(status);
|
|
|
|
type = (enum pxa_ssp_type)value;
|
|
}
|
|
|
|
/* Validate the SSP type correctness */
|
|
if (!(type > SSP_UNDEFINED && type < SSP_MAX))
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
|
|
if (!pdata)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
/* Platforms with iDMA 64-bit */
|
|
is_lpss_priv = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lpss_priv");
|
|
if (is_lpss_priv) {
|
|
pdata->tx_param = parent;
|
|
pdata->rx_param = parent;
|
|
pdata->dma_filter = pxa2xx_spi_idma_filter;
|
|
}
|
|
|
|
/* Read number of chip select pins, if provided */
|
|
device_property_read_u32(dev, "num-cs", &num_cs);
|
|
|
|
pdata->num_chipselect = num_cs;
|
|
pdata->is_target = device_property_read_bool(dev, "spi-slave");
|
|
pdata->enable_dma = true;
|
|
pdata->dma_burst_size = 1;
|
|
|
|
/* If SSP has been already enumerated, use it */
|
|
if (ssp)
|
|
return pdata;
|
|
|
|
status = pxa2xx_spi_init_ssp(pdev, &pdata->ssp, type);
|
|
if (status)
|
|
return ERR_PTR(status);
|
|
|
|
return pdata;
|
|
}
|
|
|
|
static int pxa2xx_spi_platform_probe(struct platform_device *pdev)
|
|
{
|
|
struct pxa2xx_spi_controller *platform_info;
|
|
struct device *dev = &pdev->dev;
|
|
struct ssp_device *ssp;
|
|
int ret;
|
|
|
|
platform_info = dev_get_platdata(dev);
|
|
if (!platform_info) {
|
|
platform_info = pxa2xx_spi_init_pdata(pdev);
|
|
if (IS_ERR(platform_info))
|
|
return dev_err_probe(dev, PTR_ERR(platform_info), "missing platform data\n");
|
|
}
|
|
|
|
ssp = pxa2xx_spi_ssp_request(pdev);
|
|
if (IS_ERR(ssp))
|
|
return PTR_ERR(ssp);
|
|
if (!ssp)
|
|
ssp = &platform_info->ssp;
|
|
|
|
pm_runtime_set_autosuspend_delay(dev, 50);
|
|
pm_runtime_use_autosuspend(dev);
|
|
pm_runtime_set_active(dev);
|
|
pm_runtime_enable(dev);
|
|
|
|
ret = pxa2xx_spi_probe(dev, ssp, platform_info);
|
|
if (ret)
|
|
pm_runtime_disable(dev);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void pxa2xx_spi_platform_remove(struct platform_device *pdev)
|
|
{
|
|
struct device *dev = &pdev->dev;
|
|
|
|
pm_runtime_get_sync(dev);
|
|
|
|
pxa2xx_spi_remove(dev);
|
|
|
|
pm_runtime_put_noidle(dev);
|
|
pm_runtime_disable(dev);
|
|
}
|
|
|
|
static const struct acpi_device_id pxa2xx_spi_acpi_match[] = {
|
|
{ "80860F0E" },
|
|
{ "8086228E" },
|
|
{ "INT33C0" },
|
|
{ "INT33C1" },
|
|
{ "INT3430" },
|
|
{ "INT3431" },
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(acpi, pxa2xx_spi_acpi_match);
|
|
|
|
static const struct of_device_id pxa2xx_spi_of_match[] = {
|
|
{ .compatible = "marvell,mmp2-ssp", .data = (void *)MMP2_SSP },
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(of, pxa2xx_spi_of_match);
|
|
|
|
static struct platform_driver driver = {
|
|
.driver = {
|
|
.name = "pxa2xx-spi",
|
|
.pm = pm_ptr(&pxa2xx_spi_pm_ops),
|
|
.acpi_match_table = pxa2xx_spi_acpi_match,
|
|
.of_match_table = pxa2xx_spi_of_match,
|
|
},
|
|
.probe = pxa2xx_spi_platform_probe,
|
|
.remove_new = pxa2xx_spi_platform_remove,
|
|
};
|
|
|
|
static int __init pxa2xx_spi_init(void)
|
|
{
|
|
return platform_driver_register(&driver);
|
|
}
|
|
subsys_initcall(pxa2xx_spi_init);
|
|
|
|
static void __exit pxa2xx_spi_exit(void)
|
|
{
|
|
platform_driver_unregister(&driver);
|
|
}
|
|
module_exit(pxa2xx_spi_exit);
|
|
|
|
MODULE_AUTHOR("Stephen Street");
|
|
MODULE_DESCRIPTION("PXA2xx SSP SPI Controller platform driver");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_IMPORT_NS(SPI_PXA2xx);
|
|
MODULE_ALIAS("platform:pxa2xx-spi");
|
|
MODULE_SOFTDEP("pre: dw_dmac");
|