Unverified Commit fffae3af authored by Mark Brown's avatar Mark Brown
Browse files

spi: switch to use modern name (part3) 

Merge series from Yang Yingliang <yangyingliang@huawei.com>:

I'm trying to rename the legacy name to modern name used in SPI drivers,
this is part3 patchset.

After introducing devm_spi_alloc_host/spi_alloc_host(), the legacy
named function devm_spi_alloc_master/spi_alloc_master() can be replaced.
And also change other legacy name master/slave to modern name host/target
or controller. Each patch compile test passed.
parents 7a4feff7 ee0f793c

drivers/spi/spi-lm70llp.c

+10 −10
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 
 * the SPI/Microwire bus interface. This driver specifically supports an

 * NS LM70 LLP Evaluation Board, interfacing to a PC using its parallel

 * port to bitbang an SPI-parport bridge.  Accordingly, this is an SPI

 * master controller driver.  The hwmon/lm70 driver is a "SPI protocol

 * host controller driver.  The hwmon/lm70 driver is a "SPI protocol

 * driver", layered on top of this one and usable without the lm70llp.

 *

 * Datasheet and Schematic:
@@ -189,7 +189,7 @@ static void spi_lm70llp_attach(struct parport *p) 
{

	struct pardevice	*pd;

	struct spi_lm70llp	*pp;

	struct spi_master	*master;

	struct spi_controller	*host;

	int			status;

	struct pardev_cb	lm70llp_cb;
@@ -202,17 +202,17 @@ static void spi_lm70llp_attach(struct parport *p) 
	 * the lm70 driver could verify it, reading the manf ID.

	 */



	master = spi_alloc_master(p->physport->dev, sizeof(*pp));

	if (!master) {

	host = spi_alloc_host(p->physport->dev, sizeof(*pp));

	if (!host) {

		status = -ENOMEM;

		goto out_fail;

	}

	pp = spi_master_get_devdata(master);

	pp = spi_controller_get_devdata(host);



	/*

	 * SPI and bitbang hookup.

	 */

	pp->bitbang.master = master;

	pp->bitbang.master = host;

	pp->bitbang.chipselect = lm70_chipselect;

	pp->bitbang.txrx_word[SPI_MODE_0] = lm70_txrx;

	pp->bitbang.flags = SPI_3WIRE;
@@ -228,7 +228,7 @@ static void spi_lm70llp_attach(struct parport *p) 


	if (!pd) {

		status = -ENOMEM;

		goto out_free_master;

		goto out_free_host;

	}

	pp->pd = pd;
@@ -287,8 +287,8 @@ static void spi_lm70llp_attach(struct parport *p) 
	parport_release(pp->pd);

out_parport_unreg:

	parport_unregister_device(pd);

out_free_master:

	spi_master_put(master);

out_free_host:

	spi_controller_put(host);

out_fail:

	pr_info("spi_lm70llp probe fail, status %d\n", status);

}
@@ -309,7 +309,7 @@ static void spi_lm70llp_detach(struct parport *p) 
	parport_release(pp->pd);

	parport_unregister_device(pp->pd);



	spi_master_put(pp->bitbang.master);

	spi_controller_put(pp->bitbang.master);



	lm70llp = NULL;

}

drivers/spi/spi-lp8841-rtc.c

+28 −28
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * SPI master driver for ICP DAS LP-8841 RTC

 * SPI host driver for ICP DAS LP-8841 RTC

 *

 * Copyright (C) 2016 Sergei Ianovich

 *
