Subversion Repositories tiny_spi

/*

 * Opencore tiny_spi driver

 *

 * Copyright (C) 2011 Thomas Chou <thomas@wytron.com.tw>

 *

 * Based on spi_s3c24xx.c, which is:

 * Copyright (c) 2006 Ben Dooks

 * Copyright (c) 2006 Simtec Electronics

 *      Ben Dooks <ben@simtec.co.uk>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */

#include <linux/init.h>

#include <linux/spinlock.h>

#include <linux/interrupt.h>

#include <linux/delay.h>

#include <linux/errno.h>

#include <linux/err.h>

#include <linux/clk.h>

#include <linux/platform_device.h>

#include <linux/spi/spi.h>

#include <linux/spi/spi_bitbang.h>

#include <linux/io.h>

#include <linux/gpio.h>

#define DRV_NAME "oc_tiny_spi"

#define TINY_SPI_RXDATA 0

#define TINY_SPI_TXDATA 4

#define TINY_SPI_STATUS 8

#define TINY_SPI_CONTROL        12

#define TINY_SPI_BAUD   16

#define TINY_SPI_STATUS_TXE 0x1

#define TINY_SPI_STATUS_TXR 0x2

struct tiny_spi {

        /* bitbang has to be first */

        struct spi_bitbang bitbang;

        struct completion done;

        void __iomem *base;

        int irq;

        uint freq;

        uint baudwidth;

        uint baud;

        uint speed_hz;

        struct spi_master *master;

        struct resource *ioarea;

        struct device *dev;

};

static inline struct tiny_spi *to_hw(struct spi_device *sdev)

{

        return spi_master_get_devdata(sdev->master);

}

static uint tiny_spi_baud(struct spi_device *spi, uint hz)

{

        struct tiny_spi *hw = to_hw(spi);

        uint baud;

        baud = DIV_ROUND_UP(hw->freq, hz * 2) - 1;

        if (baud > (1 << hw->baudwidth) - 1)

                baud = (1 << hw->baudwidth) - 1;

        return baud;

}

static void tiny_spi_chipselect(struct spi_device *spi, int is_active)

{

        gpio_set_value(spi->chip_select, (spi->mode & SPI_CS_HIGH) ? is_active : !is_active);

}

static int tiny_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)

{

        struct tiny_spi *hw = to_hw(spi);

        uint baud = hw->baud;

        if (t) {

                dev_dbg(&spi->dev, "%s: %u bpw, %d hz\n",

                        __func__, t->bits_per_word, t->speed_hz);

                if (t->speed_hz && t->speed_hz != hw->speed_hz)

                        baud = tiny_spi_baud(spi, t->speed_hz);

        }

        writel(baud, hw->base + TINY_SPI_BAUD);

        return 0;

}

static int tiny_spi_setup(struct spi_device *spi)

{

        struct tiny_spi *hw = to_hw(spi);

        dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz\n",

                __func__, spi->mode, spi->bits_per_word, spi->max_speed_hz);

        if (spi->max_speed_hz != hw->speed_hz) {

                hw->speed_hz = spi->max_speed_hz;

                hw->baud = tiny_spi_baud(spi, hw->speed_hz);

        }

        return 0;

}

#ifndef CONFIG_TINY_SPI_IDLE_VAL

# define CONFIG_TINY_SPI_IDLE_VAL 0xff

#endif

static int tiny_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)

