mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-27 10:35:08 +07:00
cea3d7cd95
[ Upstream commit 55a8b42e8645a6dab88674a30cb6ed328e660680 ]
Release master that have been previously allocated if the number of
chipselect is invalid.
Fixes: 8e04187c1b ("spi: altera: add SPI core parameters support via platform data.")
Signed-off-by: Pan Bian <bianpan2016@163.com>
Reviewed-by: Tom Rix <trix@redhat.com>
Link: https://lore.kernel.org/r/20210120082635.49304-1-bianpan2016@163.com
Signed-off-by: Mark Brown <broonie@kernel.org>
Signed-off-by: Sasha Levin <sashal@kernel.org>
379 lines
8.5 KiB
C
379 lines
8.5 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Altera SPI driver
|
|
*
|
|
* Copyright (C) 2008 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>
|
|
*/
|
|
|
|
#include <linux/interrupt.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/spi/altera.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/io.h>
|
|
#include <linux/of.h>
|
|
|
|
#define DRV_NAME "spi_altera"
|
|
|
|
#define ALTERA_SPI_RXDATA 0
|
|
#define ALTERA_SPI_TXDATA 4
|
|
#define ALTERA_SPI_STATUS 8
|
|
#define ALTERA_SPI_CONTROL 12
|
|
#define ALTERA_SPI_SLAVE_SEL 20
|
|
|
|
#define ALTERA_SPI_STATUS_ROE_MSK 0x8
|
|
#define ALTERA_SPI_STATUS_TOE_MSK 0x10
|
|
#define ALTERA_SPI_STATUS_TMT_MSK 0x20
|
|
#define ALTERA_SPI_STATUS_TRDY_MSK 0x40
|
|
#define ALTERA_SPI_STATUS_RRDY_MSK 0x80
|
|
#define ALTERA_SPI_STATUS_E_MSK 0x100
|
|
|
|
#define ALTERA_SPI_CONTROL_IROE_MSK 0x8
|
|
#define ALTERA_SPI_CONTROL_ITOE_MSK 0x10
|
|
#define ALTERA_SPI_CONTROL_ITRDY_MSK 0x40
|
|
#define ALTERA_SPI_CONTROL_IRRDY_MSK 0x80
|
|
#define ALTERA_SPI_CONTROL_IE_MSK 0x100
|
|
#define ALTERA_SPI_CONTROL_SSO_MSK 0x400
|
|
|
|
#define ALTERA_SPI_MAX_CS 32
|
|
|
|
enum altera_spi_type {
|
|
ALTERA_SPI_TYPE_UNKNOWN,
|
|
ALTERA_SPI_TYPE_SUBDEV,
|
|
};
|
|
|
|
struct altera_spi {
|
|
int irq;
|
|
int len;
|
|
int count;
|
|
int bytes_per_word;
|
|
u32 imr;
|
|
|
|
/* data buffers */
|
|
const unsigned char *tx;
|
|
unsigned char *rx;
|
|
|
|
struct regmap *regmap;
|
|
u32 regoff;
|
|
struct device *dev;
|
|
};
|
|
|
|
static const struct regmap_config spi_altera_config = {
|
|
.reg_bits = 32,
|
|
.reg_stride = 4,
|
|
.val_bits = 32,
|
|
.fast_io = true,
|
|
};
|
|
|
|
static int altr_spi_writel(struct altera_spi *hw, unsigned int reg,
|
|
unsigned int val)
|
|
{
|
|
int ret;
|
|
|
|
ret = regmap_write(hw->regmap, hw->regoff + reg, val);
|
|
if (ret)
|
|
dev_err(hw->dev, "fail to write reg 0x%x val 0x%x: %d\n",
|
|
reg, val, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int altr_spi_readl(struct altera_spi *hw, unsigned int reg,
|
|
unsigned int *val)
|
|
{
|
|
int ret;
|
|
|
|
ret = regmap_read(hw->regmap, hw->regoff + reg, val);
|
|
if (ret)
|
|
dev_err(hw->dev, "fail to read reg 0x%x: %d\n", reg, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline struct altera_spi *altera_spi_to_hw(struct spi_device *sdev)
|
|
{
|
|
return spi_master_get_devdata(sdev->master);
|
|
}
|
|
|
|
static void altera_spi_set_cs(struct spi_device *spi, bool is_high)
|
|
{
|
|
struct altera_spi *hw = altera_spi_to_hw(spi);
|
|
|
|
if (is_high) {
|
|
hw->imr &= ~ALTERA_SPI_CONTROL_SSO_MSK;
|
|
altr_spi_writel(hw, ALTERA_SPI_CONTROL, hw->imr);
|
|
altr_spi_writel(hw, ALTERA_SPI_SLAVE_SEL, 0);
|
|
} else {
|
|
altr_spi_writel(hw, ALTERA_SPI_SLAVE_SEL,
|
|
BIT(spi->chip_select));
|
|
hw->imr |= ALTERA_SPI_CONTROL_SSO_MSK;
|
|
altr_spi_writel(hw, ALTERA_SPI_CONTROL, hw->imr);
|
|
}
|
|
}
|
|
|
|
static void altera_spi_tx_word(struct altera_spi *hw)
|
|
{
|
|
unsigned int txd = 0;
|
|
|
|
if (hw->tx) {
|
|
switch (hw->bytes_per_word) {
|
|
case 1:
|
|
txd = hw->tx[hw->count];
|
|
break;
|
|
case 2:
|
|
txd = (hw->tx[hw->count * 2]
|
|
| (hw->tx[hw->count * 2 + 1] << 8));
|
|
break;
|
|
case 4:
|
|
txd = (hw->tx[hw->count * 4]
|
|
| (hw->tx[hw->count * 4 + 1] << 8)
|
|
| (hw->tx[hw->count * 4 + 2] << 16)
|
|
| (hw->tx[hw->count * 4 + 3] << 24));
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
altr_spi_writel(hw, ALTERA_SPI_TXDATA, txd);
|
|
}
|
|
|
|
static void altera_spi_rx_word(struct altera_spi *hw)
|
|
{
|
|
unsigned int rxd;
|
|
|
|
altr_spi_readl(hw, ALTERA_SPI_RXDATA, &rxd);
|
|
if (hw->rx) {
|
|
switch (hw->bytes_per_word) {
|
|
case 1:
|
|
hw->rx[hw->count] = rxd;
|
|
break;
|
|
case 2:
|
|
hw->rx[hw->count * 2] = rxd;
|
|
hw->rx[hw->count * 2 + 1] = rxd >> 8;
|
|
break;
|
|
case 4:
|
|
hw->rx[hw->count * 4] = rxd;
|
|
hw->rx[hw->count * 4 + 1] = rxd >> 8;
|
|
hw->rx[hw->count * 4 + 2] = rxd >> 16;
|
|
hw->rx[hw->count * 4 + 3] = rxd >> 24;
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
hw->count++;
|
|
}
|
|
|
|
static int altera_spi_txrx(struct spi_master *master,
|
|
struct spi_device *spi, struct spi_transfer *t)
|
|
{
|
|
struct altera_spi *hw = spi_master_get_devdata(master);
|
|
u32 val;
|
|
|
|
hw->tx = t->tx_buf;
|
|
hw->rx = t->rx_buf;
|
|
hw->count = 0;
|
|
hw->bytes_per_word = DIV_ROUND_UP(t->bits_per_word, 8);
|
|
hw->len = t->len / hw->bytes_per_word;
|
|
|
|
if (hw->irq >= 0) {
|
|
/* enable receive interrupt */
|
|
hw->imr |= ALTERA_SPI_CONTROL_IRRDY_MSK;
|
|
altr_spi_writel(hw, ALTERA_SPI_CONTROL, hw->imr);
|
|
|
|
/* send the first byte */
|
|
altera_spi_tx_word(hw);
|
|
|
|
return 1;
|
|
}
|
|
|
|
while (hw->count < hw->len) {
|
|
altera_spi_tx_word(hw);
|
|
|
|
for (;;) {
|
|
altr_spi_readl(hw, ALTERA_SPI_STATUS, &val);
|
|
if (val & ALTERA_SPI_STATUS_RRDY_MSK)
|
|
break;
|
|
|
|
cpu_relax();
|
|
}
|
|
|
|
altera_spi_rx_word(hw);
|
|
}
|
|
spi_finalize_current_transfer(master);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static irqreturn_t altera_spi_irq(int irq, void *dev)
|
|
{
|
|
struct spi_master *master = dev;
|
|
struct altera_spi *hw = spi_master_get_devdata(master);
|
|
|
|
altera_spi_rx_word(hw);
|
|
|
|
if (hw->count < hw->len) {
|
|
altera_spi_tx_word(hw);
|
|
} else {
|
|
/* disable receive interrupt */
|
|
hw->imr &= ~ALTERA_SPI_CONTROL_IRRDY_MSK;
|
|
altr_spi_writel(hw, ALTERA_SPI_CONTROL, hw->imr);
|
|
|
|
spi_finalize_current_transfer(master);
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int altera_spi_probe(struct platform_device *pdev)
|
|
{
|
|
const struct platform_device_id *platid = platform_get_device_id(pdev);
|
|
struct altera_spi_platform_data *pdata = dev_get_platdata(&pdev->dev);
|
|
enum altera_spi_type type = ALTERA_SPI_TYPE_UNKNOWN;
|
|
struct altera_spi *hw;
|
|
struct spi_master *master;
|
|
int err = -ENODEV;
|
|
u32 val;
|
|
u16 i;
|
|
|
|
master = spi_alloc_master(&pdev->dev, sizeof(struct altera_spi));
|
|
if (!master)
|
|
return err;
|
|
|
|
/* setup the master state. */
|
|
master->bus_num = pdev->id;
|
|
|
|
if (pdata) {
|
|
if (pdata->num_chipselect > ALTERA_SPI_MAX_CS) {
|
|
dev_err(&pdev->dev,
|
|
"Invalid number of chipselect: %hu\n",
|
|
pdata->num_chipselect);
|
|
err = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
master->num_chipselect = pdata->num_chipselect;
|
|
master->mode_bits = pdata->mode_bits;
|
|
master->bits_per_word_mask = pdata->bits_per_word_mask;
|
|
} else {
|
|
master->num_chipselect = 16;
|
|
master->mode_bits = SPI_CS_HIGH;
|
|
master->bits_per_word_mask = SPI_BPW_RANGE_MASK(1, 16);
|
|
}
|
|
|
|
master->dev.of_node = pdev->dev.of_node;
|
|
master->transfer_one = altera_spi_txrx;
|
|
master->set_cs = altera_spi_set_cs;
|
|
|
|
hw = spi_master_get_devdata(master);
|
|
hw->dev = &pdev->dev;
|
|
|
|
if (platid)
|
|
type = platid->driver_data;
|
|
|
|
/* find and map our resources */
|
|
if (type == ALTERA_SPI_TYPE_SUBDEV) {
|
|
struct resource *regoff;
|
|
|
|
hw->regmap = dev_get_regmap(pdev->dev.parent, NULL);
|
|
if (!hw->regmap) {
|
|
dev_err(&pdev->dev, "get regmap failed\n");
|
|
goto exit;
|
|
}
|
|
|
|
regoff = platform_get_resource(pdev, IORESOURCE_REG, 0);
|
|
if (regoff)
|
|
hw->regoff = regoff->start;
|
|
} else {
|
|
void __iomem *res;
|
|
|
|
res = devm_platform_ioremap_resource(pdev, 0);
|
|
if (IS_ERR(res)) {
|
|
err = PTR_ERR(res);
|
|
goto exit;
|
|
}
|
|
|
|
hw->regmap = devm_regmap_init_mmio(&pdev->dev, res,
|
|
&spi_altera_config);
|
|
if (IS_ERR(hw->regmap)) {
|
|
dev_err(&pdev->dev, "regmap mmio init failed\n");
|
|
err = PTR_ERR(hw->regmap);
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
/* program defaults into the registers */
|
|
hw->imr = 0; /* disable spi interrupts */
|
|
altr_spi_writel(hw, ALTERA_SPI_CONTROL, hw->imr);
|
|
altr_spi_writel(hw, ALTERA_SPI_STATUS, 0); /* clear status reg */
|
|
altr_spi_readl(hw, ALTERA_SPI_STATUS, &val);
|
|
if (val & ALTERA_SPI_STATUS_RRDY_MSK)
|
|
altr_spi_readl(hw, ALTERA_SPI_RXDATA, &val); /* flush rxdata */
|
|
/* irq is optional */
|
|
hw->irq = platform_get_irq(pdev, 0);
|
|
if (hw->irq >= 0) {
|
|
err = devm_request_irq(&pdev->dev, hw->irq, altera_spi_irq, 0,
|
|
pdev->name, master);
|
|
if (err)
|
|
goto exit;
|
|
}
|
|
|
|
err = devm_spi_register_master(&pdev->dev, master);
|
|
if (err)
|
|
goto exit;
|
|
|
|
if (pdata) {
|
|
for (i = 0; i < pdata->num_devices; i++) {
|
|
if (!spi_new_device(master, pdata->devices + i))
|
|
dev_warn(&pdev->dev,
|
|
"unable to create SPI device: %s\n",
|
|
pdata->devices[i].modalias);
|
|
}
|
|
}
|
|
|
|
dev_info(&pdev->dev, "regoff %u, irq %d\n", hw->regoff, hw->irq);
|
|
|
|
return 0;
|
|
exit:
|
|
spi_master_put(master);
|
|
return err;
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
static const struct of_device_id altera_spi_match[] = {
|
|
{ .compatible = "ALTR,spi-1.0", },
|
|
{ .compatible = "altr,spi-1.0", },
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, altera_spi_match);
|
|
#endif /* CONFIG_OF */
|
|
|
|
static const struct platform_device_id altera_spi_ids[] = {
|
|
{ DRV_NAME, ALTERA_SPI_TYPE_UNKNOWN },
|
|
{ "subdev_spi_altera", ALTERA_SPI_TYPE_SUBDEV },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(platform, altera_spi_ids);
|
|
|
|
static struct platform_driver altera_spi_driver = {
|
|
.probe = altera_spi_probe,
|
|
.driver = {
|
|
.name = DRV_NAME,
|
|
.pm = NULL,
|
|
.of_match_table = of_match_ptr(altera_spi_match),
|
|
},
|
|
.id_table = altera_spi_ids,
|
|
};
|
|
module_platform_driver(altera_spi_driver);
|
|
|
|
MODULE_DESCRIPTION("Altera SPI driver");
|
|
MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("platform:" DRV_NAME);
|