dm: spi: Rename soft_spi.c to soft_spi_legacy.c
authorSimon Glass <sjg@chromium.org>
Tue, 14 Oct 2014 05:41:58 +0000 (23:41 -0600)
committerSimon Glass <sjg@chromium.org>
Wed, 22 Oct 2014 16:36:48 +0000 (10:36 -0600)
Reserve the 'normal' name for use by driver model, and rename the old
driver so that it is clear that it is for 'legacy' drivers only.

Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Jagannadha Sutradharudu Teki <jagannadh.teki@gmail.com>
drivers/spi/Makefile
drivers/spi/soft_spi.c [deleted file]
drivers/spi/soft_spi_legacy.c [new file with mode: 0644]

index a1de0288de208985d16c087fd8422bd20d4b0796..5cc8655d136cf10f2ceaa3770799f5ab331012e3 100644 (file)
@@ -11,6 +11,7 @@ obj-y += spi-uclass.o
 obj-$(CONFIG_SANDBOX) += spi-emul-uclass.o
 else
 obj-y += spi.o
+obj-$(CONFIG_SOFT_SPI) += soft_spi_legacy.o
 endif
 
 obj-$(CONFIG_EP93XX_SPI) += ep93xx_spi.o
@@ -35,7 +36,6 @@ obj-$(CONFIG_MXS_SPI) += mxs_spi.o
 obj-$(CONFIG_OC_TINY_SPI) += oc_tiny_spi.o
 obj-$(CONFIG_OMAP3_SPI) += omap3_spi.o
 obj-$(CONFIG_SANDBOX_SPI) += sandbox_spi.o
-obj-$(CONFIG_SOFT_SPI) += soft_spi.o
 obj-$(CONFIG_SH_SPI) += sh_spi.o
 obj-$(CONFIG_SH_QSPI) += sh_qspi.o
 obj-$(CONFIG_FSL_ESPI) += fsl_espi.o
