Unverified Commit 3d8f037f authored by Andy Shevchenko's avatar Andy Shevchenko Committed by Mark Brown
Browse files

spi: pxa2xx: Move platform driver to a separate file 



The spi-pxa2xx.c is bloated with a platform driver code while
pretending to provide a core functionality. Make it real core
library by splitting out the platform driver to a separate file.

Signed-off-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>
Link: https://msgid.link/r/20240530151117.1130792-11-andriy.shevchenko@linux.intel.com


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 20ade9b9

drivers/spi/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -107,7 +107,8 @@ obj-$(CONFIG_SPI_PIC32) += spi-pic32.o 
obj-$(CONFIG_SPI_PIC32_SQI)		+= spi-pic32-sqi.o

obj-$(CONFIG_SPI_PL022)			+= spi-pl022.o

obj-$(CONFIG_SPI_PPC4xx)		+= spi-ppc4xx.o

spi-pxa2xx-platform-objs		:= spi-pxa2xx.o spi-pxa2xx-dma.o

obj-$(CONFIG_SPI_PXA2XX)		+= spi-pxa2xx-core.o

spi-pxa2xx-core-y			:= spi-pxa2xx.o spi-pxa2xx-dma.o

obj-$(CONFIG_SPI_PXA2XX)		+= spi-pxa2xx-platform.o

obj-$(CONFIG_SPI_PXA2XX_PCI)		+= spi-pxa2xx-pci.o

obj-$(CONFIG_SPI_QCOM_GENI)		+= spi-geni-qcom.o

drivers/spi/spi-pxa2xx-platform.c

0 → 100644
+214 −0
Original line number Diff line number Diff line 
// 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/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 ssp;



	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;



	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");



		dev->platform_data = platform_info;

	}



	ssp = pxa2xx_spi_ssp_request(pdev);

	if (IS_ERR(ssp))

		return PTR_ERR(ssp);

	if (!ssp)

		ssp = &platform_info->ssp;



	return pxa2xx_spi_probe(dev, ssp);

}



static void pxa2xx_spi_platform_remove(struct platform_device *pdev)

{

	pxa2xx_spi_remove(&pdev->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");

drivers/spi/spi-pxa2xx.c

+8 −207
Original line number Diff line number Diff line
@@ -4,7 +4,6 @@ 
 * Copyright (C) 2013, 2021 Intel Corporation

 */



#include <linux/acpi.h>

#include <linux/atomic.h>

#include <linux/bitops.h>

#include <linux/bug.h>
@@ -14,15 +13,12 @@ 
#include <linux/dmaengine.h>

#include <linux/err.h>

#include <linux/gpio/consumer.h>

#include <linux/init.h>

#include <linux/interrupt.h>

#include <linux/io.h>

#include <linux/ioport.h>

#include <linux/math64.h>

#include <linux/minmax.h>

#include <linux/mod_devicetable.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/pm_runtime.h>

#include <linux/property.h>

#include <linux/slab.h>
@@ -32,11 +28,6 @@ 


#include "spi-pxa2xx.h"



MODULE_AUTHOR("Stephen Street");

MODULE_DESCRIPTION("PXA2xx SSP SPI Controller");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:pxa2xx-spi");



#define TIMOUT_DFLT		1000



/*
@@ -1263,131 +1254,6 @@ static void cleanup(struct spi_device *spi) 
	kfree(chip);

}



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 ssp;



	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_fw_translate_cs(struct spi_controller *controller,

				      unsigned int cs)

{
@@ -1413,7 +1279,7 @@ static size_t pxa2xx_spi_max_dma_transfer_size(struct spi_device *spi) 
	return MAX_DMA_LEN;

}



static int pxa2xx_spi_probe(struct device *dev, struct ssp_device *ssp)

int pxa2xx_spi_probe(struct device *dev, struct ssp_device *ssp)

{

	struct pxa2xx_spi_controller *platform_info;

	struct spi_controller *controller;
@@ -1613,8 +1479,9 @@ static int pxa2xx_spi_probe(struct device *dev, struct ssp_device *ssp) 


	return status;

}

EXPORT_SYMBOL_NS_GPL(pxa2xx_spi_probe, SPI_PXA2xx);



static void pxa2xx_spi_remove(struct device *dev)

void pxa2xx_spi_remove(struct device *dev)

{

	struct driver_data *drv_data = dev_get_drvdata(dev);

	struct ssp_device *ssp = drv_data->ssp;
@@ -1637,6 +1504,7 @@ static void pxa2xx_spi_remove(struct device *dev) 
	/* Release IRQ */

	free_irq(ssp->irq, drv_data);

}

EXPORT_SYMBOL_NS_GPL(pxa2xx_spi_remove, SPI_PXA2xx);



static int pxa2xx_spi_suspend(struct device *dev)

{
@@ -1688,78 +1556,11 @@ static int pxa2xx_spi_runtime_resume(struct device *dev) 
	return clk_prepare_enable(drv_data->ssp->clk);

}



static const struct dev_pm_ops pxa2xx_spi_pm_ops = {

EXPORT_NS_GPL_DEV_PM_OPS(pxa2xx_spi_pm_ops, SPI_PXA2xx) = {

	SYSTEM_SLEEP_PM_OPS(pxa2xx_spi_suspend, pxa2xx_spi_resume)

	RUNTIME_PM_OPS(pxa2xx_spi_runtime_suspend, pxa2xx_spi_runtime_resume, NULL)

};



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;



	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");



		dev->platform_data = platform_info;

	}



	ssp = pxa2xx_spi_ssp_request(pdev);

	if (IS_ERR(ssp))

		return PTR_ERR(ssp);

	if (!ssp)

		ssp = &platform_info->ssp;



	return pxa2xx_spi_probe(dev, ssp);

}



static void pxa2xx_spi_platform_remove(struct platform_device *pdev)

{

	pxa2xx_spi_remove(&pdev->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_SOFTDEP("pre: dw_dmac");
 
MODULE_AUTHOR("Stephen Street");

MODULE_DESCRIPTION("PXA2xx SSP SPI Controller core driver");

MODULE_LICENSE("GPL");

drivers/spi/spi-pxa2xx.h

+6 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 


#include <linux/pxa2xx_ssp.h>



struct device;

struct gpio_desc;



/*
@@ -131,4 +132,9 @@ extern void pxa2xx_spi_dma_stop(struct driver_data *drv_data); 
extern int pxa2xx_spi_dma_setup(struct driver_data *drv_data);

extern void pxa2xx_spi_dma_release(struct driver_data *drv_data);



int pxa2xx_spi_probe(struct device *dev, struct ssp_device *ssp);

void pxa2xx_spi_remove(struct device *dev);



extern const struct dev_pm_ops pxa2xx_spi_pm_ops;



#endif /* SPI_PXA2XX_H */