{

        struct tiny_spi *hw = to_hw(spi);

        const u8 *txp = t->tx_buf;

        u8 *rxp = t->rx_buf;

        uint i;

        dev_dbg(&spi->dev, "%s: tx %p, rx %p, len %d\n",

                __func__, t->tx_buf, t->rx_buf, t->len);

        /* we need to tighten the transfer loop */

        if (txp && rxp) {

                writeb(*txp++, hw->base + TINY_SPI_TXDATA);

                if (t->len > 1) {

                        writeb(*txp++, hw->base + TINY_SPI_TXDATA);

                        for (i = 2; i < t->len; i++) {

                                u8 rx, tx = *txp++;

                                while (!(readb(hw->base + TINY_SPI_STATUS) &

                                         TINY_SPI_STATUS_TXR))

                                        cpu_relax();

                                rx = readb(hw->base + TINY_SPI_TXDATA);

                                writeb(tx, hw->base + TINY_SPI_TXDATA);

                                *rxp++ = rx;

                        }

                        while (!(readb(hw->base + TINY_SPI_STATUS) &

                                 TINY_SPI_STATUS_TXR))

                                cpu_relax();

                        *rxp++ = readb(hw->base + TINY_SPI_TXDATA);

                }

                while (!(readb(hw->base + TINY_SPI_STATUS) &

                         TINY_SPI_STATUS_TXE))

                        cpu_relax();

                *rxp++ = readb(hw->base + TINY_SPI_RXDATA);

        } else if (rxp) {

                writeb(CONFIG_TINY_SPI_IDLE_VAL, hw->base + TINY_SPI_TXDATA);

                if (t->len > 1) {

                        writeb(CONFIG_TINY_SPI_IDLE_VAL,

                               hw->base + TINY_SPI_TXDATA);

                        for (i = 2; i < t->len; i++) {

                                u8 rx;

                                while (!(readb(hw->base + TINY_SPI_STATUS) &

                                         TINY_SPI_STATUS_TXR))

                                        cpu_relax();

                                rx = readb(hw->base + TINY_SPI_TXDATA);

                                writeb(CONFIG_TINY_SPI_IDLE_VAL,

                                       hw->base + TINY_SPI_TXDATA);

                                *rxp++ = rx;

                        }

                        while (!(readb(hw->base + TINY_SPI_STATUS) &

                                 TINY_SPI_STATUS_TXR))

                                cpu_relax();

                        *rxp++ = readb(hw->base + TINY_SPI_TXDATA);

                }

                while (!(readb(hw->base + TINY_SPI_STATUS) &

                         TINY_SPI_STATUS_TXE))

                        cpu_relax();

                *rxp++ = readb(hw->base + TINY_SPI_RXDATA);

        } else if (txp) {

                writeb(*txp++, hw->base + TINY_SPI_TXDATA);

                if (t->len > 1) {

                        writeb(*txp++, hw->base + TINY_SPI_TXDATA);

                        for (i = 2; i < t->len; i++) {

                                u8 tx = *txp++;

                                while (!(readb(hw->base + TINY_SPI_STATUS) &

                                         TINY_SPI_STATUS_TXR))

                                        cpu_relax();

                                writeb(tx, hw->base + TINY_SPI_TXDATA);

                        }

                }

                while (!(readb(hw->base + TINY_SPI_STATUS) &

                         TINY_SPI_STATUS_TXE))

                        cpu_relax();

        } else {

                writeb(CONFIG_TINY_SPI_IDLE_VAL, hw->base + TINY_SPI_TXDATA);

                if (t->len > 1) {

                        writeb(CONFIG_TINY_SPI_IDLE_VAL,

                               hw->base + TINY_SPI_TXDATA);

                        for (i = 2; i < t->len; i++) {

                                while (!(readb(hw->base + TINY_SPI_STATUS) &

                                         TINY_SPI_STATUS_TXR))

                                        cpu_relax();

                                writeb(CONFIG_TINY_SPI_IDLE_VAL,

                                       hw->base + TINY_SPI_TXDATA);

                        }

                }

                while (!(readb(hw->base + TINY_SPI_STATUS) &

                         TINY_SPI_STATUS_TXE))

                        cpu_relax();

        }

        return t->len;

}

static irqreturn_t tiny_spi_irq(int irq, void *dev)

{

        struct tiny_spi *hw = dev;

        writeb(0, hw->base + TINY_SPI_STATUS);

        complete(&hw->done);

        return IRQ_HANDLED;

}

static int __init tiny_spi_probe(struct platform_device *pdev)

