[net-next-2.6.git] / arch / arm / mach-u300 / spi.c

/*
 * arch/arm/mach-u300/spi.c
 *
 * Copyright (C) 2009 ST-Ericsson AB
 * License terms: GNU General Public License (GPL) version 2
 *
 * Author: Linus Walleij <linus.walleij@stericsson.com>
 */
#include <linux/device.h>
#include <linux/amba/bus.h>
#include <linux/spi/spi.h>
#include <linux/amba/pl022.h>
#include <linux/err.h>
#include "padmux.h"

/*
 * The following is for the actual devices on the SSP/SPI bus
 */
#ifdef CONFIG_MACH_U300_SPIDUMMY
static void select_dummy_chip(u32 chipselect)
{
	pr_debug("CORE: %s called with CS=0x%x (%s)\n",
		 __func__,
		 chipselect,
		 chipselect ? "unselect chip" : "select chip");
	/*
	 * Here you would write the chip select value to the GPIO pins if
	 * this was a real chip (but this is a loopback dummy).
	 */
}

struct pl022_config_chip dummy_chip_info = {
	/*
	 * available POLLING_TRANSFER and INTERRUPT_TRANSFER,
	 * DMA_TRANSFER does not work
	 */
	.com_mode = INTERRUPT_TRANSFER,
	.iface = SSP_INTERFACE_MOTOROLA_SPI,
	/* We can only act as master but SSP_SLAVE is possible in theory */
	.hierarchy = SSP_MASTER,
	/* 0 = drive TX even as slave, 1 = do not drive TX as slave */
	.slave_tx_disable = 0,
	.rx_lev_trig = SSP_RX_1_OR_MORE_ELEM,
	.tx_lev_trig = SSP_TX_1_OR_MORE_EMPTY_LOC,
	.ctrl_len = SSP_BITS_12,
	.wait_state = SSP_MWIRE_WAIT_ZERO,
	.duplex = SSP_MICROWIRE_CHANNEL_FULL_DUPLEX,
	/*
	 * This is where you insert a call to a function to enable CS
	 * (usually GPIO) for a certain chip.
	 */
	.cs_control = select_dummy_chip,
};
#endif

static struct spi_board_info u300_spi_devices[] = {
#ifdef CONFIG_MACH_U300_SPIDUMMY
	{
		/* A dummy chip used for loopback tests */
		.modalias       = "spi-dummy",
		/* Really dummy, pass in additional chip config here */
		.platform_data  = NULL,
		/* This defines how the controller shall handle the device */
		.controller_data = &dummy_chip_info,
		/* .irq - no external IRQ routed from this device */
		.max_speed_hz   = 1000000,
		.bus_num        = 0, /* Only one bus on this chip */
		.chip_select    = 0,
		/* Means SPI_CS_HIGH, change if e.g low CS */
		.mode           = SPI_MODE_1 | SPI_LOOP,
	},
#endif
};

static struct pl022_ssp_controller ssp_platform_data = {
	/* If you have several SPI buses this varies, we have only bus 0 */
	.bus_id = 0,
	/* Set this to 1 when we think we got DMA working */
	.enable_dma = 0,
	/*
	 * On the APP CPU GPIO 4, 5 and 6 are connected as generic
	 * chip selects for SPI. (Same on U330, U335 and U365.)
	 * TODO: make sure the GPIO driver can select these properly
	 * and do padmuxing accordingly too.
	 */
	.num_chipselect = 3,
};


