Unverified Commit 8aaeae7e authored by Mark Brown's avatar Mark Brown
Browse files

Merge remote-tracking branches 'spi/topic/jcore', 'spi/topic/kconfig',... 

Merge remote-tracking branches 'spi/topic/jcore', 'spi/topic/kconfig', 'spi/topic/orion', 'spi/topic/pxa2xx' and 'spi/topic/rspi' into spi-next
parents 70a3550b 7c2861a6 e3d001a0 5c22af7e 3cc7b0e3 768d59f5

drivers/spi/Kconfig

+2 −2
Original line number Diff line number Diff line
@@ -72,10 +72,10 @@ config SPI_ARMADA_3700 
config SPI_ATMEL

	tristate "Atmel SPI Controller"

	depends on HAS_DMA

	depends on (ARCH_AT91 || AVR32 || COMPILE_TEST)

	depends on (ARCH_AT91 || COMPILE_TEST)

	help

	  This selects a driver for the Atmel SPI Controller, present on

	  many AT32 (AVR32) and AT91 (ARM) chips.

	  many AT91 (ARM) chips.



config SPI_AU1550

	tristate "Au1550/Au1200/Au1300 SPI Controller"

drivers/spi/spi-jcore.c

+5 −6
Original line number Diff line number Diff line
@@ -184,10 +184,11 @@ static int jcore_spi_probe(struct platform_device *pdev) 
	 */

	clock_freq = 50000000;

	clk = devm_clk_get(&pdev->dev, "ref_clk");

	if (!IS_ERR_OR_NULL(clk)) {

		if (clk_enable(clk) == 0)

	if (!IS_ERR(clk)) {

		if (clk_prepare_enable(clk) == 0) {

			clock_freq = clk_get_rate(clk);

		else

			clk_disable_unprepare(clk);

		} else

			dev_warn(&pdev->dev, "could not enable ref_clk\n");

	}

	hw->clock_freq = clock_freq;
@@ -198,10 +199,8 @@ static int jcore_spi_probe(struct platform_device *pdev) 


	/* Register our spi controller */

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

	if (err) {

		clk_disable(clk);

	if (err)

		goto exit;

	}



	return 0;

drivers/spi/spi-orion.c

+55 −10
Original line number Diff line number Diff line
@@ -90,14 +90,19 @@ struct orion_direct_acc { 
	u32			size;

};



struct orion_child_options {

	struct orion_direct_acc direct_access;

};



struct orion_spi {

	struct spi_master	*master;

	void __iomem		*base;

	struct clk              *clk;

	struct clk              *axi_clk;

	const struct orion_spi_dev *devdata;

	int			unused_hw_gpio;



	struct orion_direct_acc	direct_access[ORION_NUM_CHIPSELECTS];

	struct orion_child_options	child[ORION_NUM_CHIPSELECTS];

};



static inline void __iomem *spi_reg(struct orion_spi *orion_spi, u32 reg)
@@ -324,13 +329,13 @@ static void orion_spi_set_cs(struct spi_device *spi, bool enable) 
	struct orion_spi *orion_spi;

	int cs;



	orion_spi = spi_master_get_devdata(spi->master);



	if (gpio_is_valid(spi->cs_gpio))

		cs = 0;

		cs = orion_spi->unused_hw_gpio;

	else

		cs = spi->chip_select;



	orion_spi = spi_master_get_devdata(spi->master);



	orion_spi_clrbits(orion_spi, ORION_SPI_IF_CTRL_REG, ORION_SPI_CS_MASK);

	orion_spi_setbits(orion_spi, ORION_SPI_IF_CTRL_REG,

				ORION_SPI_CS(cs));
@@ -435,7 +440,7 @@ orion_spi_write_read(struct spi_device *spi, struct spi_transfer *xfer) 
	 * Use SPI direct write mode if base address is available. Otherwise

	 * fall back to PIO mode for this transfer.

	 */

	if ((orion_spi->direct_access[cs].vaddr) && (xfer->tx_buf) &&

	if ((orion_spi->child[cs].direct_access.vaddr) && (xfer->tx_buf) &&

	    (word_len == 8)) {

		unsigned int cnt = count / 4;

		unsigned int rem = count % 4;
@@ -444,12 +449,12 @@ orion_spi_write_read(struct spi_device *spi, struct spi_transfer *xfer) 
		 * Send the TX-data to the SPI device via the direct

		 * mapped address window

		 */

		iowrite32_rep(orion_spi->direct_access[cs].vaddr,

		iowrite32_rep(orion_spi->child[cs].direct_access.vaddr,

			      xfer->tx_buf, cnt);

		if (rem) {

			u32 *buf = (u32 *)xfer->tx_buf;



			iowrite8_rep(orion_spi->direct_access[cs].vaddr,

			iowrite8_rep(orion_spi->child[cs].direct_access.vaddr,

				     &buf[cnt], rem);

		}
@@ -498,6 +503,9 @@ static int orion_spi_transfer_one(struct spi_master *master, 


static int orion_spi_setup(struct spi_device *spi)

{

	if (gpio_is_valid(spi->cs_gpio)) {

		gpio_direction_output(spi->cs_gpio, !(spi->mode & SPI_CS_HIGH));

	}

	return orion_spi_setup_transfer(spi, NULL);

}
@@ -620,6 +628,7 @@ static int orion_spi_probe(struct platform_device *pdev) 


	spi = spi_master_get_devdata(master);

	spi->master = master;

	spi->unused_hw_gpio = -1;



	of_id = of_match_device(orion_spi_of_match_table, &pdev->dev);

	devdata = (of_id) ? of_id->data : &orion_spi_dev_data;
@@ -702,14 +711,14 @@ static int orion_spi_probe(struct platform_device *pdev) 
		 * This needs to get extended for the direct SPI-NOR / SPI-NAND

		 * support, once this gets implemented.

		 */

		spi->direct_access[cs].vaddr = devm_ioremap(&pdev->dev,

		spi->child[cs].direct_access.vaddr = devm_ioremap(&pdev->dev,

							    r->start,

							    PAGE_SIZE);

		if (!spi->direct_access[cs].vaddr) {

		if (!spi->child[cs].direct_access.vaddr) {

			status = -ENOMEM;

			goto out_rel_axi_clk;

		}

		spi->direct_access[cs].size = PAGE_SIZE;

		spi->child[cs].direct_access.size = PAGE_SIZE;



		dev_info(&pdev->dev, "CS%d configured for direct access\n", cs);

	}
@@ -731,8 +740,44 @@ static int orion_spi_probe(struct platform_device *pdev) 
	if (status < 0)

		goto out_rel_pm;



	if (master->cs_gpios) {

		int i;

		for (i = 0; i < master->num_chipselect; ++i) {

			char *gpio_name;



			if (!gpio_is_valid(master->cs_gpios[i])) {

				continue;

			}



			gpio_name = devm_kasprintf(&pdev->dev, GFP_KERNEL,

					"%s-CS%d", dev_name(&pdev->dev), i);

			if (!gpio_name) {

				status = -ENOMEM;

				goto out_rel_master;

			}



			status = devm_gpio_request(&pdev->dev,

					master->cs_gpios[i], gpio_name);

			if (status) {

				dev_err(&pdev->dev,

					"Can't request GPIO for CS %d\n",

					master->cs_gpios[i]);

				goto out_rel_master;

			}

			if (spi->unused_hw_gpio == -1) {

				dev_info(&pdev->dev,

					"Selected unused HW CS#%d for any GPIO CSes\n",

					i);

				spi->unused_hw_gpio = i;

			}

		}

	}





	return status;



out_rel_master:

	spi_unregister_master(master);

out_rel_pm:

	pm_runtime_disable(&pdev->dev);

out_rel_axi_clk:

drivers/spi/spi-pxa2xx-dma.c

+2 −2
Original line number Diff line number Diff line
@@ -191,7 +191,7 @@ int pxa2xx_spi_dma_setup(struct driver_data *drv_data) 
{

	struct pxa2xx_spi_master *pdata = drv_data->master_info;

	struct device *dev = &drv_data->pdev->dev;

	struct spi_master *master = drv_data->master;

	struct spi_controller *master = drv_data->master;

	dma_cap_mask_t mask;



	dma_cap_zero(mask);
@@ -215,7 +215,7 @@ int pxa2xx_spi_dma_setup(struct driver_data *drv_data) 


void pxa2xx_spi_dma_release(struct driver_data *drv_data)

{

	struct spi_master *master = drv_data->master;

	struct spi_controller *master = drv_data->master;



	if (master->dma_rx) {

		dmaengine_terminate_sync(master->dma_rx);

drivers/spi/spi-pxa2xx.c

+29 −25
Original line number Diff line number Diff line
@@ -415,10 +415,17 @@ static void cs_deassert(struct driver_data *drv_data) 
{

	struct chip_data *chip =

		spi_get_ctldata(drv_data->master->cur_msg->spi);

	unsigned long timeout;



	if (drv_data->ssp_type == CE4100_SSP)

		return;



	/* Wait until SSP becomes idle before deasserting the CS */

	timeout = jiffies + msecs_to_jiffies(10);

	while (pxa2xx_spi_read(drv_data, SSSR) & SSSR_BSY &&

	       !time_after(jiffies, timeout))

		cpu_relax();



	if (chip->cs_control) {

		chip->cs_control(PXA2XX_CS_DEASSERT);

		return;
@@ -563,7 +570,6 @@ static void giveback(struct driver_data *drv_data) 
{

	struct spi_transfer* last_transfer;

	struct spi_message *msg;

	unsigned long timeout;



	msg = drv_data->master->cur_msg;

	drv_data->cur_transfer = NULL;
@@ -575,12 +581,6 @@ static void giveback(struct driver_data *drv_data) 
	if (last_transfer->delay_usecs)

		udelay(last_transfer->delay_usecs);



	/* Wait until SSP becomes idle before deasserting the CS */

	timeout = jiffies + msecs_to_jiffies(10);

	while (pxa2xx_spi_read(drv_data, SSSR) & SSSR_BSY &&

	       !time_after(jiffies, timeout))

		cpu_relax();



	/* Drop chip select UNLESS cs_change is true or we are returning

	 * a message with an error, or next message is for another chip

	 */
@@ -962,7 +962,7 @@ static unsigned int pxa2xx_ssp_get_clk_div(struct driver_data *drv_data, 
	return clk_div << 8;

}



static bool pxa2xx_spi_can_dma(struct spi_master *master,

static bool pxa2xx_spi_can_dma(struct spi_controller *master,

			       struct spi_device *spi,

			       struct spi_transfer *xfer)

{
@@ -976,7 +976,7 @@ static bool pxa2xx_spi_can_dma(struct spi_master *master, 
static void pump_transfers(unsigned long data)

{

	struct driver_data *drv_data = (struct driver_data *)data;

	struct spi_master *master = drv_data->master;

	struct spi_controller *master = drv_data->master;

	struct spi_message *message = master->cur_msg;

	struct chip_data *chip = spi_get_ctldata(message->spi);

	u32 dma_thresh = chip->dma_threshold;
@@ -1182,10 +1182,10 @@ static void pump_transfers(unsigned long data) 
	pxa2xx_spi_write(drv_data, SSCR1, cr1);

}



static int pxa2xx_spi_transfer_one_message(struct spi_master *master,

static int pxa2xx_spi_transfer_one_message(struct spi_controller *master,

					   struct spi_message *msg)

{

	struct driver_data *drv_data = spi_master_get_devdata(master);

	struct driver_data *drv_data = spi_controller_get_devdata(master);



	/* Initial message state*/

	msg->state = START_STATE;
@@ -1198,9 +1198,9 @@ static int pxa2xx_spi_transfer_one_message(struct spi_master *master, 
	return 0;

}



static int pxa2xx_spi_unprepare_transfer(struct spi_master *master)

static int pxa2xx_spi_unprepare_transfer(struct spi_controller *master)

{

	struct driver_data *drv_data = spi_master_get_devdata(master);

	struct driver_data *drv_data = spi_controller_get_devdata(master);



	/* Disable the SSP now */

	pxa2xx_spi_write(drv_data, SSCR0,
@@ -1212,7 +1212,8 @@ static int pxa2xx_spi_unprepare_transfer(struct spi_master *master) 
static int setup_cs(struct spi_device *spi, struct chip_data *chip,

		    struct pxa2xx_spi_chip *chip_info)

{

	struct driver_data *drv_data = spi_master_get_devdata(spi->master);

	struct driver_data *drv_data =

		spi_controller_get_devdata(spi->controller);

	struct gpio_desc *gpiod;

	int err = 0;
@@ -1270,7 +1271,8 @@ static int setup(struct spi_device *spi) 
	struct pxa2xx_spi_chip *chip_info;

	struct chip_data *chip;

	const struct lpss_config *config;

	struct driver_data *drv_data = spi_master_get_devdata(spi->master);

	struct driver_data *drv_data =

		spi_controller_get_devdata(spi->controller);

	uint tx_thres, tx_hi_thres, rx_thres;



	switch (drv_data->ssp_type) {
@@ -1410,7 +1412,8 @@ static int setup(struct spi_device *spi) 
static void cleanup(struct spi_device *spi)

{

	struct chip_data *chip = spi_get_ctldata(spi);

	struct driver_data *drv_data = spi_master_get_devdata(spi->master);

	struct driver_data *drv_data =

		spi_controller_get_devdata(spi->controller);



	if (!chip)

		return;
@@ -1575,9 +1578,10 @@ pxa2xx_spi_init_pdata(struct platform_device *pdev) 
}

#endif



static int pxa2xx_spi_fw_translate_cs(struct spi_master *master, unsigned cs)

static int pxa2xx_spi_fw_translate_cs(struct spi_controller *master,

				      unsigned int cs)

{

	struct driver_data *drv_data = spi_master_get_devdata(master);

	struct driver_data *drv_data = spi_controller_get_devdata(master);



	if (has_acpi_companion(&drv_data->pdev->dev)) {

		switch (drv_data->ssp_type) {
@@ -1602,7 +1606,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) 
{

	struct device *dev = &pdev->dev;

	struct pxa2xx_spi_master *platform_info;

	struct spi_master *master;

	struct spi_controller *master;

	struct driver_data *drv_data;

	struct ssp_device *ssp;

	const struct lpss_config *config;
@@ -1633,7 +1637,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) 
		pxa_ssp_free(ssp);

		return -ENOMEM;

	}

	drv_data = spi_master_get_devdata(master);

	drv_data = spi_controller_get_devdata(master);

	drv_data->master = master;

	drv_data->master_info = platform_info;

	drv_data->pdev = pdev;
@@ -1651,7 +1655,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) 
	master->unprepare_transfer_hardware = pxa2xx_spi_unprepare_transfer;

	master->fw_translate_cs = pxa2xx_spi_fw_translate_cs;

	master->auto_runtime_pm = true;

	master->flags = SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX;

	master->flags = SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX;



	drv_data->ssp_type = ssp->type;
@@ -1793,7 +1797,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) 


	/* Register with the SPI framework */

	platform_set_drvdata(pdev, drv_data);

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

	status = devm_spi_register_controller(&pdev->dev, master);

	if (status != 0) {

		dev_err(&pdev->dev, "problem registering spi master\n");

		goto out_error_clock_enabled;
@@ -1809,7 +1813,7 @@ out_error_clock_enabled: 
	free_irq(ssp->irq, drv_data);



out_error_master_alloc:

	spi_master_put(master);

	spi_controller_put(master);

	pxa_ssp_free(ssp);

	return status;

}
@@ -1860,7 +1864,7 @@ static int pxa2xx_spi_suspend(struct device *dev) 
	struct ssp_device *ssp = drv_data->ssp;

	int status;



	status = spi_master_suspend(drv_data->master);

	status = spi_controller_suspend(drv_data->master);

	if (status != 0)

		return status;

	pxa2xx_spi_write(drv_data, SSCR0, 0);
@@ -1886,7 +1890,7 @@ static int pxa2xx_spi_resume(struct device *dev) 
		lpss_ssp_setup(drv_data);



	/* Start the queue running */

	status = spi_master_resume(drv_data->master);

	status = spi_controller_resume(drv_data->master);

	if (status != 0) {

		dev_err(dev, "problem starting queue (%d)\n", status);

		return status;