@@ -73,13 +73,13 @@ bitbang_txrx_be_cpha0_lsb(struct spi_lp8841_rtc *data, 
	/* clock starts at inactive polarity */

	for (; likely(bits); bits--) {



		/* setup LSB (to slave) on leading edge */

		/* setup LSB (to target) on leading edge */

		if ((flags & SPI_CONTROLLER_NO_TX) == 0)

			setmosi(data, (word & 1));



		usleep_range(usecs, usecs + 1);	/* T(setup) */



		/* sample LSB (from slave) on trailing edge */

		/* sample LSB (from target) on trailing edge */

		word >>= 1;

		if ((flags & SPI_CONTROLLER_NO_RX) == 0)

			word |= (getmiso(data) << 31);
@@ -95,11 +95,11 @@ bitbang_txrx_be_cpha0_lsb(struct spi_lp8841_rtc *data, 
}



static int

spi_lp8841_rtc_transfer_one(struct spi_master *master,

spi_lp8841_rtc_transfer_one(struct spi_controller *host,

			    struct spi_device *spi,

			    struct spi_transfer *t)

{

	struct spi_lp8841_rtc	*data = spi_master_get_devdata(master);

	struct spi_lp8841_rtc	*data = spi_controller_get_devdata(host);

	unsigned		count = t->len;

	const u8		*tx = t->tx_buf;

	u8			*rx = t->rx_buf;
@@ -128,7 +128,7 @@ spi_lp8841_rtc_transfer_one(struct spi_master *master, 
		ret = -EINVAL;

	}



	spi_finalize_current_transfer(master);

	spi_finalize_current_transfer(host);



	return ret;

}
@@ -136,7 +136,7 @@ spi_lp8841_rtc_transfer_one(struct spi_master *master, 
static void

spi_lp8841_rtc_set_cs(struct spi_device *spi, bool enable)

{

	struct spi_lp8841_rtc *data = spi_master_get_devdata(spi->master);

	struct spi_lp8841_rtc *data = spi_controller_get_devdata(spi->controller);



	data->state = 0;

	writeb(data->state, data->iomem);
@@ -182,48 +182,48 @@ static int 
spi_lp8841_rtc_probe(struct platform_device *pdev)

{

	int				ret;

	struct spi_master		*master;

	struct spi_controller		*host;

	struct spi_lp8841_rtc		*data;



	master = spi_alloc_master(&pdev->dev, sizeof(*data));

	if (!master)

	host = spi_alloc_host(&pdev->dev, sizeof(*data));

	if (!host)

		return -ENOMEM;

	platform_set_drvdata(pdev, master);

	platform_set_drvdata(pdev, host);



	master->flags = SPI_CONTROLLER_HALF_DUPLEX;

	master->mode_bits = SPI_CS_HIGH | SPI_3WIRE | SPI_LSB_FIRST;

	host->flags = SPI_CONTROLLER_HALF_DUPLEX;

	host->mode_bits = SPI_CS_HIGH | SPI_3WIRE | SPI_LSB_FIRST;



	master->bus_num = pdev->id;

	master->num_chipselect = 1;

	master->setup = spi_lp8841_rtc_setup;

	master->set_cs = spi_lp8841_rtc_set_cs;

	master->transfer_one = spi_lp8841_rtc_transfer_one;

	master->bits_per_word_mask = SPI_BPW_MASK(8);

	host->bus_num = pdev->id;

	host->num_chipselect = 1;

	host->setup = spi_lp8841_rtc_setup;

	host->set_cs = spi_lp8841_rtc_set_cs;

	host->transfer_one = spi_lp8841_rtc_transfer_one;

	host->bits_per_word_mask = SPI_BPW_MASK(8);

#ifdef CONFIG_OF

	master->dev.of_node = pdev->dev.of_node;

	host->dev.of_node = pdev->dev.of_node;

#endif



	data = spi_master_get_devdata(master);

	data = spi_controller_get_devdata(host);



	data->iomem = devm_platform_ioremap_resource(pdev, 0);

	ret = PTR_ERR_OR_ZERO(data->iomem);

	if (ret) {

		dev_err(&pdev->dev, "failed to get IO address\n");

		goto err_put_master;

		goto err_put_host;

	}



	/* register with the SPI framework */

	ret = devm_spi_register_master(&pdev->dev, master);

	ret = devm_spi_register_controller(&pdev->dev, host);

	if (ret) {

		dev_err(&pdev->dev, "cannot register spi master\n");

		goto err_put_master;

		dev_err(&pdev->dev, "cannot register spi host\n");

		goto err_put_host;

	}



	return ret;





err_put_master:

	spi_master_put(master);

err_put_host:

	spi_controller_put(host);



	return ret;

}
@@ -239,6 +239,6 @@ static struct platform_driver spi_lp8841_rtc_driver = { 
};

module_platform_driver(spi_lp8841_rtc_driver);



MODULE_DESCRIPTION("SPI master driver for ICP DAS LP-8841 RTC");

MODULE_DESCRIPTION("SPI host driver for ICP DAS LP-8841 RTC");

MODULE_AUTHOR("Sergei Ianovich");

MODULE_LICENSE("GPL");

drivers/spi/spi-meson-spicc.c

+45 −45
Original line number Diff line number Diff line
@@ -151,7 +151,7 @@ struct meson_spicc_data { 
};



struct meson_spicc_device {

	struct spi_master		*master;

	struct spi_controller		*host;

	struct platform_device		*pdev;

	void __iomem			*base;

	struct clk			*core;
@@ -399,11 +399,11 @@ static void meson_spicc_reset_fifo(struct meson_spicc_device *spicc) 
				    spicc->base + SPICC_ENH_CTL0);

}



static int meson_spicc_transfer_one(struct spi_master *master,

static int meson_spicc_transfer_one(struct spi_controller *host,

				    struct spi_device *spi,

				    struct spi_transfer *xfer)

{

	struct meson_spicc_device *spicc = spi_master_get_devdata(master);

	struct meson_spicc_device *spicc = spi_controller_get_devdata(host);

	uint64_t timeout;



	/* Store current transfer */
@@ -454,10 +454,10 @@ static int meson_spicc_transfer_one(struct spi_master *master, 
	return 0;

}



static int meson_spicc_prepare_message(struct spi_master *master,

static int meson_spicc_prepare_message(struct spi_controller *host,

				       struct spi_message *message)

{

	struct meson_spicc_device *spicc = spi_master_get_devdata(master);

	struct meson_spicc_device *spicc = spi_controller_get_devdata(host);

	struct spi_device *spi = message->spi;

	u32 conf = readl_relaxed(spicc->base + SPICC_CONREG) & SPICC_DATARATE_MASK;
@@ -519,9 +519,9 @@ static int meson_spicc_prepare_message(struct spi_master *master, 
	return 0;

}



static int meson_spicc_unprepare_transfer(struct spi_master *master)

static int meson_spicc_unprepare_transfer(struct spi_controller *host)

{

	struct meson_spicc_device *spicc = spi_master_get_devdata(master);

	struct meson_spicc_device *spicc = spi_controller_get_devdata(host);

	u32 conf = readl_relaxed(spicc->base + SPICC_CONREG) & SPICC_DATARATE_MASK;



	/* Disable all IRQs */
@@ -541,7 +541,7 @@ static int meson_spicc_unprepare_transfer(struct spi_master *master) 
static int meson_spicc_setup(struct spi_device *spi)

{

	if (!spi->controller_state)

		spi->controller_state = spi_master_get_devdata(spi->master);

		spi->controller_state = spi_controller_get_devdata(spi->controller);



	return 0;

}
@@ -585,7 +585,7 @@ static unsigned long meson_spicc_pow2_recalc_rate(struct clk_hw *hw, 
	struct clk_divider *divider = to_clk_divider(hw);

	struct meson_spicc_device *spicc = pow2_clk_to_spicc(divider);



	if (!spicc->master->cur_msg)

	if (!spicc->host->cur_msg)

		return 0;



	return clk_divider_ops.recalc_rate(hw, parent_rate);
@@ -597,7 +597,7 @@ static int meson_spicc_pow2_determine_rate(struct clk_hw *hw, 
	struct clk_divider *divider = to_clk_divider(hw);

	struct meson_spicc_device *spicc = pow2_clk_to_spicc(divider);



	if (!spicc->master->cur_msg)

	if (!spicc->host->cur_msg)

		return -EINVAL;



	return clk_divider_ops.determine_rate(hw, req);
@@ -609,7 +609,7 @@ static int meson_spicc_pow2_set_rate(struct clk_hw *hw, unsigned long rate, 
	struct clk_divider *divider = to_clk_divider(hw);

	struct meson_spicc_device *spicc = pow2_clk_to_spicc(divider);



	if (!spicc->master->cur_msg)

	if (!spicc->host->cur_msg)

		return -EINVAL;



	return clk_divider_ops.set_rate(hw, rate, parent_rate);
@@ -769,23 +769,23 @@ static int meson_spicc_enh_clk_init(struct meson_spicc_device *spicc) 


static int meson_spicc_probe(struct platform_device *pdev)

{

	struct spi_master *master;

	struct spi_controller *host;

	struct meson_spicc_device *spicc;

	int ret, irq;



	master = spi_alloc_master(&pdev->dev, sizeof(*spicc));

	if (!master) {

		dev_err(&pdev->dev, "master allocation failed\n");

	host = spi_alloc_host(&pdev->dev, sizeof(*spicc));

	if (!host) {

		dev_err(&pdev->dev, "host allocation failed\n");

		return -ENOMEM;

	}

	spicc = spi_master_get_devdata(master);

	spicc->master = master;

	spicc = spi_controller_get_devdata(host);

	spicc->host = host;



	spicc->data = of_device_get_match_data(&pdev->dev);

	if (!spicc->data) {

		dev_err(&pdev->dev, "failed to get match data\n");

		ret = -EINVAL;

		goto out_master;

		goto out_host;

	}



	spicc->pdev = pdev;
@@ -797,7 +797,7 @@ static int meson_spicc_probe(struct platform_device *pdev) 
	if (IS_ERR(spicc->base)) {

		dev_err(&pdev->dev, "io resource mapping failed\n");

		ret = PTR_ERR(spicc->base);

		goto out_master;

		goto out_host;

	}



	/* Set master mode and enable controller */
@@ -810,21 +810,21 @@ static int meson_spicc_probe(struct platform_device *pdev) 
	irq = platform_get_irq(pdev, 0);

	if (irq < 0) {

		ret = irq;

		goto out_master;

		goto out_host;

	}



	ret = devm_request_irq(&pdev->dev, irq, meson_spicc_irq,

			       0, NULL, spicc);

	if (ret) {

		dev_err(&pdev->dev, "irq request failed\n");

		goto out_master;

		goto out_host;

	}



	spicc->core = devm_clk_get(&pdev->dev, "core");

	if (IS_ERR(spicc->core)) {

		dev_err(&pdev->dev, "core clock request failed\n");

		ret = PTR_ERR(spicc->core);

		goto out_master;

		goto out_host;

	}



	if (spicc->data->has_pclk) {
@@ -832,14 +832,14 @@ static int meson_spicc_probe(struct platform_device *pdev) 
		if (IS_ERR(spicc->pclk)) {

			dev_err(&pdev->dev, "pclk clock request failed\n");

			ret = PTR_ERR(spicc->pclk);

			goto out_master;

			goto out_host;

		}

	}



	ret = clk_prepare_enable(spicc->core);

	if (ret) {

		dev_err(&pdev->dev, "core clock enable failed\n");

		goto out_master;

		goto out_host;

	}



	ret = clk_prepare_enable(spicc->pclk);
@@ -856,22 +856,22 @@ static int meson_spicc_probe(struct platform_device *pdev) 


	device_reset_optional(&pdev->dev);



	master->num_chipselect = 4;

	master->dev.of_node = pdev->dev.of_node;

	master->mode_bits = SPI_CPHA | SPI_CPOL | SPI_CS_HIGH;

	master->bits_per_word_mask = SPI_BPW_MASK(32) |

	host->num_chipselect = 4;

	host->dev.of_node = pdev->dev.of_node;

	host->mode_bits = SPI_CPHA | SPI_CPOL | SPI_CS_HIGH;

	host->bits_per_word_mask = SPI_BPW_MASK(32) |

				   SPI_BPW_MASK(24) |

				   SPI_BPW_MASK(16) |

				   SPI_BPW_MASK(8);

	master->flags = (SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX);

	master->min_speed_hz = spicc->data->min_speed_hz;

	master->max_speed_hz = spicc->data->max_speed_hz;

	master->setup = meson_spicc_setup;

	master->cleanup = meson_spicc_cleanup;

	master->prepare_message = meson_spicc_prepare_message;

	master->unprepare_transfer_hardware = meson_spicc_unprepare_transfer;

	master->transfer_one = meson_spicc_transfer_one;

	master->use_gpio_descriptors = true;

	host->flags = (SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX);

	host->min_speed_hz = spicc->data->min_speed_hz;

	host->max_speed_hz = spicc->data->max_speed_hz;

	host->setup = meson_spicc_setup;

	host->cleanup = meson_spicc_cleanup;

	host->prepare_message = meson_spicc_prepare_message;

	host->unprepare_transfer_hardware = meson_spicc_unprepare_transfer;

	host->transfer_one = meson_spicc_transfer_one;

	host->use_gpio_descriptors = true;



	meson_spicc_oen_enable(spicc);
@@ -889,9 +889,9 @@ static int meson_spicc_probe(struct platform_device *pdev) 
		}

	}



	ret = devm_spi_register_master(&pdev->dev, master);

	ret = devm_spi_register_controller(&pdev->dev, host);

	if (ret) {

		dev_err(&pdev->dev, "spi master registration failed\n");

		dev_err(&pdev->dev, "spi host registration failed\n");

		goto out_clk;

	}
@@ -903,8 +903,8 @@ static int meson_spicc_probe(struct platform_device *pdev) 
out_core_clk:

	clk_disable_unprepare(spicc->core);



out_master:

	spi_master_put(master);

out_host:

	spi_controller_put(host);



	return ret;

}
@@ -919,7 +919,7 @@ static void meson_spicc_remove(struct platform_device *pdev) 
	clk_disable_unprepare(spicc->core);

	clk_disable_unprepare(spicc->pclk);



	spi_master_put(spicc->master);

	spi_controller_put(spicc->host);

}



static const struct meson_spicc_data meson_spicc_gx_data = {

drivers/spi/spi-meson-spifc.c

+33 −33
Original line number Diff line number Diff line
@@ -67,13 +67,13 @@ 


/**

 * struct meson_spifc

 * @master:	the SPI master

 * @host:	the SPI host

 * @regmap:	regmap for device registers

 * @clk:	input clock of the built-in baud rate generator

 * @dev:	the device structure

 */

struct meson_spifc {

	struct spi_master *master;

	struct spi_controller *host;

	struct regmap *regmap;

	struct clk *clk;

	struct device *dev;
@@ -237,16 +237,16 @@ static int meson_spifc_txrx(struct meson_spifc *spifc, 


/**

 * meson_spifc_transfer_one() - perform a single transfer

 * @master:	the SPI master

 * @host:	the SPI host

 * @spi:	the SPI device

 * @xfer:	the current SPI transfer

 * Return:	0 on success, a negative value on error

 */

static int meson_spifc_transfer_one(struct spi_master *master,

static int meson_spifc_transfer_one(struct spi_controller *host,

				    struct spi_device *spi,

				    struct spi_transfer *xfer)

{

	struct meson_spifc *spifc = spi_master_get_devdata(master);

	struct meson_spifc *spifc = spi_controller_get_devdata(host);

	int len, done = 0, ret = 0;



	meson_spifc_setup_speed(spifc, xfer->speed_hz);
@@ -256,7 +256,7 @@ static int meson_spifc_transfer_one(struct spi_master *master, 
	while (done < xfer->len && !ret) {

		len = min_t(int, xfer->len - done, SPIFC_BUFFER_SIZE);

		ret = meson_spifc_txrx(spifc, xfer, done, len,

				       spi_transfer_is_last(master, xfer),

				       spi_transfer_is_last(host, xfer),

				       done + len >= xfer->len);

		done += len;

	}
@@ -284,19 +284,19 @@ static void meson_spifc_hw_init(struct meson_spifc *spifc) 


static int meson_spifc_probe(struct platform_device *pdev)

{

	struct spi_master *master;

	struct spi_controller *host;

	struct meson_spifc *spifc;

	void __iomem *base;

	unsigned int rate;

	int ret = 0;



	master = spi_alloc_master(&pdev->dev, sizeof(struct meson_spifc));

	if (!master)

	host = spi_alloc_host(&pdev->dev, sizeof(struct meson_spifc));

	if (!host)

		return -ENOMEM;



	platform_set_drvdata(pdev, master);

	platform_set_drvdata(pdev, host);



	spifc = spi_master_get_devdata(master);

	spifc = spi_controller_get_devdata(host);

	spifc->dev = &pdev->dev;



	base = devm_platform_ioremap_resource(pdev, 0);
@@ -327,22 +327,22 @@ static int meson_spifc_probe(struct platform_device *pdev) 


	rate = clk_get_rate(spifc->clk);



	master->num_chipselect = 1;

	master->dev.of_node = pdev->dev.of_node;

	master->bits_per_word_mask = SPI_BPW_MASK(8);

	master->auto_runtime_pm = true;

	master->transfer_one = meson_spifc_transfer_one;

	master->min_speed_hz = rate >> 6;

	master->max_speed_hz = rate >> 1;

	host->num_chipselect = 1;

	host->dev.of_node = pdev->dev.of_node;

	host->bits_per_word_mask = SPI_BPW_MASK(8);

	host->auto_runtime_pm = true;

	host->transfer_one = meson_spifc_transfer_one;

	host->min_speed_hz = rate >> 6;

	host->max_speed_hz = rate >> 1;



	meson_spifc_hw_init(spifc);



	pm_runtime_set_active(spifc->dev);

	pm_runtime_enable(spifc->dev);



	ret = devm_spi_register_master(spifc->dev, master);

	ret = devm_spi_register_controller(spifc->dev, host);

	if (ret) {

		dev_err(spifc->dev, "failed to register spi master\n");

		dev_err(spifc->dev, "failed to register spi host\n");

		goto out_clk;

	}
@@ -351,14 +351,14 @@ static int meson_spifc_probe(struct platform_device *pdev) 
	clk_disable_unprepare(spifc->clk);

	pm_runtime_disable(spifc->dev);

out_err:

	spi_master_put(master);

	spi_controller_put(host);

	return ret;

}



static void meson_spifc_remove(struct platform_device *pdev)

{

	struct spi_master *master = platform_get_drvdata(pdev);

	struct meson_spifc *spifc = spi_master_get_devdata(master);

	struct spi_controller *host = platform_get_drvdata(pdev);

	struct meson_spifc *spifc = spi_controller_get_devdata(host);



	pm_runtime_get_sync(&pdev->dev);

	clk_disable_unprepare(spifc->clk);
@@ -368,11 +368,11 @@ static void meson_spifc_remove(struct platform_device *pdev) 
#ifdef CONFIG_PM_SLEEP

static int meson_spifc_suspend(struct device *dev)

{

	struct spi_master *master = dev_get_drvdata(dev);

	struct meson_spifc *spifc = spi_master_get_devdata(master);

	struct spi_controller *host = dev_get_drvdata(dev);

	struct meson_spifc *spifc = spi_controller_get_devdata(host);

	int ret;



	ret = spi_master_suspend(master);

	ret = spi_controller_suspend(host);

	if (ret)

		return ret;
@@ -384,8 +384,8 @@ static int meson_spifc_suspend(struct device *dev) 


static int meson_spifc_resume(struct device *dev)

{

	struct spi_master *master = dev_get_drvdata(dev);

	struct meson_spifc *spifc = spi_master_get_devdata(master);

	struct spi_controller *host = dev_get_drvdata(dev);

	struct meson_spifc *spifc = spi_controller_get_devdata(host);

	int ret;



	if (!pm_runtime_suspended(dev)) {
@@ -396,7 +396,7 @@ static int meson_spifc_resume(struct device *dev) 


	meson_spifc_hw_init(spifc);



	ret = spi_master_resume(master);

	ret = spi_controller_resume(host);

	if (ret)

		clk_disable_unprepare(spifc->clk);
@@ -407,8 +407,8 @@ static int meson_spifc_resume(struct device *dev) 
#ifdef CONFIG_PM

static int meson_spifc_runtime_suspend(struct device *dev)

{

	struct spi_master *master = dev_get_drvdata(dev);

	struct meson_spifc *spifc = spi_master_get_devdata(master);

	struct spi_controller *host = dev_get_drvdata(dev);

	struct meson_spifc *spifc = spi_controller_get_devdata(host);



	clk_disable_unprepare(spifc->clk);
@@ -417,8 +417,8 @@ static int meson_spifc_runtime_suspend(struct device *dev) 


static int meson_spifc_runtime_resume(struct device *dev)

{

	struct spi_master *master = dev_get_drvdata(dev);

	struct meson_spifc *spifc = spi_master_get_devdata(master);

	struct spi_controller *host = dev_get_drvdata(dev);

	struct meson_spifc *spifc = spi_controller_get_devdata(host);



	return clk_prepare_enable(spifc->clk);

}

drivers/spi/spi-microchip-core-qspi.c

+5 −5
Original line number Diff line number Diff line
@@ -299,7 +299,7 @@ static int mchp_coreqspi_setup_clock(struct mchp_coreqspi *qspi, struct spi_devi 


static int mchp_coreqspi_setup_op(struct spi_device *spi_dev)

{

	struct spi_controller *ctlr = spi_dev->master;

	struct spi_controller *ctlr = spi_dev->controller;

	struct mchp_coreqspi *qspi = spi_controller_get_devdata(ctlr);

	u32 control = readl_relaxed(qspi->regs + REG_CONTROL);
@@ -368,7 +368,7 @@ static inline void mchp_coreqspi_config_op(struct mchp_coreqspi *qspi, const str 
static int mchp_qspi_wait_for_ready(struct spi_mem *mem)

{

	struct mchp_coreqspi *qspi = spi_controller_get_devdata

				    (mem->spi->master);

				    (mem->spi->controller);

	u32 status;

	int ret;
@@ -387,7 +387,7 @@ static int mchp_qspi_wait_for_ready(struct spi_mem *mem) 
static int mchp_coreqspi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op)

{

	struct mchp_coreqspi *qspi = spi_controller_get_devdata

				    (mem->spi->master);

				    (mem->spi->controller);

	u32 address = op->addr.val;

	u8 opcode = op->cmd.opcode;

	u8 opaddr[5];
@@ -505,10 +505,10 @@ static int mchp_coreqspi_probe(struct platform_device *pdev) 
	struct device_node *np = dev->of_node;

	int ret;



	ctlr = devm_spi_alloc_master(&pdev->dev, sizeof(*qspi));

	ctlr = devm_spi_alloc_host(&pdev->dev, sizeof(*qspi));

	if (!ctlr)

		return dev_err_probe(&pdev->dev, -ENOMEM,

				     "unable to allocate master for QSPI controller\n");

				     "unable to allocate host for QSPI controller\n");



	qspi = spi_controller_get_devdata(ctlr);

	platform_set_drvdata(pdev, qspi);