void __init u300_spi_init(struct amba_device *adev)
{
	struct pmx *pmx;

	adev->dev.platform_data = &ssp_platform_data;
	/*
	 * Setup padmuxing for SPI. Since this must always be
	 * compiled into the kernel, pmx is never released.
	 */
	pmx = pmx_get(&adev->dev, U300_APP_PMX_SPI_SETTING);

	if (IS_ERR(pmx))
		dev_warn(&adev->dev, "Could not get padmux handle\n");
	else {
		int ret;

		ret = pmx_activate(&adev->dev, pmx);
		if (IS_ERR_VALUE(ret))
			dev_warn(&adev->dev, "Could not activate padmuxing\n");
	}

}
void __init u300_spi_register_board_devices(void)
{
	/* Register any SPI devices */
	spi_register_board_info(u300_spi_devices, ARRAY_SIZE(u300_spi_devices));
}
Commit	Line	Data
c7c8c78f LW	1	/*
	2	* arch/arm/mach-u300/spi.c
	3	*
	4	* Copyright (C) 2009 ST-Ericsson AB
	5	* License terms: GNU General Public License (GPL) version 2
	6	*
	7	* Author: Linus Walleij <linus.walleij@stericsson.com>
	8	*/
	9	#include <linux/device.h>
	10	#include <linux/amba/bus.h>
	11	#include <linux/spi/spi.h>
	12	#include <linux/amba/pl022.h>
	13	#include <linux/err.h>
	14	#include "padmux.h"
	15
	16	/*
	17	* The following is for the actual devices on the SSP/SPI bus
	18	*/
	19	#ifdef CONFIG_MACH_U300_SPIDUMMY
	20	static void select_dummy_chip(u32 chipselect)
	21	{
	22	pr_debug("CORE: %s called with CS=0x%x (%s)\n",
	23	__func__,
	24	chipselect,
	25	chipselect ? "unselect chip" : "select chip");
	26	/*
	27	* Here you would write the chip select value to the GPIO pins if
	28	* this was a real chip (but this is a loopback dummy).
	29	*/
	30	}
	31
	32	struct pl022_config_chip dummy_chip_info = {
c7c8c78f LW	33	/*
	34	* available POLLING_TRANSFER and INTERRUPT_TRANSFER,
	35	* DMA_TRANSFER does not work
	36	*/
	37	.com_mode = INTERRUPT_TRANSFER,
	38	.iface = SSP_INTERFACE_MOTOROLA_SPI,
	39	/* We can only act as master but SSP_SLAVE is possible in theory */
	40	.hierarchy = SSP_MASTER,
	41	/* 0 = drive TX even as slave, 1 = do not drive TX as slave */
	42	.slave_tx_disable = 0,
c7c8c78f LW	43	.rx_lev_trig = SSP_RX_1_OR_MORE_ELEM,
c7c8c78f LW	44	.tx_lev_trig = SSP_TX_1_OR_MORE_EMPTY_LOC,
c7c8c78f LW	45	.ctrl_len = SSP_BITS_12,
	46	.wait_state = SSP_MWIRE_WAIT_ZERO,
	47	.duplex = SSP_MICROWIRE_CHANNEL_FULL_DUPLEX,
	48	/*
	49	* This is where you insert a call to a function to enable CS
	50	* (usually GPIO) for a certain chip.
	51	*/
	52	.cs_control = select_dummy_chip,
	53	};
	54	#endif
	55
	56	static struct spi_board_info u300_spi_devices[] = {
	57	#ifdef CONFIG_MACH_U300_SPIDUMMY
	58	{
	59	/* A dummy chip used for loopback tests */
	60	.modalias = "spi-dummy",
	61	/* Really dummy, pass in additional chip config here */
	62	.platform_data = NULL,
	63	/* This defines how the controller shall handle the device */
	64	.controller_data = &dummy_chip_info,
	65	/* .irq - no external IRQ routed from this device */
	66	.max_speed_hz = 1000000,
	67	.bus_num = 0, /* Only one bus on this chip */
	68	.chip_select = 0,
	69	/* Means SPI_CS_HIGH, change if e.g low CS */
65289d63	70	.mode = SPI_MODE_1 \| SPI_LOOP,
c7c8c78f LW	71	},
	72	#endif
	73	};
	74
	75	static struct pl022_ssp_controller ssp_platform_data = {
	76	/* If you have several SPI buses this varies, we have only bus 0 */
	77	.bus_id = 0,
	78	/* Set this to 1 when we think we got DMA working */
	79	.enable_dma = 0,
	80	/*
	81	* On the APP CPU GPIO 4, 5 and 6 are connected as generic
	82	* chip selects for SPI. (Same on U330, U335 and U365.)
	83	* TODO: make sure the GPIO driver can select these properly
	84	* and do padmuxing accordingly too.
	85	*/
	86	.num_chipselect = 3,
	87	};
	88
	89
	90	void __init u300_spi_init(struct amba_device *adev)
	91	{
	92	struct pmx *pmx;
	93
	94	adev->dev.platform_data = &ssp_platform_data;
	95	/*
	96	* Setup padmuxing for SPI. Since this must always be
	97	* compiled into the kernel, pmx is never released.
	98	*/
	99	pmx = pmx_get(&adev->dev, U300_APP_PMX_SPI_SETTING);
	100
	101	if (IS_ERR(pmx))
	102	dev_warn(&adev->dev, "Could not get padmux handle\n");
	103	else {
	104	int ret;
	105
	106	ret = pmx_activate(&adev->dev, pmx);
	107	if (IS_ERR_VALUE(ret))
	108	dev_warn(&adev->dev, "Could not activate padmuxing\n");
	109	}
	110
	111	}
	112	void __init u300_spi_register_board_devices(void)
	113	{
	114	/* Register any SPI devices */
	115	spi_register_board_info(u300_spi_devices, ARRAY_SIZE(u300_spi_devices));
	116	}