Merge branch 'next-spi' of git://git.secretlab.ca/git/linux-2.6 (702c0b04) · Commits · 戴 / test

Documentation/spi/ep93xx_spi

0 → 100644

+95 −0

Original line number	Diff line number	Diff line
		Cirrus EP93xx SPI controller driver HOWTO
		=========================================

		ep93xx_spi driver brings SPI master support for EP93xx SPI controller. Chip
		selects are implemented with GPIO lines.

		NOTE: If possible, don't use SFRMOUT (SFRM1) signal as a chip select. It will
		not work correctly (it cannot be controlled by software). Use GPIO lines
		instead.

		Sample configuration
		====================

		Typically driver configuration is done in platform board files (the files under
		arch/arm/mach-ep93xx/*.c). In this example we configure MMC over SPI through
		this driver on TS-7260 board. You can adapt the code to suit your needs.

		This example uses EGPIO9 as SD/MMC card chip select (this is wired in DIO1
		header on the board).

		You need to select CONFIG_MMC_SPI to use mmc_spi driver.

		arch/arm/mach-ep93xx/ts72xx.c:

		...
		#include <linux/gpio.h>
		#include <linux/spi/spi.h>

		#include <mach/ep93xx_spi.h>

		/* this is our GPIO line used for chip select */
		#define MMC_CHIP_SELECT_GPIO EP93XX_GPIO_LINE_EGPIO9

		static int ts72xx_mmc_spi_setup(struct spi_device *spi)
		{
		int err;

		err = gpio_request(MMC_CHIP_SELECT_GPIO, spi->modalias);
		if (err)
		return err;

		gpio_direction_output(MMC_CHIP_SELECT_GPIO, 1);

		return 0;
		}

		static void ts72xx_mmc_spi_cleanup(struct spi_device *spi)
		{
		gpio_set_value(MMC_CHIP_SELECT_GPIO, 1);
		gpio_direction_input(MMC_CHIP_SELECT_GPIO);
		gpio_free(MMC_CHIP_SELECT_GPIO);
		}

		static void ts72xx_mmc_spi_cs_control(struct spi_device *spi, int value)
		{
		gpio_set_value(MMC_CHIP_SELECT_GPIO, value);
		}

		static struct ep93xx_spi_chip_ops ts72xx_mmc_spi_ops = {
		.setup = ts72xx_mmc_spi_setup,
		.cleanup = ts72xx_mmc_spi_cleanup,
		.cs_control = ts72xx_mmc_spi_cs_control,
		};

		static struct spi_board_info ts72xx_spi_devices[] __initdata = {
		{
		.modalias = "mmc_spi",
		.controller_data = &ts72xx_mmc_spi_ops,
		/*
		* We use 10 MHz even though the maximum is 7.4 MHz. The driver
		* will limit it automatically to max. frequency.
		*/
		.max_speed_hz = 10 * 1000 * 1000,
		.bus_num = 0,
		.chip_select = 0,
		.mode = SPI_MODE_0,
		},
		};

		static struct ep93xx_spi_info ts72xx_spi_info = {
		.num_chipselect = ARRAY_SIZE(ts72xx_spi_devices),
		};

		static void __init ts72xx_init_machine(void)
		{
		...
		ep93xx_register_spi(&ts72xx_spi_info, ts72xx_spi_devices,
		ARRAY_SIZE(ts72xx_spi_devices));
		}

		Thanks to
		=========
		Martin Guy, H. Hartley Sweeten and others who helped me during development of
		the driver. Simplemachines.it donated me a Sim.One board which I used testing
		the driver on EP9307.

Documentation/spi/spidev_fdx.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -58,10 +58,10 @@ static void do_msg(int fd, int len)
		len = sizeof buf;

		buf[0] = 0xaa;
		xfer[0].tx_buf = (__u64) buf;
		xfer[0].tx_buf = (unsigned long)buf;
		xfer[0].len = 1;

		xfer[1].rx_buf = (__u64) buf;
		xfer[1].rx_buf = (unsigned long) buf;
		xfer[1].len = len;

		status = ioctl(fd, SPI_IOC_MESSAGE(2), xfer);

arch/arm/mach-ep93xx/include/mach/ep93xx_spi.h

0 → 100644

+27 −0

Original line number	Diff line number	Diff line
		#ifndef __ASM_MACH_EP93XX_SPI_H
		#define __ASM_MACH_EP93XX_SPI_H

		struct spi_device;

		/**
		* struct ep93xx_spi_info - EP93xx specific SPI descriptor
		* @num_chipselect: number of chip selects on this board, must be
		* at least one
		*/
		struct ep93xx_spi_info {
		int num_chipselect;
		};

		/**
		* struct ep93xx_spi_chip_ops - operation callbacks for SPI slave device
		* @setup: setup the chip select mechanism
		* @cleanup: cleanup the chip select mechanism
		* @cs_control: control the device chip select
		*/
		struct ep93xx_spi_chip_ops {
		int (setup)(struct spi_device spi);
		void (cleanup)(struct spi_device spi);
		void (cs_control)(struct spi_device spi, int value);
		};

		#endif /* __ASM_MACH_EP93XX_SPI_H */

arch/powerpc/include/asm/mpc52xx_psc.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -248,6 +248,7 @@ struct mpc52xx_psc_fifo {
		u16 tflwfptr; /* PSC + 0x9e */
		};

		#define MPC512x_PSC_FIFO_EOF 0x100
		#define MPC512x_PSC_FIFO_RESET_SLICE 0x80
		#define MPC512x_PSC_FIFO_ENABLE_SLICE 0x01
		#define MPC512x_PSC_FIFO_ENABLE_DMA 0x04

arch/powerpc/platforms/512x/mpc512x_shared.c

+78 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		#include <asm/prom.h>
		#include <asm/time.h>
		#include <asm/mpc5121.h>
		#include <asm/mpc52xx_psc.h>

		#include "mpc512x.h"

		@@ -95,9 +96,86 @@ void __init mpc512x_declare_of_platform_devices(void)
		}
		}

		#define DEFAULT_FIFO_SIZE 16

		static unsigned int __init get_fifo_size(struct device_node *np,
		char *prop_name)
		{
		const unsigned int *fp;

		fp = of_get_property(np, prop_name, NULL);
		if (fp)
		return *fp;

		pr_warning("no %s property in %s node, defaulting to %d\n",
		prop_name, np->full_name, DEFAULT_FIFO_SIZE);

		return DEFAULT_FIFO_SIZE;
		}

		#define FIFOC(_base) ((struct mpc512x_psc_fifo __iomem *) \
		((u32)(_base) + sizeof(struct mpc52xx_psc)))

		/* Init PSC FIFO space for TX and RX slices */
		void __init mpc512x_psc_fifo_init(void)
		{
		struct device_node *np;
		void __iomem *psc;
		unsigned int tx_fifo_size;
		unsigned int rx_fifo_size;
		int fifobase = 0; /* current fifo address in 32 bit words */

		for_each_compatible_node(np, NULL, "fsl,mpc5121-psc") {
		tx_fifo_size = get_fifo_size(np, "fsl,tx-fifo-size");
		rx_fifo_size = get_fifo_size(np, "fsl,rx-fifo-size");

		/* size in register is in 4 byte units */
		tx_fifo_size /= 4;
		rx_fifo_size /= 4;
		if (!tx_fifo_size)
		tx_fifo_size = 1;
		if (!rx_fifo_size)
		rx_fifo_size = 1;

		psc = of_iomap(np, 0);
		if (!psc) {
		pr_err("%s: Can't map %s device\n",
		__func__, np->full_name);
		continue;
		}

		/* FIFO space is 4KiB, check if requested size is available */
		if ((fifobase + tx_fifo_size + rx_fifo_size) > 0x1000) {
		pr_err("%s: no fifo space available for %s\n",
		__func__, np->full_name);
		iounmap(psc);
		/*
		* chances are that another device requests less
		* fifo space, so we continue.
		*/
		continue;
		}

		/* set tx and rx fifo size registers */
		out_be32(&FIFOC(psc)->txsz, (fifobase << 16) \| tx_fifo_size);
		fifobase += tx_fifo_size;
		out_be32(&FIFOC(psc)->rxsz, (fifobase << 16) \| rx_fifo_size);
		fifobase += rx_fifo_size;

		/* reset and enable the slices */
		out_be32(&FIFOC(psc)->txcmd, 0x80);
		out_be32(&FIFOC(psc)->txcmd, 0x01);
		out_be32(&FIFOC(psc)->rxcmd, 0x80);
		out_be32(&FIFOC(psc)->rxcmd, 0x01);

		iounmap(psc);
		}
		}

		void __init mpc512x_init(void)
		{
		mpc512x_declare_of_platform_devices();
		mpc5121_clk_init();
		mpc512x_restart_init();
		mpc512x_psc_fifo_init();
		}

Admin message