{

        struct tiny_spi *hw;

        struct spi_master *master;

        struct resource *res;

        int err = 0;

        master = spi_alloc_master(&pdev->dev, sizeof(struct tiny_spi));

        if (master == NULL) {

                dev_err(&pdev->dev, "No memory for spi_master\n");

                err = -ENOMEM;

                goto err_nomem;

        }

        hw = spi_master_get_devdata(master);

        memset(hw, 0, sizeof(struct tiny_spi));

        hw->master = spi_master_get(master);

        hw->dev = &pdev->dev;

        platform_set_drvdata(pdev, hw);

        init_completion(&hw->done);

        /* setup the master state. */

        master->bus_num = pdev->id;

        master->num_chipselect = 256;

        master->mode_bits = SPI_CS_HIGH;

        /* setup the state for the bitbang driver */

        hw->bitbang.master = hw->master;

        hw->bitbang.setup_transfer = tiny_spi_setup_transfer;

        hw->bitbang.chipselect = tiny_spi_chipselect;

        hw->bitbang.txrx_bufs = tiny_spi_txrx_bufs;

        hw->bitbang.master->setup = tiny_spi_setup;

        dev_dbg(hw->dev, "bitbang at %p\n", &hw->bitbang);

        /* find and map our resources */

        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

        if (res == NULL) {

                dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");

                err = -ENOENT;

                goto err_no_iores;

        }

        hw->ioarea = request_mem_region(res->start, (res->end - res->start) + 1,

                                        pdev->name);

        if (hw->ioarea == NULL) {

                dev_err(&pdev->dev, "Cannot reserve region\n");

                err = -ENXIO;

                goto err_no_iores;

        }

        hw->base =

            ioremap(res->start, (res->end - res->start) + 1);

        if (hw->base == 0) {

                dev_err(&pdev->dev, "Cannot map IO\n");

                err = -ENXIO;

                goto err_no_iomap;

        }

        hw->irq = platform_get_irq(pdev, 0);

        if (hw->irq < 0) {

                dev_err(&pdev->dev, "No IRQ specified\n");

                err = -ENOENT;

                goto err_no_irq;

        }

        err = request_irq(hw->irq, tiny_spi_irq, 0, pdev->name, hw);

        if (err) {

                dev_err(&pdev->dev, "Cannot claim IRQ\n");

                goto err_no_irq;

        }

        hw->freq = 100000000;

        hw->baudwidth = 7;

        hw->baud = 1;

        dev_info(hw->dev, "base %p, irq %d\n", hw->base, hw->irq);

        /* register our spi controller */

        err = spi_bitbang_start(&hw->bitbang);

        if (err) {

                dev_err(&pdev->dev, "Failed to register SPI master\n");

                goto err_register;

        }

        return 0;

err_register:

        free_irq(hw->irq, hw);

err_no_irq:

        iounmap((void *)hw->base);

err_no_iomap:

        release_resource(hw->ioarea);

        kfree(hw->ioarea);

err_no_iores:

        spi_master_put(hw->master);;

err_nomem:

        return err;

}

static int __exit tiny_spi_remove(struct platform_device *dev)

{

        struct tiny_spi *hw = platform_get_drvdata(dev);

        platform_set_drvdata(dev, NULL);

        spi_unregister_master(hw->master);

        free_irq(hw->irq, hw);

        iounmap((void *)hw->base);

        release_resource(hw->ioarea);

        kfree(hw->ioarea);

        spi_master_put(hw->master);

        return 0;

}

static struct platform_driver tiny_spidrv = {

        .remove = __exit_p(tiny_spi_remove),

        .driver = {

                .name = DRV_NAME,

                .owner = THIS_MODULE,

                .pm = NULL,

        },

};

static int __init tiny_spi_init(void)

{

        return platform_driver_probe(&tiny_spidrv, tiny_spi_probe);

}

static void __exit tiny_spi_exit(void)

{

        platform_driver_unregister(&tiny_spidrv);

}

module_init(tiny_spi_init);

module_exit(tiny_spi_exit);

MODULE_DESCRIPTION("Opencore tiny_spi driver");

MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:" DRV_NAME);