microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Merge remote-tracking branches 'spi/topic/jcore', 'spi/topic/kconfig', 'spi/topic/orion', 'spi/topic/pxa2xx' and 'spi/topic/rspi' into spi-next

This commit is contained in:
Mark Brown 2018-04-02 15:56:39 +01:00
Родитель 70a3550b8c 7c2861a6fb e3d001a0c2 5c22af7eeb 3cc7b0e357 768d59f5d0
Коммит 8aaeae7e61
Не найден ключ, соответствующий данной подписи
Идентификатор ключа GPG: 24D68B725D5487D0
7 изменённых файлов: 96 добавлений и 48 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4
drivers/spi/Kconfig
Просмотреть файл

@ -72,10 +72,10 @@ config SPI_ARMADA_3700
config SPI_ATMEL config SPI_ATMEL
tristate "Atmel SPI Controller" tristate "Atmel SPI Controller"
depends on HAS_DMA depends on HAS_DMA
depends on (ARCH_AT91 || AVR32 || COMPILE_TEST) depends on (ARCH_AT91 || COMPILE_TEST)
help help
This selects a driver for the Atmel SPI Controller, present on This selects a driver for the Atmel SPI Controller, present on
many AT32 (AVR32) and AT91 (ARM) chips. many AT91 (ARM) chips.
config SPI_AU1550 config SPI_AU1550
tristate "Au1550/Au1200/Au1300 SPI Controller" tristate "Au1550/Au1200/Au1300 SPI Controller"

11
drivers/spi/spi-jcore.c
Просмотреть файл

@ -184,10 +184,11 @@ static int jcore_spi_probe(struct platform_device *pdev)
*/ */
clock_freq = 50000000; clock_freq = 50000000;
clk = devm_clk_get(&pdev->dev, "ref_clk"); clk = devm_clk_get(&pdev->dev, "ref_clk");
if (!IS_ERR_OR_NULL(clk)) { if (!IS_ERR(clk)) {
if (clk_enable(clk) == 0) if (clk_prepare_enable(clk) == 0) {
clock_freq = clk_get_rate(clk); clock_freq = clk_get_rate(clk);
else clk_disable_unprepare(clk);
} else
dev_warn(&pdev->dev, "could not enable ref_clk\n"); dev_warn(&pdev->dev, "could not enable ref_clk\n");
} }
hw->clock_freq = clock_freq; hw->clock_freq = clock_freq;
@ -198,10 +199,8 @@ static int jcore_spi_probe(struct platform_device *pdev)
/* Register our spi controller */ /* Register our spi controller */
err = devm_spi_register_master(&pdev->dev, master); err = devm_spi_register_master(&pdev->dev, master);
if (err) { if (err)
clk_disable(clk);
goto exit; goto exit;
}
return 0; return 0;

65
drivers/spi/spi-orion.c
Просмотреть файл

