OpenCores
URL https://opencores.org/ocsvn/tiny_spi/tiny_spi/trunk

Subversion Repositories tiny_spi

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /tiny_spi
    from Rev 9 to Rev 10
    ↔ Reverse comparison
  •

Rev 9 → Rev 10

/trunk/driver/linux-2.6/oc_tiny_spi.c
1,6 → 1,8
/*
* Opencore tiny_spi driver
* OpenCores tiny SPI master driver
*
* http://opencores.org/project,tiny_spi
*
* Copyright (C) 2011 Thomas Chou <thomas@wytron.com.tw>
*
* Based on spi_s3c24xx.c, which is:
12,6 → 14,7
* 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>
22,16 → 25,18
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <linux/spi/spi_bitbang.h>
#include <linux/spi/oc_tiny_spi.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/of.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_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
43,14 → 48,16
 
void __iomem *base;
int irq;
uint freq;
uint baudwidth;
uint baud;
uint speed_hz;
 
struct spi_master *master;
struct resource *ioarea;
struct device *dev;
unsigned int freq;
unsigned int baudwidth;
int interrupt; /* use interrupt driven data transfer, slow */
unsigned int baud;
unsigned int speed_hz;
unsigned int mode;
unsigned int len;
unsigned int txc, rxc;
const u8 *txp;
u8 *rxp;
};
 
static inline struct tiny_spi *to_hw(struct spi_device *sdev)
58,32 → 65,31
return spi_master_get_devdata(sdev->master);
}
 
static uint tiny_spi_baud(struct spi_device *spi, uint hz)
static unsigned int tiny_spi_baud(struct spi_device *spi, unsigned int 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;
 
return min(DIV_ROUND_UP(hw->freq, hz * 2), (1U << hw->baudwidth)) - 1;
}
 
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);
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)
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;
unsigned int 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);
writel(hw->mode, hw->base + TINY_SPI_CONTROL);
return 0;
}
 
91,17 → 97,16
{
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);
}
hw->mode = spi->mode & (SPI_CPOL | SPI_CPHA);
return 0;
}
 
#ifndef CONFIG_TINY_SPI_IDLE_VAL
# define CONFIG_TINY_SPI_IDLE_VAL 0xff
# define CONFIG_TINY_SPI_IDLE_VAL 0x00
#endif
 
static int tiny_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)
109,13 → 114,36
struct tiny_spi *hw = to_hw(spi);
const u8 *txp = t->tx_buf;
u8 *rxp = t->rx_buf;
uint i;
unsigned int i;
 
dev_dbg(&spi->dev, "%s: tx %p, rx %p, len %d\n",
__func__, t->tx_buf, t->rx_buf, t->len);
if (hw->irq >= 0 && hw->interrupt) {
/* use intrrupt driven data transfer */
hw->len = t->len;
hw->txp = t->tx_buf;
hw->rxp = t->rx_buf;
hw->txc = 0;
hw->rxc = 0;
init_completion(&hw->done);
 
/* we need to tighten the transfer loop */
if (txp && rxp) {
/* send the first byte */
if (t->len > 1) {
writeb(hw->txp ? *hw->txp++ : CONFIG_TINY_SPI_IDLE_VAL,
hw->base + TINY_SPI_TXDATA);
hw->txc++;
writeb(hw->txp ? *hw->txp++ : CONFIG_TINY_SPI_IDLE_VAL,
hw->base + TINY_SPI_TXDATA);
hw->txc++;
writeb(TINY_SPI_STATUS_TXR, hw->base + TINY_SPI_STATUS);
} else {
writeb(hw->txp ? *hw->txp++ : CONFIG_TINY_SPI_IDLE_VAL,
hw->base + TINY_SPI_TXDATA);
hw->txc++;
writeb(TINY_SPI_STATUS_TXE, hw->base + TINY_SPI_STATUS);
}
 
wait_for_completion(&hw->done);
} else if (txp && rxp) {
/* we need to tighten the transfer loop */
writeb(*txp++, hw->base + TINY_SPI_TXDATA);
if (t->len > 1) {
writeb(*txp++, hw->base + TINY_SPI_TXDATA);
199,13 → 227,60
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);
if (hw->rxc + 1 == hw->len) {
if (hw->rxp)
*hw->rxp++ = readb(hw->base + TINY_SPI_RXDATA);
hw->rxc++;
complete(&hw->done);
} else {
if (hw->rxp)
*hw->rxp++ = readb(hw->base + TINY_SPI_TXDATA);
hw->rxc++;
if (hw->txc < hw->len) {
writeb(hw->txp ? *hw->txp++ : CONFIG_TINY_SPI_IDLE_VAL,
hw->base + TINY_SPI_TXDATA);
hw->txc++;
writeb(TINY_SPI_STATUS_TXR,
hw->base + TINY_SPI_STATUS);
} else {
writeb(TINY_SPI_STATUS_TXE,
hw->base + TINY_SPI_STATUS);
}
}
return IRQ_HANDLED;
}
 
static int __init tiny_spi_probe(struct platform_device *pdev)
#ifdef CONFIG_OF
static int __devinit tiny_spi_of_probe(struct platform_device *pdev,
struct tiny_spi *hw)
{
const __be32 *val;
 
hw->bitbang.master->dev.of_node = pdev->dev.of_node;
val = of_get_property(pdev->dev.of_node, "baud-width", NULL);
if (val)
hw->baudwidth = be32_to_cpup(val);
val = of_get_property(pdev->dev.of_node, "clock-frequency", NULL);
if (val)
hw->freq = be32_to_cpup(val);
val = of_get_property(pdev->dev.of_node, "interrupt-driven", NULL);
if (val)
hw->interrupt = be32_to_cpup(val);
return 0;
}
#else
static int __devinit tiny_spi_of_probe(struct platform_device *pdev,
struct tiny_spi *hw)
{
return 0;
}
#endif
 
static int __devinit tiny_spi_probe(struct platform_device *pdev)
{
struct tiny_spi_platform_data *platp = pdev->dev.platform_data;
struct tiny_spi *hw;
struct spi_master *master;
struct resource *res;
215,35 → 290,30
if (master == NULL) {
dev_err(&pdev->dev, "No memory for spi_master\n");
err = -ENOMEM;
goto err_nomem;
goto err_no_mem;
}
 
/* setup the master state. */
master->bus_num = pdev->id;
master->num_chipselect = 255;
master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
master->setup = tiny_spi_setup;
 
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.master = spi_master_get(master);
if (hw->bitbang.master == NULL) {
dev_err(&pdev->dev, "Cannot get device\n");
err = -ENODEV;
goto err_no_dev;
}
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");
250,43 → 320,33
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);
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;
}
 