diff --git a/drivers/spi/soft_spi.c b/drivers/spi/soft_spi.c
deleted file mode 100644 (file)
index c969be3..0000000
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * (C) Copyright 2002
- * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
- *
- * Influenced by code from:
- * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-
-#include <common.h>
-#include <spi.h>
-
-#include <malloc.h>
-
-/*-----------------------------------------------------------------------
- * Definitions
- */
-
-#ifdef DEBUG_SPI
-#define PRINTD(fmt,args...)    printf (fmt ,##args)
-#else
-#define PRINTD(fmt,args...)
-#endif
-
-struct soft_spi_slave {
-       struct spi_slave slave;
-       unsigned int mode;
-};
-
-static inline struct soft_spi_slave *to_soft_spi(struct spi_slave *slave)
-{
-       return container_of(slave, struct soft_spi_slave, slave);
-}
-
-/*=====================================================================*/
-/*                         Public Functions                            */
-/*=====================================================================*/
-
-/*-----------------------------------------------------------------------
- * Initialization
- */
-void spi_init (void)
-{
-#ifdef SPI_INIT
-       volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
-
-       SPI_INIT;
-#endif
-}
-
-struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
-               unsigned int max_hz, unsigned int mode)
-{
-       struct soft_spi_slave *ss;
-
-       if (!spi_cs_is_valid(bus, cs))
-               return NULL;
-
-       ss = spi_alloc_slave(struct soft_spi_slave, bus, cs);
-       if (!ss)
-               return NULL;
-
-       ss->mode = mode;
-
-       /* TODO: Use max_hz to limit the SCK rate */
-
-       return &ss->slave;
-}
-
-void spi_free_slave(struct spi_slave *slave)
-{
-       struct soft_spi_slave *ss = to_soft_spi(slave);
-
-       free(ss);
-}
-
-int spi_claim_bus(struct spi_slave *slave)
-{
-#ifdef CONFIG_SYS_IMMR
-       volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
-#endif
-       struct soft_spi_slave *ss = to_soft_spi(slave);
-
-       /*
-        * Make sure the SPI clock is in idle state as defined for
-        * this slave.
-        */
-       if (ss->mode & SPI_CPOL)
-               SPI_SCL(1);
-       else
-               SPI_SCL(0);
-
-       return 0;
-}
-
-void spi_release_bus(struct spi_slave *slave)
-{
-       /* Nothing to do */
-}
-
-/*-----------------------------------------------------------------------
- * SPI transfer
- *
- * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
- * "bitlen" bits in the SPI MISO port.  That's just the way SPI works.
- *
- * The source of the outgoing bits is the "dout" parameter and the
- * destination of the input bits is the "din" parameter.  Note that "dout"
- * and "din" can point to the same memory location, in which case the
- * input data overwrites the output data (since both are buffered by
- * temporary variables, this is OK).
- */
-int  spi_xfer(struct spi_slave *slave, unsigned int bitlen,
-               const void *dout, void *din, unsigned long flags)
-{
-#ifdef CONFIG_SYS_IMMR
-       volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
-#endif
-       struct soft_spi_slave *ss = to_soft_spi(slave);
-       uchar           tmpdin  = 0;
-       uchar           tmpdout = 0;
-       const u8        *txd = dout;
-       u8              *rxd = din;
-       int             cpol = ss->mode & SPI_CPOL;
-       int             cpha = ss->mode & SPI_CPHA;
-       unsigned int    j;
-
-       PRINTD("spi_xfer: slave %u:%u dout %08X din %08X bitlen %u\n",
-               slave->bus, slave->cs, *(uint *)txd, *(uint *)rxd, bitlen);
-
-       if (flags & SPI_XFER_BEGIN)
-               spi_cs_activate(slave);
-
-       for(j = 0; j < bitlen; j++) {
-               /*
-                * Check if it is time to work on a new byte.
-                */
-               if ((j % 8) == 0) {
-                       if (txd)
-                               tmpdout = *txd++;
-                       else
-                               tmpdout = 0;
-                       if(j != 0) {
-                               if (rxd)
-                                       *rxd++ = tmpdin;
-                       }
-                       tmpdin  = 0;
-               }
-
-               if (!cpha)
-                       SPI_SCL(!cpol);
-               SPI_SDA(tmpdout & 0x80);
-               SPI_DELAY;
-               if (cpha)
-                       SPI_SCL(!cpol);
-               else
-                       SPI_SCL(cpol);
-               tmpdin  <<= 1;
-               tmpdin  |= SPI_READ;
-               tmpdout <<= 1;
-               SPI_DELAY;
-               if (cpha)
-                       SPI_SCL(cpol);
-       }
-       /*
-        * If the number of bits isn't a multiple of 8, shift the last
-        * bits over to left-justify them.  Then store the last byte
-        * read in.
-        */
-       if (rxd) {
-               if ((bitlen % 8) != 0)
-                       tmpdin <<= 8 - (bitlen % 8);
-               *rxd++ = tmpdin;
-       }
-
-       if (flags & SPI_XFER_END)
-               spi_cs_deactivate(slave);
-
-       return(0);
-}
diff --git a/drivers/spi/soft_spi_legacy.c b/drivers/spi/soft_spi_legacy.c
new file mode 100644 (file)
index 0000000..c969be3
--- /dev/null
@@ -0,0 +1,181 @@
+/*
+ * (C) Copyright 2002
+ * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
+ *
+ * Influenced by code from:
+ * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <spi.h>
+
+#include <malloc.h>
+
+/*-----------------------------------------------------------------------
+ * Definitions
+ */
+
+#ifdef DEBUG_SPI
+#define PRINTD(fmt,args...)    printf (fmt ,##args)
+#else
+#define PRINTD(fmt,args...)
+#endif
+
+struct soft_spi_slave {
+       struct spi_slave slave;
+       unsigned int mode;
+};
+
+static inline struct soft_spi_slave *to_soft_spi(struct spi_slave *slave)
+{
+       return container_of(slave, struct soft_spi_slave, slave);
+}
+
+/*=====================================================================*/
+/*                         Public Functions                            */
+/*=====================================================================*/
+
+/*-----------------------------------------------------------------------
+ * Initialization
+ */
+void spi_init (void)
+{
+#ifdef SPI_INIT
+       volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
+
+       SPI_INIT;
+#endif
+}
+
+struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
+               unsigned int max_hz, unsigned int mode)
+{
+       struct soft_spi_slave *ss;
+
+       if (!spi_cs_is_valid(bus, cs))
+               return NULL;
+
+       ss = spi_alloc_slave(struct soft_spi_slave, bus, cs);
+       if (!ss)
+               return NULL;
+
+       ss->mode = mode;
+
+       /* TODO: Use max_hz to limit the SCK rate */
+
+       return &ss->slave;
+}
+
+void spi_free_slave(struct spi_slave *slave)
+{
+       struct soft_spi_slave *ss = to_soft_spi(slave);
+
+       free(ss);
+}
+
+int spi_claim_bus(struct spi_slave *slave)
+{
+#ifdef CONFIG_SYS_IMMR
+       volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
+#endif
+       struct soft_spi_slave *ss = to_soft_spi(slave);
+
+       /*
+        * Make sure the SPI clock is in idle state as defined for
+        * this slave.
+        */
+       if (ss->mode & SPI_CPOL)
+               SPI_SCL(1);
+       else
+               SPI_SCL(0);
+
+       return 0;
+}
+
+void spi_release_bus(struct spi_slave *slave)
+{
+       /* Nothing to do */
+}
+
+/*-----------------------------------------------------------------------
+ * SPI transfer
+ *
+ * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
+ * "bitlen" bits in the SPI MISO port.  That's just the way SPI works.
+ *
+ * The source of the outgoing bits is the "dout" parameter and the
+ * destination of the input bits is the "din" parameter.  Note that "dout"
+ * and "din" can point to the same memory location, in which case the
+ * input data overwrites the output data (since both are buffered by
+ * temporary variables, this is OK).
+ */
+int  spi_xfer(struct spi_slave *slave, unsigned int bitlen,
+               const void *dout, void *din, unsigned long flags)
+{
+#ifdef CONFIG_SYS_IMMR
+       volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
+#endif
+       struct soft_spi_slave *ss = to_soft_spi(slave);
+       uchar           tmpdin  = 0;
+       uchar           tmpdout = 0;
+       const u8        *txd = dout;
+       u8              *rxd = din;
+       int             cpol = ss->mode & SPI_CPOL;
+       int             cpha = ss->mode & SPI_CPHA;
+       unsigned int    j;
+
+       PRINTD("spi_xfer: slave %u:%u dout %08X din %08X bitlen %u\n",
+               slave->bus, slave->cs, *(uint *)txd, *(uint *)rxd, bitlen);
+
+       if (flags & SPI_XFER_BEGIN)
+               spi_cs_activate(slave);
+
+       for(j = 0; j < bitlen; j++) {
+               /*
+                * Check if it is time to work on a new byte.
+                */
+               if ((j % 8) == 0) {
+                       if (txd)
+                               tmpdout = *txd++;
+                       else
+                               tmpdout = 0;
+                       if(j != 0) {
+                               if (rxd)
+                                       *rxd++ = tmpdin;
+                       }
+                       tmpdin  = 0;
+               }
+
+               if (!cpha)
+                       SPI_SCL(!cpol);
+               SPI_SDA(tmpdout & 0x80);
+               SPI_DELAY;
+               if (cpha)
+                       SPI_SCL(!cpol);
+               else
+                       SPI_SCL(cpol);
+               tmpdin  <<= 1;
+               tmpdin  |= SPI_READ;
+               tmpdout <<= 1;
+               SPI_DELAY;
+               if (cpha)
+                       SPI_SCL(cpol);
+       }
+       /*
+        * If the number of bits isn't a multiple of 8, shift the last
+        * bits over to left-justify them.  Then store the last byte
+        * read in.
+        */
+       if (rxd) {
+               if ((bitlen % 8) != 0)
+                       tmpdin <<= 8 - (bitlen % 8);
+               *rxd++ = tmpdin;
+       }
+
+       if (flags & SPI_XFER_END)
+               spi_cs_deactivate(slave);
+
+       return(0);
+}