@ -90,14 +90,19 @@ struct orion_direct_acc {
u32 size; u32 size;
}; };
struct orion_child_options {
struct orion_direct_acc direct_access;
};
struct orion_spi { struct orion_spi {
struct spi_master *master; struct spi_master *master;
void __iomem *base; void __iomem *base;
struct clk *clk; struct clk *clk;
struct clk *axi_clk; struct clk *axi_clk;
const struct orion_spi_dev *devdata; const struct orion_spi_dev *devdata;
int unused_hw_gpio;
struct orion_direct_acc direct_access[ORION_NUM_CHIPSELECTS]; struct orion_child_options child[ORION_NUM_CHIPSELECTS];
}; };
static inline void __iomem *spi_reg(struct orion_spi *orion_spi, u32 reg) static inline void __iomem *spi_reg(struct orion_spi *orion_spi, u32 reg)
@ -324,13 +329,13 @@ static void orion_spi_set_cs(struct spi_device *spi, bool enable)
struct orion_spi *orion_spi; struct orion_spi *orion_spi;
int cs; int cs;
orion_spi = spi_master_get_devdata(spi->master);
if (gpio_is_valid(spi->cs_gpio)) if (gpio_is_valid(spi->cs_gpio))
cs = 0; cs = orion_spi->unused_hw_gpio;
else else
cs = spi->chip_select; cs = spi->chip_select;
orion_spi = spi_master_get_devdata(spi->master);
orion_spi_clrbits(orion_spi, ORION_SPI_IF_CTRL_REG, ORION_SPI_CS_MASK); orion_spi_clrbits(orion_spi, ORION_SPI_IF_CTRL_REG, ORION_SPI_CS_MASK);
orion_spi_setbits(orion_spi, ORION_SPI_IF_CTRL_REG, orion_spi_setbits(orion_spi, ORION_SPI_IF_CTRL_REG,
ORION_SPI_CS(cs)); ORION_SPI_CS(cs));
@ -435,7 +440,7 @@ orion_spi_write_read(struct spi_device *spi, struct spi_transfer *xfer)
* Use SPI direct write mode if base address is available. Otherwise * Use SPI direct write mode if base address is available. Otherwise
* fall back to PIO mode for this transfer. * fall back to PIO mode for this transfer.
*/ */
if ((orion_spi->direct_access[cs].vaddr) && (xfer->tx_buf) && if ((orion_spi->child[cs].direct_access.vaddr) && (xfer->tx_buf) &&
(word_len == 8)) { (word_len == 8)) {
unsigned int cnt = count / 4; unsigned int cnt = count / 4;
unsigned int rem = count % 4; unsigned int rem = count % 4;
@ -444,12 +449,12 @@ orion_spi_write_read(struct spi_device *spi, struct spi_transfer *xfer)
* Send the TX-data to the SPI device via the direct * Send the TX-data to the SPI device via the direct
* mapped address window * mapped address window
*/ */
iowrite32_rep(orion_spi->direct_access[cs].vaddr, iowrite32_rep(orion_spi->child[cs].direct_access.vaddr,
xfer->tx_buf, cnt); xfer->tx_buf, cnt);
if (rem) { if (rem) {
u32 *buf = (u32 *)xfer->tx_buf; u32 *buf = (u32 *)xfer->tx_buf;
iowrite8_rep(orion_spi->direct_access[cs].vaddr, iowrite8_rep(orion_spi->child[cs].direct_access.vaddr,
&buf[cnt], rem); &buf[cnt], rem);
} }
@ -498,6 +503,9 @@ static int orion_spi_transfer_one(struct spi_master *master,
static int orion_spi_setup(struct spi_device *spi) static int orion_spi_setup(struct spi_device *spi)
{ {
if (gpio_is_valid(spi->cs_gpio)) {
gpio_direction_output(spi->cs_gpio, !(spi->mode & SPI_CS_HIGH));
}
return orion_spi_setup_transfer(spi, NULL); return orion_spi_setup_transfer(spi, NULL);
} }
@ -620,6 +628,7 @@ static int orion_spi_probe(struct platform_device *pdev)
spi = spi_master_get_devdata(master); spi = spi_master_get_devdata(master);
spi->master = master; spi->master = master;
spi->unused_hw_gpio = -1;
of_id = of_match_device(orion_spi_of_match_table, &pdev->dev); of_id = of_match_device(orion_spi_of_match_table, &pdev->dev);
devdata = (of_id) ? of_id->data : &orion_spi_dev_data; devdata = (of_id) ? of_id->data : &orion_spi_dev_data;
@ -702,14 +711,14 @@ static int orion_spi_probe(struct platform_device *pdev)
* This needs to get extended for the direct SPI-NOR / SPI-NAND * This needs to get extended for the direct SPI-NOR / SPI-NAND
* support, once this gets implemented. * support, once this gets implemented.
*/ */
spi->direct_access[cs].vaddr = devm_ioremap(&pdev->dev, spi->child[cs].direct_access.vaddr = devm_ioremap(&pdev->dev,
r->start, r->start,
PAGE_SIZE); PAGE_SIZE);
if (!spi->direct_access[cs].vaddr) { if (!spi->child[cs].direct_access.vaddr) {
status = -ENOMEM; status = -ENOMEM;
goto out_rel_axi_clk; goto out_rel_axi_clk;
} }
spi->direct_access[cs].size = PAGE_SIZE; spi->child[cs].direct_access.size = PAGE_SIZE;
dev_info(&pdev->dev, "CS%d configured for direct access\n", cs); dev_info(&pdev->dev, "CS%d configured for direct access\n", cs);
} }
@ -731,8 +740,44 @@ static int orion_spi_probe(struct platform_device *pdev)
if (status < 0) if (status < 0)
goto out_rel_pm; goto out_rel_pm;
if (master->cs_gpios) {
int i;
for (i = 0; i < master->num_chipselect; ++i) {
char *gpio_name;
if (!gpio_is_valid(master->cs_gpios[i])) {
continue;
}
gpio_name = devm_kasprintf(&pdev->dev, GFP_KERNEL,
"%s-CS%d", dev_name(&pdev->dev), i);
if (!gpio_name) {
status = -ENOMEM;
goto out_rel_master;
}
status = devm_gpio_request(&pdev->dev,
master->cs_gpios[i], gpio_name);
if (status) {
dev_err(&pdev->dev,
"Can't request GPIO for CS %d\n",
master->cs_gpios[i]);
goto out_rel_master;
}
if (spi->unused_hw_gpio == -1) {
dev_info(&pdev->dev,
"Selected unused HW CS#%d for any GPIO CSes\n",
i);
spi->unused_hw_gpio = i;
}
}
}
return status; return status;
out_rel_master:
spi_unregister_master(master);
out_rel_pm: out_rel_pm:
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
out_rel_axi_clk: out_rel_axi_clk:

4
drivers/spi/spi-pxa2xx-dma.c
Просмотреть файл

@ -191,7 +191,7 @@ int pxa2xx_spi_dma_setup(struct driver_data *drv_data)
{ {
struct pxa2xx_spi_master *pdata = drv_data->master_info; struct pxa2xx_spi_master *pdata = drv_data->master_info;
struct device *dev = &drv_data->pdev->dev; struct device *dev = &drv_data->pdev->dev;
struct spi_master *master = drv_data->master; struct spi_controller *master = drv_data->master;
dma_cap_mask_t mask; dma_cap_mask_t mask;
dma_cap_zero(mask); dma_cap_zero(mask);
@ -215,7 +215,7 @@ int pxa2xx_spi_dma_setup(struct driver_data *drv_data)
void pxa2xx_spi_dma_release(struct driver_data *drv_data) void pxa2xx_spi_dma_release(struct driver_data *drv_data)
{ {
struct spi_master *master = drv_data->master; struct spi_controller *master = drv_data->master;
if (master->dma_rx) { if (master->dma_rx) {
dmaengine_terminate_sync(master->dma_rx); dmaengine_terminate_sync(master->dma_rx);

54
drivers/spi/spi-pxa2xx.c
Просмотреть файл

@ -415,10 +415,17 @@ static void cs_deassert(struct driver_data *drv_data)
{ {
struct chip_data *chip = struct chip_data *chip =
spi_get_ctldata(drv_data->master->cur_msg->spi); spi_get_ctldata(drv_data->master->cur_msg->spi);
unsigned long timeout;
if (drv_data->ssp_type == CE4100_SSP) if (drv_data->ssp_type == CE4100_SSP)
return; return;
/* Wait until SSP becomes idle before deasserting the CS */
timeout = jiffies + msecs_to_jiffies(10);
while (pxa2xx_spi_read(drv_data, SSSR) & SSSR_BSY &&
!time_after(jiffies, timeout))
cpu_relax();
if (chip->cs_control) { if (chip->cs_control) {
chip->cs_control(PXA2XX_CS_DEASSERT); chip->cs_control(PXA2XX_CS_DEASSERT);
return; return;
@ -563,7 +570,6 @@ static void giveback(struct driver_data *drv_data)
{ {
struct spi_transfer* last_transfer; struct spi_transfer* last_transfer;
struct spi_message *msg; struct spi_message *msg;
unsigned long timeout;
msg = drv_data->master->cur_msg; msg = drv_data->master->cur_msg;
drv_data->cur_transfer = NULL; drv_data->cur_transfer = NULL;
@ -575,12 +581,6 @@ static void giveback(struct driver_data *drv_data)
if (last_transfer->delay_usecs) if (last_transfer->delay_usecs)
udelay(last_transfer->delay_usecs); udelay(last_transfer->delay_usecs);
/* Wait until SSP becomes idle before deasserting the CS */
timeout = jiffies + msecs_to_jiffies(10);
while (pxa2xx_spi_read(drv_data, SSSR) & SSSR_BSY &&
!time_after(jiffies, timeout))
cpu_relax();
/* Drop chip select UNLESS cs_change is true or we are returning /* Drop chip select UNLESS cs_change is true or we are returning
* a message with an error, or next message is for another chip * a message with an error, or next message is for another chip
*/ */
@ -962,7 +962,7 @@ static unsigned int pxa2xx_ssp_get_clk_div(struct driver_data *drv_data,
return clk_div << 8; return clk_div << 8;
} }
static bool pxa2xx_spi_can_dma(struct spi_master *master, static bool pxa2xx_spi_can_dma(struct spi_controller *master,
struct spi_device *spi, struct spi_device *spi,
struct spi_transfer *xfer) struct spi_transfer *xfer)
{ {
@ -976,7 +976,7 @@ static bool pxa2xx_spi_can_dma(struct spi_master *master,
static void pump_transfers(unsigned long data) static void pump_transfers(unsigned long data)
{ {
struct driver_data *drv_data = (struct driver_data *)data; struct driver_data *drv_data = (struct driver_data *)data;
struct spi_master *master = drv_data->master; struct spi_controller *master = drv_data->master;
struct spi_message *message = master->cur_msg; struct spi_message *message = master->cur_msg;
struct chip_data *chip = spi_get_ctldata(message->spi); struct chip_data *chip = spi_get_ctldata(message->spi);
u32 dma_thresh = chip->dma_threshold; u32 dma_thresh = chip->dma_threshold;
@ -1182,10 +1182,10 @@ static void pump_transfers(unsigned long data)
pxa2xx_spi_write(drv_data, SSCR1, cr1); pxa2xx_spi_write(drv_data, SSCR1, cr1);
} }
static int pxa2xx_spi_transfer_one_message(struct spi_master *master, static int pxa2xx_spi_transfer_one_message(struct spi_controller *master,
struct spi_message *msg) struct spi_message *msg)
{ {
struct driver_data *drv_data = spi_master_get_devdata(master); struct driver_data *drv_data = spi_controller_get_devdata(master);
/* Initial message state*/ /* Initial message state*/
msg->state = START_STATE; msg->state = START_STATE;
@ -1198,9 +1198,9 @@ static int pxa2xx_spi_transfer_one_message(struct spi_master *master,
return 0; return 0;
} }
static int pxa2xx_spi_unprepare_transfer(struct spi_master *master) static int pxa2xx_spi_unprepare_transfer(struct spi_controller *master)
{ {
struct driver_data *drv_data = spi_master_get_devdata(master); struct driver_data *drv_data = spi_controller_get_devdata(master);
/* Disable the SSP now */ /* Disable the SSP now */
pxa2xx_spi_write(drv_data, SSCR0, pxa2xx_spi_write(drv_data, SSCR0,
@ -1212,7 +1212,8 @@ static int pxa2xx_spi_unprepare_transfer(struct spi_master *master)
static int setup_cs(struct spi_device *spi, struct chip_data *chip, static int setup_cs(struct spi_device *spi, struct chip_data *chip,
struct pxa2xx_spi_chip *chip_info) struct pxa2xx_spi_chip *chip_info)
{ {
struct driver_data *drv_data = spi_master_get_devdata(spi->master); struct driver_data *drv_data =
spi_controller_get_devdata(spi->controller);
struct gpio_desc *gpiod; struct gpio_desc *gpiod;
int err = 0; int err = 0;
@ -1270,7 +1271,8 @@ static int setup(struct spi_device *spi)
struct pxa2xx_spi_chip *chip_info; struct pxa2xx_spi_chip *chip_info;
struct chip_data *chip; struct chip_data *chip;
const struct lpss_config *config; const struct lpss_config *config;
struct driver_data *drv_data = spi_master_get_devdata(spi->master); struct driver_data *drv_data =
spi_controller_get_devdata(spi->controller);
uint tx_thres, tx_hi_thres, rx_thres; uint tx_thres, tx_hi_thres, rx_thres;
switch (drv_data->ssp_type) { switch (drv_data->ssp_type) {
@ -1410,7 +1412,8 @@ static int setup(struct spi_device *spi)
static void cleanup(struct spi_device *spi) static void cleanup(struct spi_device *spi)
{ {
struct chip_data *chip = spi_get_ctldata(spi); struct chip_data *chip = spi_get_ctldata(spi);
struct driver_data *drv_data = spi_master_get_devdata(spi->master); struct driver_data *drv_data =
spi_controller_get_devdata(spi->controller);
if (!chip) if (!chip)
return; return;
@ -1575,9 +1578,10 @@ pxa2xx_spi_init_pdata(struct platform_device *pdev)
} }
#endif #endif
static int pxa2xx_spi_fw_translate_cs(struct spi_master *master, unsigned cs) static int pxa2xx_spi_fw_translate_cs(struct spi_controller *master,
unsigned int cs)
{ {
struct driver_data *drv_data = spi_master_get_devdata(master); struct driver_data *drv_data = spi_controller_get_devdata(master);
if (has_acpi_companion(&drv_data->pdev->dev)) { if (has_acpi_companion(&drv_data->pdev->dev)) {
switch (drv_data->ssp_type) { switch (drv_data->ssp_type) {
@ -1602,7 +1606,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
{ {
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
struct pxa2xx_spi_master *platform_info; struct pxa2xx_spi_master *platform_info;
struct spi_master *master; struct spi_controller *master;
struct driver_data *drv_data; struct driver_data *drv_data;
struct ssp_device *ssp; struct ssp_device *ssp;
const struct lpss_config *config; const struct lpss_config *config;
@ -1633,7 +1637,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
pxa_ssp_free(ssp); pxa_ssp_free(ssp);
return -ENOMEM; return -ENOMEM;
} }
drv_data = spi_master_get_devdata(master); drv_data = spi_controller_get_devdata(master);
drv_data->master = master; drv_data->master = master;
drv_data->master_info = platform_info; drv_data->master_info = platform_info;
drv_data->pdev = pdev; drv_data->pdev = pdev;
@ -1651,7 +1655,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
master->unprepare_transfer_hardware = pxa2xx_spi_unprepare_transfer; master->unprepare_transfer_hardware = pxa2xx_spi_unprepare_transfer;
master->fw_translate_cs = pxa2xx_spi_fw_translate_cs; master->fw_translate_cs = pxa2xx_spi_fw_translate_cs;
master->auto_runtime_pm = true; master->auto_runtime_pm = true;
master->flags = SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX; master->flags = SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX;
drv_data->ssp_type = ssp->type; drv_data->ssp_type = ssp->type;
@ -1793,7 +1797,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
/* Register with the SPI framework */ /* Register with the SPI framework */
platform_set_drvdata(pdev, drv_data); platform_set_drvdata(pdev, drv_data);
status = devm_spi_register_master(&pdev->dev, master); status = devm_spi_register_controller(&pdev->dev, master);
if (status != 0) { if (status != 0) {
dev_err(&pdev->dev, "problem registering spi master\n"); dev_err(&pdev->dev, "problem registering spi master\n");
goto out_error_clock_enabled; goto out_error_clock_enabled;
@ -1809,7 +1813,7 @@ out_error_clock_enabled:
free_irq(ssp->irq, drv_data); free_irq(ssp->irq, drv_data);
out_error_master_alloc: out_error_master_alloc:
spi_master_put(master); spi_controller_put(master);
pxa_ssp_free(ssp); pxa_ssp_free(ssp);
return status; return status;
} }
@ -1860,7 +1864,7 @@ static int pxa2xx_spi_suspend(struct device *dev)
struct ssp_device *ssp = drv_data->ssp; struct ssp_device *ssp = drv_data->ssp;
int status; int status;
status = spi_master_suspend(drv_data->master); status = spi_controller_suspend(drv_data->master);
if (status != 0) if (status != 0)
return status; return status;
pxa2xx_spi_write(drv_data, SSCR0, 0); pxa2xx_spi_write(drv_data, SSCR0, 0);
@ -1886,7 +1890,7 @@ static int pxa2xx_spi_resume(struct device *dev)
lpss_ssp_setup(drv_data); lpss_ssp_setup(drv_data);
/* Start the queue running */ /* Start the queue running */
status = spi_master_resume(drv_data->master); status = spi_controller_resume(drv_data->master);
if (status != 0) { if (status != 0) {
dev_err(dev, "problem starting queue (%d)\n", status); dev_err(dev, "problem starting queue (%d)\n", status);
return status; return status;

2
drivers/spi/spi-pxa2xx.h
Просмотреть файл

@ -31,7 +31,7 @@ struct driver_data {
/* SPI framework hookup */ /* SPI framework hookup */
enum pxa_ssp_type ssp_type; enum pxa_ssp_type ssp_type;
struct spi_master *master; struct spi_controller *master;
/* PXA hookup */ /* PXA hookup */
struct pxa2xx_spi_master *master_info; struct pxa2xx_spi_master *master_info;

4
drivers/spi/spi-rspi.c
Просмотреть файл

@ -535,7 +535,7 @@ static int rspi_dma_transfer(struct rspi_data *rspi, struct sg_table *tx,
/* First prepare and submit the DMA request(s), as this may fail */ /* First prepare and submit the DMA request(s), as this may fail */
if (rx) { if (rx) {
desc_rx = dmaengine_prep_slave_sg(rspi->master->dma_rx, desc_rx = dmaengine_prep_slave_sg(rspi->master->dma_rx,
rx->sgl, rx->nents, DMA_FROM_DEVICE, rx->sgl, rx->nents, DMA_DEV_TO_MEM,
DMA_PREP_INTERRUPT | DMA_CTRL_ACK); DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
if (!desc_rx) { if (!desc_rx) {
ret = -EAGAIN; ret = -EAGAIN;
@ -555,7 +555,7 @@ static int rspi_dma_transfer(struct rspi_data *rspi, struct sg_table *tx,
if (tx) { if (tx) {
desc_tx = dmaengine_prep_slave_sg(rspi->master->dma_tx, desc_tx = dmaengine_prep_slave_sg(rspi->master->dma_tx,
tx->sgl, tx->nents, DMA_TO_DEVICE, tx->sgl, tx->nents, DMA_MEM_TO_DEV,
DMA_PREP_INTERRUPT | DMA_CTRL_ACK); DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
if (!desc_tx) { if (!desc_tx) {
ret = -EAGAIN; ret = -EAGAIN;