/* irq is optional */
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;
if (hw->irq >= 0) {
init_completion(&hw->done);
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;
}
}
 
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;
/* find platform data */
if (platp) {
hw->freq = platp->freq;
hw->baudwidth = platp->baudwidth;
hw->interrupt = platp->interrupt;
} else {
err = tiny_spi_of_probe(pdev, hw);
if (err)
goto err_no_of;
}
 
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) {
293,46 → 353,59
dev_err(&pdev->dev, "Failed to register SPI master\n");
goto err_register;
}
dev_info(&pdev->dev, "base %p, irq %d\n", hw->base, hw->irq);
 
return 0;
 
err_register:
free_irq(hw->irq, hw);
if (hw->irq >= 0)
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:
spi_master_put(master);
err_no_mem:
err_no_of:
err_no_dev:
return err;
}
 
static int __exit tiny_spi_remove(struct platform_device *dev)
static int __devexit tiny_spi_remove(struct platform_device *dev)
{
struct tiny_spi *hw = platform_get_drvdata(dev);
struct spi_master *master = hw->bitbang.master;
 
platform_set_drvdata(dev, NULL);
spi_bitbang_stop(&hw->bitbang);
 
spi_unregister_master(hw->master);
 
free_irq(hw->irq, hw);
if (hw->irq >= 0)
free_irq(hw->irq, hw);
iounmap((void *)hw->base);
 
release_resource(hw->ioarea);
kfree(hw->ioarea);
 
spi_master_put(hw->master);
platform_set_drvdata(dev, NULL);
spi_master_put(master);
return 0;
}
 
#ifdef CONFIG_OF
static struct of_device_id oc_tiny_spi_match[] = {
{
.compatible = "opencores,oc_tiny_spi",
},
{},
}
MODULE_DEVICE_TABLE(of, oc_tiny_spi_match);
#endif
 
static struct platform_driver tiny_spidrv = {
.remove = __exit_p(tiny_spi_remove),
.remove = __devexit_p(tiny_spi_remove),
.driver = {
.name = DRV_NAME,
.owner = THIS_MODULE,
.pm = NULL,
#ifdef CONFIG_OF
.of_match_table = oc_tiny_spi_match,
#endif
},
};
 
349,7 → 422,7
module_init(tiny_spi_init);
module_exit(tiny_spi_exit);
 
MODULE_DESCRIPTION("Opencore tiny_spi driver");
MODULE_DESCRIPTION("OpenCores tiny SPI driver");
MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:" DRV_NAME);
/trunk/driver/linux-2.6/oc_tiny_spi.h
0,0 → 1,16
#ifndef _LINUX_SPI_OC_TINY_SPI_H
#define _LINUX_SPI_OC_TINY_SPI_H
 
/**
* struct tiny_spi_platform_data - platform data of the OpenCores tiny SPI
* @freq: input clock freq to the core.
* @baudwidth: baud rate divider width of the core.
* @interrupt: use intrrupt driven data transfer.
*/
struct tiny_spi_platform_data {
uint freq;
uint baudwidth;
int interrupt;
};
 
#endif /* _LINUX_SPI_OC_TINY_SPI_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.