Quelle  spi-pxa2xx-platform.c   Sprache: 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 = 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");