On Thu, Apr 30, 2009 at 5:48 PM, Anton Vorontsov
<avoront...@ru.mvista.com> wrote:
> Since we renamed the file, we might want to rename the file
> internals too.
>
> Though we don't bother with changing platform driver name and
> platform module alias. The stuff is legacy and hopefully we'll
> remove it soon.
>
I'd say no personally. Its a lot of churn for very little gain. The
filename change alone should be sufficient to clue people into what
the driver is for.
g.
> Suggested-by: Kumar Gala <ga...@kernel.crashing.org>
> Signed-off-by: Anton Vorontsov <avoront...@ru.mvista.com>
> ---
> drivers/spi/Kconfig | 2 +-
> drivers/spi/Makefile | 2 +-
> drivers/spi/spi_mpc8xxx.c | 396 ++++++++++++++++++++++----------------------
> 3 files changed, 200 insertions(+), 200 deletions(-)
>
> diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
> index 3c1845c..9e77bf1 100644
> --- a/drivers/spi/Kconfig
> +++ b/drivers/spi/Kconfig
> @@ -139,7 +139,7 @@ config SPI_MPC52xx_PSC
> This enables using the Freescale MPC52xx Programmable Serial
> Controller in master SPI mode.
>
> -config SPI_MPC83xx
> +config SPI_MPC8xxx
> tristate "Freescale MPC8xxx SPI controller"
> depends on FSL_SOC
> help
> diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
> index fdc7aa0..18ba6b4 100644
> --- a/drivers/spi/Makefile
> +++ b/drivers/spi/Makefile
> @@ -24,7 +24,7 @@ obj-$(CONFIG_SPI_OMAP_UWIRE) += omap_uwire.o
> obj-$(CONFIG_SPI_OMAP24XX) += omap2_mcspi.o
> obj-$(CONFIG_SPI_ORION) += orion_spi.o
> obj-$(CONFIG_SPI_MPC52xx_PSC) += mpc52xx_psc_spi.o
> -obj-$(CONFIG_SPI_MPC83xx) += spi_mpc8xxx.o
> +obj-$(CONFIG_SPI_MPC8xxx) += spi_mpc8xxx.o
> obj-$(CONFIG_SPI_S3C24XX_GPIO) += spi_s3c24xx_gpio.o
> obj-$(CONFIG_SPI_S3C24XX) += spi_s3c24xx.o
> obj-$(CONFIG_SPI_TXX9) += spi_txx9.o
> diff --git a/drivers/spi/spi_mpc8xxx.c b/drivers/spi/spi_mpc8xxx.c
> index 4192ce4..15d9527 100644
> --- a/drivers/spi/spi_mpc8xxx.c
> +++ b/drivers/spi/spi_mpc8xxx.c
> @@ -1,5 +1,5 @@
> /*
> - * MPC83xx SPI controller driver.
> + * MPC8xxx SPI controller driver.
> *
> * Maintainer: Kumar Gala
> *
> @@ -37,7 +37,7 @@
> #include <asm/irq.h>
>
> /* SPI Controller registers */
> -struct mpc83xx_spi_reg {
> +struct mpc8xxx_spi_reg {
> u8 res1[0x20];
> __be32 mode;
> __be32 event;
> @@ -76,16 +76,16 @@ struct mpc83xx_spi_reg {
> #define SPIM_NF 0x00000100 /* Not full */
>
> /* SPI Controller driver's private data. */
> -struct mpc83xx_spi {
> - struct mpc83xx_spi_reg __iomem *base;
> +struct mpc8xxx_spi {
> + struct mpc8xxx_spi_reg __iomem *base;
>
> /* rx & tx bufs from the spi_transfer */
> const void *tx;
> void *rx;
>
> /* functions to deal with different sized buffers */
> - void (*get_rx) (u32 rx_data, struct mpc83xx_spi *);
> - u32(*get_tx) (struct mpc83xx_spi *);
> + void (*get_rx) (u32 rx_data, struct mpc8xxx_spi *);
> + u32(*get_tx) (struct mpc8xxx_spi *);
>
> unsigned int count;
> unsigned int irq;
> @@ -107,44 +107,44 @@ struct mpc83xx_spi {
> struct completion done;
> };
>
> -struct spi_mpc83xx_cs {
> +struct spi_mpc8xxx_cs {
> /* functions to deal with different sized buffers */
> - void (*get_rx) (u32 rx_data, struct mpc83xx_spi *);
> - u32 (*get_tx) (struct mpc83xx_spi *);
> + void (*get_rx) (u32 rx_data, struct mpc8xxx_spi *);
> + u32 (*get_tx) (struct mpc8xxx_spi *);
> u32 rx_shift; /* RX data reg shift when in qe mode */
> u32 tx_shift; /* TX data reg shift when in qe mode */
> u32 hw_mode; /* Holds HW mode register settings */
> };
>
> -static inline void mpc83xx_spi_write_reg(__be32 __iomem *reg, u32 val)
> +static inline void mpc8xxx_spi_write_reg(__be32 __iomem *reg, u32 val)
> {
> out_be32(reg, val);
> }
>
> -static inline u32 mpc83xx_spi_read_reg(__be32 __iomem *reg)
> +static inline u32 mpc8xxx_spi_read_reg(__be32 __iomem *reg)
> {
> return in_be32(reg);
> }
>
> #define MPC83XX_SPI_RX_BUF(type) \
> static \
> -void mpc83xx_spi_rx_buf_##type(u32 data, struct mpc83xx_spi *mpc83xx_spi) \
> +void mpc8xxx_spi_rx_buf_##type(u32 data, struct mpc8xxx_spi *mpc8xxx_spi) \
> { \
> - type *rx = mpc83xx_spi->rx; \
> - *rx++ = (type)(data >> mpc83xx_spi->rx_shift); \
> - mpc83xx_spi->rx = rx; \
> + type *rx = mpc8xxx_spi->rx; \
> + *rx++ = (type)(data >> mpc8xxx_spi->rx_shift); \
> + mpc8xxx_spi->rx = rx; \
> }
>
> #define MPC83XX_SPI_TX_BUF(type) \
> static \
> -u32 mpc83xx_spi_tx_buf_##type(struct mpc83xx_spi *mpc83xx_spi) \
> +u32 mpc8xxx_spi_tx_buf_##type(struct mpc8xxx_spi *mpc8xxx_spi) \
> { \
> u32 data; \
> - const type *tx = mpc83xx_spi->tx; \
> + const type *tx = mpc8xxx_spi->tx; \
> if (!tx) \
> return 0; \
> - data = *tx++ << mpc83xx_spi->tx_shift; \
> - mpc83xx_spi->tx = tx; \
> + data = *tx++ << mpc8xxx_spi->tx_shift; \
> + mpc8xxx_spi->tx = tx; \
> return data; \
> }
>
> @@ -155,12 +155,12 @@ MPC83XX_SPI_TX_BUF(u8)
> MPC83XX_SPI_TX_BUF(u16)
> MPC83XX_SPI_TX_BUF(u32)
>
> -static void mpc83xx_spi_chipselect(struct spi_device *spi, int value)
> +static void mpc8xxx_spi_chipselect(struct spi_device *spi, int value)
> {
> - struct mpc83xx_spi *mpc83xx_spi = spi_master_get_devdata(spi->master);
> + struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
> struct fsl_spi_platform_data *pdata = spi->dev.parent->platform_data;
> bool pol = spi->mode & SPI_CS_HIGH;
> - struct spi_mpc83xx_cs *cs = spi->controller_state;
> + struct spi_mpc8xxx_cs *cs = spi->controller_state;
>
> if (value == BITBANG_CS_INACTIVE) {
> if (pdata->cs_control)
> @@ -168,16 +168,16 @@ static void mpc83xx_spi_chipselect(struct spi_device
> *spi, int value)
> }
>
> if (value == BITBANG_CS_ACTIVE) {
> - u32 regval = mpc83xx_spi_read_reg(&mpc83xx_spi->base->mode);
> + u32 regval = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->mode);
>
> - mpc83xx_spi->rx_shift = cs->rx_shift;
> - mpc83xx_spi->tx_shift = cs->tx_shift;
> - mpc83xx_spi->get_rx = cs->get_rx;
> - mpc83xx_spi->get_tx = cs->get_tx;
> + mpc8xxx_spi->rx_shift = cs->rx_shift;
> + mpc8xxx_spi->tx_shift = cs->tx_shift;
> + mpc8xxx_spi->get_rx = cs->get_rx;
> + mpc8xxx_spi->get_tx = cs->get_tx;
>
> if (cs->hw_mode != regval) {
> unsigned long flags;
> - __be32 __iomem *mode = &mpc83xx_spi->base->mode;
> + __be32 __iomem *mode = &mpc8xxx_spi->base->mode;
>
> regval = cs->hw_mode;
> /* Turn off IRQs locally to minimize time that
> @@ -185,8 +185,8 @@ static void mpc83xx_spi_chipselect(struct spi_device
> *spi, int value)
> */
> local_irq_save(flags);
> /* Turn off SPI unit prior changing mode */
> - mpc83xx_spi_write_reg(mode, regval & ~SPMODE_ENABLE);
> - mpc83xx_spi_write_reg(mode, regval);
> + mpc8xxx_spi_write_reg(mode, regval & ~SPMODE_ENABLE);
> + mpc8xxx_spi_write_reg(mode, regval);
> local_irq_restore(flags);
> }
> if (pdata->cs_control)
> @@ -195,15 +195,15 @@ static void mpc83xx_spi_chipselect(struct spi_device
> *spi, int value)
> }
>
> static
> -int mpc83xx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer
> *t)
> +int mpc8xxx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer
> *t)
> {
> - struct mpc83xx_spi *mpc83xx_spi;
> + struct mpc8xxx_spi *mpc8xxx_spi;
> u32 regval;
> u8 bits_per_word, pm;
> u32 hz;
> - struct spi_mpc83xx_cs *cs = spi->controller_state;
> + struct spi_mpc8xxx_cs *cs = spi->controller_state;
>
> - mpc83xx_spi = spi_master_get_devdata(spi->master);
> + mpc8xxx_spi = spi_master_get_devdata(spi->master);
>
> if (t) {
> bits_per_word = t->bits_per_word;
> @@ -228,26 +228,26 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi,
> struct spi_transfer *t)
> cs->rx_shift = 0;
> cs->tx_shift = 0;
> if (bits_per_word <= 8) {
> - cs->get_rx = mpc83xx_spi_rx_buf_u8;
> - cs->get_tx = mpc83xx_spi_tx_buf_u8;
> - if (mpc83xx_spi->qe_mode) {
> + cs->get_rx = mpc8xxx_spi_rx_buf_u8;
> + cs->get_tx = mpc8xxx_spi_tx_buf_u8;
> + if (mpc8xxx_spi->qe_mode) {
> cs->rx_shift = 16;
> cs->tx_shift = 24;
> }
> } else if (bits_per_word <= 16) {
> - cs->get_rx = mpc83xx_spi_rx_buf_u16;
> - cs->get_tx = mpc83xx_spi_tx_buf_u16;
> - if (mpc83xx_spi->qe_mode) {
> + cs->get_rx = mpc8xxx_spi_rx_buf_u16;
> + cs->get_tx = mpc8xxx_spi_tx_buf_u16;
> + if (mpc8xxx_spi->qe_mode) {
> cs->rx_shift = 16;
> cs->tx_shift = 16;
> }
> } else if (bits_per_word <= 32) {
> - cs->get_rx = mpc83xx_spi_rx_buf_u32;
> - cs->get_tx = mpc83xx_spi_tx_buf_u32;
> + cs->get_rx = mpc8xxx_spi_rx_buf_u32;
> + cs->get_tx = mpc8xxx_spi_tx_buf_u32;
> } else
> return -EINVAL;
>
> - if (mpc83xx_spi->qe_mode && spi->mode & SPI_LSB_FIRST) {
> + if (mpc8xxx_spi->qe_mode && spi->mode & SPI_LSB_FIRST) {
> cs->tx_shift = 0;
> if (bits_per_word <= 8)
> cs->rx_shift = 8;
> @@ -255,10 +255,10 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi,
> struct spi_transfer *t)
> cs->rx_shift = 0;
> }
>
> - mpc83xx_spi->rx_shift = cs->rx_shift;
> - mpc83xx_spi->tx_shift = cs->tx_shift;
> - mpc83xx_spi->get_rx = cs->get_rx;
> - mpc83xx_spi->get_tx = cs->get_tx;
> + mpc8xxx_spi->rx_shift = cs->rx_shift;
> + mpc8xxx_spi->tx_shift = cs->tx_shift;
> + mpc8xxx_spi->get_rx = cs->get_rx;
> + mpc8xxx_spi->get_tx = cs->get_tx;
>
> if (bits_per_word == 32)
> bits_per_word = 0;
> @@ -271,25 +271,25 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi,
> struct spi_transfer *t)
>
> cs->hw_mode |= SPMODE_LEN(bits_per_word);
>
> - if ((mpc83xx_spi->spibrg / hz) > 64) {
> + if ((mpc8xxx_spi->spibrg / hz) > 64) {
> cs->hw_mode |= SPMODE_DIV16;
> - pm = mpc83xx_spi->spibrg / (hz * 64);
> + pm = mpc8xxx_spi->spibrg / (hz * 64);
>
> WARN_ONCE(pm > 16, "%s: Requested speed is too low: %d Hz. "
> "Will use %d Hz instead.\n", dev_name(&spi->dev),
> - hz, mpc83xx_spi->spibrg / 1024);
> + hz, mpc8xxx_spi->spibrg / 1024);
> if (pm > 16)
> pm = 16;
> } else
> - pm = mpc83xx_spi->spibrg / (hz * 4);
> + pm = mpc8xxx_spi->spibrg / (hz * 4);
> if (pm)
> pm--;
>
> cs->hw_mode |= SPMODE_PM(pm);
> - regval = mpc83xx_spi_read_reg(&mpc83xx_spi->base->mode);
> + regval = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->mode);
> if (cs->hw_mode != regval) {
> unsigned long flags;
> - __be32 __iomem *mode = &mpc83xx_spi->base->mode;
> + __be32 __iomem *mode = &mpc8xxx_spi->base->mode;
>
> regval = cs->hw_mode;
> /* Turn off IRQs locally to minimize time
> @@ -297,22 +297,22 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi,
> struct spi_transfer *t)
> */
> local_irq_save(flags);
> /* Turn off SPI unit prior changing mode */
> - mpc83xx_spi_write_reg(mode, regval & ~SPMODE_ENABLE);
> - mpc83xx_spi_write_reg(mode, regval);
> + mpc8xxx_spi_write_reg(mode, regval & ~SPMODE_ENABLE);
> + mpc8xxx_spi_write_reg(mode, regval);
> local_irq_restore(flags);
> }
> return 0;
> }
>
> -static int mpc83xx_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
> +static int mpc8xxx_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
> {
> - struct mpc83xx_spi *mpc83xx_spi;
> + struct mpc8xxx_spi *mpc8xxx_spi;
> u32 word, len, bits_per_word;
>
> - mpc83xx_spi = spi_master_get_devdata(spi->master);
> + mpc8xxx_spi = spi_master_get_devdata(spi->master);
>
> - mpc83xx_spi->tx = t->tx_buf;
> - mpc83xx_spi->rx = t->rx_buf;
> + mpc8xxx_spi->tx = t->tx_buf;
> + mpc8xxx_spi->rx = t->rx_buf;
> bits_per_word = spi->bits_per_word;
> if (t->bits_per_word)
> bits_per_word = t->bits_per_word;
> @@ -329,26 +329,26 @@ static int mpc83xx_spi_bufs(struct spi_device *spi,
> struct spi_transfer *t)
> return -EINVAL;
> len /= 2;
> }
> - mpc83xx_spi->count = len;
> + mpc8xxx_spi->count = len;
>
> - INIT_COMPLETION(mpc83xx_spi->done);
> + INIT_COMPLETION(mpc8xxx_spi->done);
>
> /* enable rx ints */
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->mask, SPIM_NE);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mask, SPIM_NE);
>
> /* transmit word */
> - word = mpc83xx_spi->get_tx(mpc83xx_spi);
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->transmit, word);
> + word = mpc8xxx_spi->get_tx(mpc8xxx_spi);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->transmit, word);
>
> - wait_for_completion(&mpc83xx_spi->done);
> + wait_for_completion(&mpc8xxx_spi->done);
>
> /* disable rx ints */
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->mask, 0);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mask, 0);
>
> - return mpc83xx_spi->count;
> + return mpc8xxx_spi->count;
> }
>
> -static void mpc83xx_spi_do_one_msg(struct spi_message *m)
> +static void mpc8xxx_spi_do_one_msg(struct spi_message *m)
> {
> struct spi_device *spi = m->spi;
> struct spi_transfer *t;
> @@ -364,18 +364,18 @@ static void mpc83xx_spi_do_one_msg(struct spi_message
> *m)
> status = -EINVAL;
>
> if (cs_change)
> - status = mpc83xx_spi_setup_transfer(spi, t);
> + status = mpc8xxx_spi_setup_transfer(spi, t);
> if (status < 0)
> break;
> }
>
> if (cs_change) {
> - mpc83xx_spi_chipselect(spi, BITBANG_CS_ACTIVE);
> + mpc8xxx_spi_chipselect(spi, BITBANG_CS_ACTIVE);
> ndelay(nsecs);
> }
> cs_change = t->cs_change;
> if (t->len)
> - status = mpc83xx_spi_bufs(spi, t);
> + status = mpc8xxx_spi_bufs(spi, t);
> if (status) {
> status = -EMSGSIZE;
> break;
> @@ -387,7 +387,7 @@ static void mpc83xx_spi_do_one_msg(struct spi_message *m)
>
> if (cs_change) {
> ndelay(nsecs);
> - mpc83xx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
> + mpc8xxx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
> ndelay(nsecs);
> }
> }
> @@ -397,42 +397,42 @@ static void mpc83xx_spi_do_one_msg(struct spi_message
> *m)
>
> if (status || !cs_change) {
> ndelay(nsecs);
> - mpc83xx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
> + mpc8xxx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
> }
>
> - mpc83xx_spi_setup_transfer(spi, NULL);
> + mpc8xxx_spi_setup_transfer(spi, NULL);
> }
>
> -static void mpc83xx_spi_work(struct work_struct *work)
> +static void mpc8xxx_spi_work(struct work_struct *work)
> {
> - struct mpc83xx_spi *mpc83xx_spi = container_of(work, struct
> mpc83xx_spi,
> + struct mpc8xxx_spi *mpc8xxx_spi = container_of(work, struct
> mpc8xxx_spi,
> work);
>
> - spin_lock_irq(&mpc83xx_spi->lock);
> - while (!list_empty(&mpc83xx_spi->queue)) {
> - struct spi_message *m = container_of(mpc83xx_spi->queue.next,
> + spin_lock_irq(&mpc8xxx_spi->lock);
> + while (!list_empty(&mpc8xxx_spi->queue)) {
> + struct spi_message *m = container_of(mpc8xxx_spi->queue.next,
> struct spi_message, queue);
>
> list_del_init(&m->queue);
> - spin_unlock_irq(&mpc83xx_spi->lock);
> + spin_unlock_irq(&mpc8xxx_spi->lock);
>
> - mpc83xx_spi_do_one_msg(m);
> + mpc8xxx_spi_do_one_msg(m);
>
> - spin_lock_irq(&mpc83xx_spi->lock);
> + spin_lock_irq(&mpc8xxx_spi->lock);
> }
> - spin_unlock_irq(&mpc83xx_spi->lock);
> + spin_unlock_irq(&mpc8xxx_spi->lock);
> }
>
> /* the spi->mode bits understood by this driver: */
> #define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH \
> | SPI_LSB_FIRST | SPI_LOOP)
>
> -static int mpc83xx_spi_setup(struct spi_device *spi)
> +static int mpc8xxx_spi_setup(struct spi_device *spi)
> {
> - struct mpc83xx_spi *mpc83xx_spi;
> + struct mpc8xxx_spi *mpc8xxx_spi;
> int retval;
> u32 hw_mode;
> - struct spi_mpc83xx_cs *cs = spi->controller_state;
> + struct spi_mpc8xxx_cs *cs = spi->controller_state;
>
> if (spi->mode & ~MODEBITS) {
> dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
> @@ -449,13 +449,13 @@ static int mpc83xx_spi_setup(struct spi_device *spi)
> return -ENOMEM;
> spi->controller_state = cs;
> }
> - mpc83xx_spi = spi_master_get_devdata(spi->master);
> + mpc8xxx_spi = spi_master_get_devdata(spi->master);
>
> if (!spi->bits_per_word)
> spi->bits_per_word = 8;
>
> hw_mode = cs->hw_mode; /* Save orginal settings */
> - cs->hw_mode = mpc83xx_spi_read_reg(&mpc83xx_spi->base->mode);
> + cs->hw_mode = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->mode);
> /* mask out bits we are going to set */
> cs->hw_mode &= ~(SPMODE_CP_BEGIN_EDGECLK | SPMODE_CI_INACTIVEHIGH
> | SPMODE_REV | SPMODE_LOOP);
> @@ -469,7 +469,7 @@ static int mpc83xx_spi_setup(struct spi_device *spi)
> if (spi->mode & SPI_LOOP)
> cs->hw_mode |= SPMODE_LOOP;
>
> - retval = mpc83xx_spi_setup_transfer(spi, NULL);
> + retval = mpc8xxx_spi_setup_transfer(spi, NULL);
> if (retval < 0) {
> cs->hw_mode = hw_mode; /* Restore settings */
> return retval;
> @@ -481,21 +481,21 @@ static int mpc83xx_spi_setup(struct spi_device *spi)
> return 0;
> }
>
> -static irqreturn_t mpc83xx_spi_irq(s32 irq, void *context_data)
> +static irqreturn_t mpc8xxx_spi_irq(s32 irq, void *context_data)
> {
> - struct mpc83xx_spi *mpc83xx_spi = context_data;
> + struct mpc8xxx_spi *mpc8xxx_spi = context_data;
> u32 event;
> irqreturn_t ret = IRQ_NONE;
>
> /* Get interrupt events(tx/rx) */
> - event = mpc83xx_spi_read_reg(&mpc83xx_spi->base->event);
> + event = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->event);
>
> /* We need handle RX first */
> if (event & SPIE_NE) {
> - u32 rx_data =
> mpc83xx_spi_read_reg(&mpc83xx_spi->base->receive);
> + u32 rx_data =
> mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->receive);
>
> - if (mpc83xx_spi->rx)
> - mpc83xx_spi->get_rx(rx_data, mpc83xx_spi);
> + if (mpc8xxx_spi->rx)
> + mpc8xxx_spi->get_rx(rx_data, mpc8xxx_spi);
>
> ret = IRQ_HANDLED;
> }
> @@ -503,56 +503,56 @@ static irqreturn_t mpc83xx_spi_irq(s32 irq, void
> *context_data)
> if ((event & SPIE_NF) == 0)
> /* spin until TX is done */
> while (((event =
> - mpc83xx_spi_read_reg(&mpc83xx_spi->base->event)) &
> + mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->event)) &
> SPIE_NF) == 0)
> cpu_relax();
>
> - mpc83xx_spi->count -= 1;
> - if (mpc83xx_spi->count) {
> - u32 word = mpc83xx_spi->get_tx(mpc83xx_spi);
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->transmit, word);
> + mpc8xxx_spi->count -= 1;
> + if (mpc8xxx_spi->count) {
> + u32 word = mpc8xxx_spi->get_tx(mpc8xxx_spi);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->transmit, word);
> } else {
> - complete(&mpc83xx_spi->done);
> + complete(&mpc8xxx_spi->done);
> }
>
> /* Clear the events */
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->event, event);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->event, event);
>
> return ret;
> }
> -static int mpc83xx_spi_transfer(struct spi_device *spi,
> +static int mpc8xxx_spi_transfer(struct spi_device *spi,
> struct spi_message *m)
> {
> - struct mpc83xx_spi *mpc83xx_spi = spi_master_get_devdata(spi->master);
> + struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
> unsigned long flags;
>
> m->actual_length = 0;
> m->status = -EINPROGRESS;
>
> - spin_lock_irqsave(&mpc83xx_spi->lock, flags);
> - list_add_tail(&m->queue, &mpc83xx_spi->queue);
> - queue_work(mpc83xx_spi->workqueue, &mpc83xx_spi->work);
> - spin_unlock_irqrestore(&mpc83xx_spi->lock, flags);
> + spin_lock_irqsave(&mpc8xxx_spi->lock, flags);
> + list_add_tail(&m->queue, &mpc8xxx_spi->queue);
> + queue_work(mpc8xxx_spi->workqueue, &mpc8xxx_spi->work);
> + spin_unlock_irqrestore(&mpc8xxx_spi->lock, flags);
>
> return 0;
> }
>
>
> -static void mpc83xx_spi_cleanup(struct spi_device *spi)
> +static void mpc8xxx_spi_cleanup(struct spi_device *spi)
> {
> kfree(spi->controller_state);
> }
>
> static struct spi_master * __devinit
> -mpc83xx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
> +mpc8xxx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
> {
> struct fsl_spi_platform_data *pdata = dev->platform_data;
> struct spi_master *master;
> - struct mpc83xx_spi *mpc83xx_spi;
> + struct mpc8xxx_spi *mpc8xxx_spi;
> u32 regval;
> int ret = 0;
>
> - master = spi_alloc_master(dev, sizeof(struct mpc83xx_spi));
> + master = spi_alloc_master(dev, sizeof(struct mpc8xxx_spi));
> if (master == NULL) {
> ret = -ENOMEM;
> goto err;
> @@ -560,36 +560,36 @@ mpc83xx_spi_probe(struct device *dev, struct resource
> *mem, unsigned int irq)
>
> dev_set_drvdata(dev, master);
>
> - master->setup = mpc83xx_spi_setup;
> - master->transfer = mpc83xx_spi_transfer;
> - master->cleanup = mpc83xx_spi_cleanup;
> -
> - mpc83xx_spi = spi_master_get_devdata(master);
> - mpc83xx_spi->qe_mode = pdata->qe_mode;
> - mpc83xx_spi->get_rx = mpc83xx_spi_rx_buf_u8;
> - mpc83xx_spi->get_tx = mpc83xx_spi_tx_buf_u8;
> - mpc83xx_spi->spibrg = pdata->sysclk;
> -
> - mpc83xx_spi->rx_shift = 0;
> - mpc83xx_spi->tx_shift = 0;
> - if (mpc83xx_spi->qe_mode) {
> - mpc83xx_spi->rx_shift = 16;
> - mpc83xx_spi->tx_shift = 24;
> + master->setup = mpc8xxx_spi_setup;
> + master->transfer = mpc8xxx_spi_transfer;
> + master->cleanup = mpc8xxx_spi_cleanup;
> +
> + mpc8xxx_spi = spi_master_get_devdata(master);
> + mpc8xxx_spi->qe_mode = pdata->qe_mode;
> + mpc8xxx_spi->get_rx = mpc8xxx_spi_rx_buf_u8;
> + mpc8xxx_spi->get_tx = mpc8xxx_spi_tx_buf_u8;
> + mpc8xxx_spi->spibrg = pdata->sysclk;
> +
> + mpc8xxx_spi->rx_shift = 0;
> + mpc8xxx_spi->tx_shift = 0;
> + if (mpc8xxx_spi->qe_mode) {
> + mpc8xxx_spi->rx_shift = 16;
> + mpc8xxx_spi->tx_shift = 24;
> }
>
> - init_completion(&mpc83xx_spi->done);
> + init_completion(&mpc8xxx_spi->done);
>
> - mpc83xx_spi->base = ioremap(mem->start, mem->end - mem->start + 1);
> - if (mpc83xx_spi->base == NULL) {
> + mpc8xxx_spi->base = ioremap(mem->start, mem->end - mem->start + 1);
> + if (mpc8xxx_spi->base == NULL) {
> ret = -ENOMEM;
> goto put_master;
> }
>
> - mpc83xx_spi->irq = irq;
> + mpc8xxx_spi->irq = irq;
>
> /* Register for SPI Interrupt */
> - ret = request_irq(mpc83xx_spi->irq, mpc83xx_spi_irq,
> - 0, "mpc83xx_spi", mpc83xx_spi);
> + ret = request_irq(mpc8xxx_spi->irq, mpc8xxx_spi_irq,
> + 0, "mpc8xxx_spi", mpc8xxx_spi);
>
> if (ret != 0)
> goto unmap_io;
> @@ -598,25 +598,25 @@ mpc83xx_spi_probe(struct device *dev, struct resource
> *mem, unsigned int irq)
> master->num_chipselect = pdata->max_chipselect;
>
> /* SPI controller initializations */
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->mode, 0);
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->mask, 0);
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->command, 0);
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->event, 0xffffffff);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mode, 0);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mask, 0);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->command, 0);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->event, 0xffffffff);
>
> /* Enable SPI interface */
> regval = pdata->initial_spmode | SPMODE_INIT_VAL | SPMODE_ENABLE;
> if (pdata->qe_mode)
> regval |= SPMODE_OP;
>
> - mpc83xx_spi_write_reg(&mpc83xx_spi->base->mode, regval);
> - spin_lock_init(&mpc83xx_spi->lock);
> - init_completion(&mpc83xx_spi->done);
> - INIT_WORK(&mpc83xx_spi->work, mpc83xx_spi_work);
> - INIT_LIST_HEAD(&mpc83xx_spi->queue);
> + mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mode, regval);
> + spin_lock_init(&mpc8xxx_spi->lock);
> + init_completion(&mpc8xxx_spi->done);
> + INIT_WORK(&mpc8xxx_spi->work, mpc8xxx_spi_work);
> + INIT_LIST_HEAD(&mpc8xxx_spi->queue);
>
> - mpc83xx_spi->workqueue = create_singlethread_workqueue(
> + mpc8xxx_spi->workqueue = create_singlethread_workqueue(
> dev_name(master->dev.parent));
> - if (mpc83xx_spi->workqueue == NULL) {
> + if (mpc8xxx_spi->workqueue == NULL) {
> ret = -EBUSY;
> goto free_irq;
> }
> @@ -626,57 +626,57 @@ mpc83xx_spi_probe(struct device *dev, struct resource
> *mem, unsigned int irq)
> goto unreg_master;
>
> printk(KERN_INFO
> - "%s: MPC83xx SPI Controller driver at 0x%p (irq = %d)\n",
> - dev_name(dev), mpc83xx_spi->base, mpc83xx_spi->irq);
> + "%s: MPC8xxx SPI Controller driver at 0x%p (irq = %d)\n",
> + dev_name(dev), mpc8xxx_spi->base, mpc8xxx_spi->irq);
>
> return master;
>
> unreg_master:
> - destroy_workqueue(mpc83xx_spi->workqueue);
> + destroy_workqueue(mpc8xxx_spi->workqueue);
> free_irq:
> - free_irq(mpc83xx_spi->irq, mpc83xx_spi);
> + free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
> unmap_io:
> - iounmap(mpc83xx_spi->base);
> + iounmap(mpc8xxx_spi->base);
> put_master:
> spi_master_put(master);
> err:
> return ERR_PTR(ret);
> }
>
> -static int __devexit mpc83xx_spi_remove(struct device *dev)
> +static int __devexit mpc8xxx_spi_remove(struct device *dev)
> {
> - struct mpc83xx_spi *mpc83xx_spi;
> + struct mpc8xxx_spi *mpc8xxx_spi;
> struct spi_master *master;
>
> master = dev_get_drvdata(dev);
> - mpc83xx_spi = spi_master_get_devdata(master);
> + mpc8xxx_spi = spi_master_get_devdata(master);
>
> - flush_workqueue(mpc83xx_spi->workqueue);
> - destroy_workqueue(mpc83xx_spi->workqueue);
> + flush_workqueue(mpc8xxx_spi->workqueue);
> + destroy_workqueue(mpc8xxx_spi->workqueue);
> spi_unregister_master(master);
>
> - free_irq(mpc83xx_spi->irq, mpc83xx_spi);
> - iounmap(mpc83xx_spi->base);
> + free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
> + iounmap(mpc8xxx_spi->base);
>
> return 0;
> }
>
> -struct mpc83xx_spi_probe_info {
> +struct mpc8xxx_spi_probe_info {
> struct fsl_spi_platform_data pdata;
> int *gpios;
> bool *alow_flags;
> };
>
> -static struct mpc83xx_spi_probe_info *
> +static struct mpc8xxx_spi_probe_info *
> to_of_pinfo(struct fsl_spi_platform_data *pdata)
> {
> - return container_of(pdata, struct mpc83xx_spi_probe_info, pdata);
> + return container_of(pdata, struct mpc8xxx_spi_probe_info, pdata);
> }
>
> -static void mpc83xx_spi_cs_control(struct spi_device *spi, bool on)
> +static void mpc8xxx_spi_cs_control(struct spi_device *spi, bool on)
> {
> struct device *dev = spi->dev.parent;
> - struct mpc83xx_spi_probe_info *pinfo =
> to_of_pinfo(dev->platform_data);
> + struct mpc8xxx_spi_probe_info *pinfo =
> to_of_pinfo(dev->platform_data);
> u16 cs = spi->chip_select;
> int gpio = pinfo->gpios[cs];
> bool alow = pinfo->alow_flags[cs];
> @@ -684,11 +684,11 @@ static void mpc83xx_spi_cs_control(struct spi_device
> *spi, bool on)
> gpio_set_value(gpio, on ^ alow);
> }
>
> -static int of_mpc83xx_spi_get_chipselects(struct device *dev)
> +static int of_mpc8xxx_spi_get_chipselects(struct device *dev)
> {
> struct device_node *np = dev_archdata_get_node(&dev->archdata);
> struct fsl_spi_platform_data *pdata = dev->platform_data;
> - struct mpc83xx_spi_probe_info *pinfo = to_of_pinfo(pdata);
> + struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(pdata);
> unsigned int ngpios;
> int i = 0;
> int ret;
> @@ -744,7 +744,7 @@ static int of_mpc83xx_spi_get_chipselects(struct device
> *dev)
> }
>
> pdata->max_chipselect = ngpios;
> - pdata->cs_control = mpc83xx_spi_cs_control;
> + pdata->cs_control = mpc8xxx_spi_cs_control;
>
> return 0;
>
> @@ -763,10 +763,10 @@ err_alloc_flags:
> return ret;
> }
>
> -static int of_mpc83xx_spi_free_chipselects(struct device *dev)
> +static int of_mpc8xxx_spi_free_chipselects(struct device *dev)
> {
> struct fsl_spi_platform_data *pdata = dev->platform_data;
> - struct mpc83xx_spi_probe_info *pinfo = to_of_pinfo(pdata);
> + struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(pdata);
> int i;
>
> if (!pinfo->gpios)
> @@ -782,12 +782,12 @@ static int of_mpc83xx_spi_free_chipselects(struct
> device *dev)
> return 0;
> }
>
> -static int __devinit of_mpc83xx_spi_probe(struct of_device *ofdev,
> +static int __devinit of_mpc8xxx_spi_probe(struct of_device *ofdev,
> const struct of_device_id *ofid)
> {
> struct device *dev = &ofdev->dev;
> struct device_node *np = ofdev->node;
> - struct mpc83xx_spi_probe_info *pinfo;
> + struct mpc8xxx_spi_probe_info *pinfo;
> struct fsl_spi_platform_data *pdata;
> struct spi_master *master;
> struct resource mem;
> @@ -819,7 +819,7 @@ static int __devinit of_mpc83xx_spi_probe(struct
> of_device *ofdev,
> if (prop && !strcmp(prop, "cpu-qe"))
> pdata->qe_mode = 1;
>
> - ret = of_mpc83xx_spi_get_chipselects(dev);
> + ret = of_mpc8xxx_spi_get_chipselects(dev);
> if (ret)
> goto err;
>
> @@ -833,7 +833,7 @@ static int __devinit of_mpc83xx_spi_probe(struct
> of_device *ofdev,
> goto err;
> }
>
> - master = mpc83xx_spi_probe(dev, &mem, irq.start);
> + master = mpc8xxx_spi_probe(dev, &mem, irq.start);
> if (IS_ERR(master)) {
> ret = PTR_ERR(master);
> goto err;
> @@ -844,34 +844,34 @@ static int __devinit of_mpc83xx_spi_probe(struct
> of_device *ofdev,
> return 0;
>
> err:
> - of_mpc83xx_spi_free_chipselects(dev);
> + of_mpc8xxx_spi_free_chipselects(dev);
> err_clk:
> kfree(pinfo);
> return ret;
> }
>
> -static int __devexit of_mpc83xx_spi_remove(struct of_device *ofdev)
> +static int __devexit of_mpc8xxx_spi_remove(struct of_device *ofdev)
> {
> int ret;
>
> - ret = mpc83xx_spi_remove(&ofdev->dev);
> + ret = mpc8xxx_spi_remove(&ofdev->dev);
> if (ret)
> return ret;
> - of_mpc83xx_spi_free_chipselects(&ofdev->dev);
> + of_mpc8xxx_spi_free_chipselects(&ofdev->dev);
> return 0;
> }
>
> -static const struct of_device_id of_mpc83xx_spi_match[] = {
> +static const struct of_device_id of_mpc8xxx_spi_match[] = {
> { .compatible = "fsl,spi" },
> {},
> };
> -MODULE_DEVICE_TABLE(of, of_mpc83xx_spi_match);
> +MODULE_DEVICE_TABLE(of, of_mpc8xxx_spi_match);
>
> -static struct of_platform_driver of_mpc83xx_spi_driver = {
> - .name = "mpc83xx_spi",
> - .match_table = of_mpc83xx_spi_match,
> - .probe = of_mpc83xx_spi_probe,
> - .remove = __devexit_p(of_mpc83xx_spi_remove),
> +static struct of_platform_driver of_mpc8xxx_spi_driver = {
> + .name = "mpc8xxx_spi",
> + .match_table = of_mpc8xxx_spi_match,
> + .probe = of_mpc8xxx_spi_probe,
> + .remove = __devexit_p(of_mpc8xxx_spi_remove),
> };
>
> #ifdef CONFIG_MPC832x_RDB
> @@ -882,7 +882,7 @@ static struct of_platform_driver of_mpc83xx_spi_driver = {
> * tree can work with OpenFirmware driver. But for now we support old trees
> * as well.
> */
> -static int __devinit plat_mpc83xx_spi_probe(struct platform_device *pdev)
> +static int __devinit plat_mpc8xxx_spi_probe(struct platform_device *pdev)
> {
> struct resource *mem;
> unsigned int irq;
> @@ -899,21 +899,21 @@ static int __devinit plat_mpc83xx_spi_probe(struct
> platform_device *pdev)
> if (!irq)
> return -EINVAL;
>
> - master = mpc83xx_spi_probe(&pdev->dev, mem, irq);
> + master = mpc8xxx_spi_probe(&pdev->dev, mem, irq);
> if (IS_ERR(master))
> return PTR_ERR(master);
> return 0;
> }
>
> -static int __devexit plat_mpc83xx_spi_remove(struct platform_device *pdev)
> +static int __devexit plat_mpc8xxx_spi_remove(struct platform_device *pdev)
> {
> - return mpc83xx_spi_remove(&pdev->dev);
> + return mpc8xxx_spi_remove(&pdev->dev);
> }
>
> MODULE_ALIAS("platform:mpc83xx_spi");
> -static struct platform_driver mpc83xx_spi_driver = {
> - .probe = plat_mpc83xx_spi_probe,
> - .remove = __exit_p(plat_mpc83xx_spi_remove),
> +static struct platform_driver mpc8xxx_spi_driver = {
> + .probe = plat_mpc8xxx_spi_probe,
> + .remove = __exit_p(plat_mpc8xxx_spi_remove),
> .driver = {
> .name = "mpc83xx_spi",
> .owner = THIS_MODULE,
> @@ -924,35 +924,35 @@ static bool legacy_driver_failed;
>
> static void __init legacy_driver_register(void)
> {
> - legacy_driver_failed = platform_driver_register(&mpc83xx_spi_driver);
> + legacy_driver_failed = platform_driver_register(&mpc8xxx_spi_driver);
> }
>
> static void __exit legacy_driver_unregister(void)
> {
> if (legacy_driver_failed)
> return;
> - platform_driver_unregister(&mpc83xx_spi_driver);
> + platform_driver_unregister(&mpc8xxx_spi_driver);
> }
> #else
> static void __init legacy_driver_register(void) {}
> static void __exit legacy_driver_unregister(void) {}
> #endif /* CONFIG_MPC832x_RDB */
>
> -static int __init mpc83xx_spi_init(void)
> +static int __init mpc8xxx_spi_init(void)
> {
> legacy_driver_register();
> - return of_register_platform_driver(&of_mpc83xx_spi_driver);
> + return of_register_platform_driver(&of_mpc8xxx_spi_driver);
> }
>
> -static void __exit mpc83xx_spi_exit(void)
> +static void __exit mpc8xxx_spi_exit(void)
> {
> - of_unregister_platform_driver(&of_mpc83xx_spi_driver);
> + of_unregister_platform_driver(&of_mpc8xxx_spi_driver);
> legacy_driver_unregister();
> }
>
> -module_init(mpc83xx_spi_init);
> -module_exit(mpc83xx_spi_exit);
> +module_init(mpc8xxx_spi_init);
> +module_exit(mpc8xxx_spi_exit);
>
> MODULE_AUTHOR("Kumar Gala");
> -MODULE_DESCRIPTION("Simple MPC83xx SPI Driver");
> +MODULE_DESCRIPTION("Simple MPC8xxx SPI Driver");
> MODULE_LICENSE("GPL");
> --
> 1.6.2.2
>
> ------------------------------------------------------------------------------
> Register Now & Save for Velocity, the Web Performance & Operations
> Conference from O'Reilly Media. Velocity features a full day of
> expert-led, hands-on workshops and two days of sessions from industry
> leaders in dedicated Performance & Operations tracks. Use code vel09scf
> and Save an extra 15% before 5/3. http://p.sf.net/sfu/velocityconf
> _______________________________________________
> spi-devel-general mailing list
> spi-devel-gene...@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/spi-devel-general
>
--
Grant Likely, B.Sc., P.Eng.
Secret Lab Technologies Ltd.
_______________________________________________
Linuxppc-dev mailing list
Linuxppc-dev@ozlabs.org
https://ozlabs.org/mailman/listinfo/linuxppc-dev
