Commit 88a50c16 authored by Mark Brown's avatar Mark Brown

spi: Add support for stacked/parallel memories

Merge series from Amit Kumar Mahapatra <amit.kumar-mahapatra@amd.com>:

This patch series adds support to the SPI framework for using multiple
chip selects.
parents 18f78b5e 4d8ff6b0
...@@ -98,7 +98,7 @@ static int tps6594_spi_probe(struct spi_device *spi) ...@@ -98,7 +98,7 @@ static int tps6594_spi_probe(struct spi_device *spi)
spi_set_drvdata(spi, tps); spi_set_drvdata(spi, tps);
tps->dev = dev; tps->dev = dev;
tps->reg = spi->chip_select; tps->reg = spi_get_chipselect(spi, 0);
tps->irq = spi->irq; tps->irq = spi->irq;
tps->regmap = devm_regmap_init(dev, NULL, spi, &tps6594_spi_regmap_config); tps->regmap = devm_regmap_init(dev, NULL, spi, &tps6594_spi_regmap_config);
......
...@@ -612,10 +612,21 @@ static int spi_dev_check(struct device *dev, void *data) ...@@ -612,10 +612,21 @@ static int spi_dev_check(struct device *dev, void *data)
{ {
struct spi_device *spi = to_spi_device(dev); struct spi_device *spi = to_spi_device(dev);
struct spi_device *new_spi = data; struct spi_device *new_spi = data;
int idx, nw_idx;
if (spi->controller == new_spi->controller && u8 cs, cs_nw;
spi_get_chipselect(spi, 0) == spi_get_chipselect(new_spi, 0))
if (spi->controller == new_spi->controller) {
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
cs = spi_get_chipselect(spi, idx);
for (nw_idx = 0; nw_idx < SPI_CS_CNT_MAX; nw_idx++) {
cs_nw = spi_get_chipselect(new_spi, nw_idx);
if (cs != 0xFF && cs_nw != 0xFF && cs == cs_nw) {
dev_err(dev, "chipselect %d already in use\n", cs_nw);
return -EBUSY; return -EBUSY;
}
}
}
}
return 0; return 0;
} }
...@@ -629,14 +640,33 @@ static int __spi_add_device(struct spi_device *spi) ...@@ -629,14 +640,33 @@ static int __spi_add_device(struct spi_device *spi)
{ {
struct spi_controller *ctlr = spi->controller; struct spi_controller *ctlr = spi->controller;
struct device *dev = ctlr->dev.parent; struct device *dev = ctlr->dev.parent;
int status; int status, idx, nw_idx;
u8 cs, nw_cs;
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
/* Chipselects are numbered 0..max; validate. */ /* Chipselects are numbered 0..max; validate. */
if (spi_get_chipselect(spi, 0) >= ctlr->num_chipselect) { cs = spi_get_chipselect(spi, idx);
dev_err(dev, "cs%d >= max %d\n", spi_get_chipselect(spi, 0), if (cs != 0xFF && cs >= ctlr->num_chipselect) {
dev_err(dev, "cs%d >= max %d\n", spi_get_chipselect(spi, idx),
ctlr->num_chipselect); ctlr->num_chipselect);
return -EINVAL; return -EINVAL;
} }
}
/*
* Make sure that multiple logical CS doesn't map to the same physical CS.
* For example, spi->chip_select[0] != spi->chip_select[1] and so on.
*/
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
cs = spi_get_chipselect(spi, idx);
for (nw_idx = idx + 1; nw_idx < SPI_CS_CNT_MAX; nw_idx++) {
nw_cs = spi_get_chipselect(spi, nw_idx);
if (cs != 0xFF && nw_cs != 0xFF && cs == nw_cs) {
dev_err(dev, "chipselect %d already in use\n", nw_cs);
return -EBUSY;
}
}
}
/* Set the bus ID string */ /* Set the bus ID string */
spi_dev_set_name(spi); spi_dev_set_name(spi);
...@@ -647,11 +677,8 @@ static int __spi_add_device(struct spi_device *spi) ...@@ -647,11 +677,8 @@ static int __spi_add_device(struct spi_device *spi)
* its configuration. * its configuration.
*/ */
status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check); status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
if (status) { if (status)
dev_err(dev, "chipselect %d already in use\n",
spi_get_chipselect(spi, 0));
return status; return status;
}
/* Controller may unregister concurrently */ /* Controller may unregister concurrently */
if (IS_ENABLED(CONFIG_SPI_DYNAMIC) && if (IS_ENABLED(CONFIG_SPI_DYNAMIC) &&
...@@ -659,8 +686,15 @@ static int __spi_add_device(struct spi_device *spi) ...@@ -659,8 +686,15 @@ static int __spi_add_device(struct spi_device *spi)
return -ENODEV; return -ENODEV;
} }
if (ctlr->cs_gpiods) if (ctlr->cs_gpiods) {
spi_set_csgpiod(spi, 0, ctlr->cs_gpiods[spi_get_chipselect(spi, 0)]); u8 cs;
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
cs = spi_get_chipselect(spi, idx);
if (cs != 0xFF)
spi_set_csgpiod(spi, idx, ctlr->cs_gpiods[cs]);
}
}
/* /*
* Drivers may modify this initial i/o setup, but will * Drivers may modify this initial i/o setup, but will
...@@ -701,6 +735,9 @@ int spi_add_device(struct spi_device *spi) ...@@ -701,6 +735,9 @@ int spi_add_device(struct spi_device *spi)
struct spi_controller *ctlr = spi->controller; struct spi_controller *ctlr = spi->controller;
int status; int status;
/* Set the bus ID string */
spi_dev_set_name(spi);
mutex_lock(&ctlr->add_lock); mutex_lock(&ctlr->add_lock);
status = __spi_add_device(spi); status = __spi_add_device(spi);
mutex_unlock(&ctlr->add_lock); mutex_unlock(&ctlr->add_lock);
...@@ -727,6 +764,7 @@ struct spi_device *spi_new_device(struct spi_controller *ctlr, ...@@ -727,6 +764,7 @@ struct spi_device *spi_new_device(struct spi_controller *ctlr,
{ {
struct spi_device *proxy; struct spi_device *proxy;
int status; int status;
u8 idx;
/* /*
* NOTE: caller did any chip->bus_num checks necessary. * NOTE: caller did any chip->bus_num checks necessary.
...@@ -742,6 +780,18 @@ struct spi_device *spi_new_device(struct spi_controller *ctlr, ...@@ -742,6 +780,18 @@ struct spi_device *spi_new_device(struct spi_controller *ctlr,
WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias)); WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
/*
* Zero(0) is a valid physical CS value and can be located at any
* logical CS in the spi->chip_select[]. If all the physical CS
* are initialized to 0 then It would be difficult to differentiate
* between a valid physical CS 0 & an unused logical CS whose physical
* CS can be 0. As a solution to this issue initialize all the CS to 0xFF.
* Now all the unused logical CS will have 0xFF physical CS value & can be
* ignore while performing physical CS validity checks.
*/
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
spi_set_chipselect(proxy, idx, 0xFF);
spi_set_chipselect(proxy, 0, chip->chip_select); spi_set_chipselect(proxy, 0, chip->chip_select);
proxy->max_speed_hz = chip->max_speed_hz; proxy->max_speed_hz = chip->max_speed_hz;
proxy->mode = chip->mode; proxy->mode = chip->mode;
...@@ -750,6 +800,15 @@ struct spi_device *spi_new_device(struct spi_controller *ctlr, ...@@ -750,6 +800,15 @@ struct spi_device *spi_new_device(struct spi_controller *ctlr,
proxy->dev.platform_data = (void *) chip->platform_data; proxy->dev.platform_data = (void *) chip->platform_data;
proxy->controller_data = chip->controller_data; proxy->controller_data = chip->controller_data;
proxy->controller_state = NULL; proxy->controller_state = NULL;
/*
* spi->chip_select[i] gives the corresponding physical CS for logical CS i
* logical CS number is represented by setting the ith bit in spi->cs_index_mask
* So, for example, if spi->cs_index_mask = 0x01 then logical CS number is 0 and
* spi->chip_select[0] will give the physical CS.
* By default spi->chip_select[0] will hold the physical CS number so, set
* spi->cs_index_mask as 0x01.
*/
proxy->cs_index_mask = 0x01;
if (chip->swnode) { if (chip->swnode) {
status = device_add_software_node(&proxy->dev, chip->swnode); status = device_add_software_node(&proxy->dev, chip->swnode);
...@@ -942,32 +1001,51 @@ static void spi_res_release(struct spi_controller *ctlr, struct spi_message *mes ...@@ -942,32 +1001,51 @@ static void spi_res_release(struct spi_controller *ctlr, struct spi_message *mes
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static inline bool spi_is_last_cs(struct spi_device *spi)
{
u8 idx;
bool last = false;
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
if ((spi->cs_index_mask >> idx) & 0x01) {
if (spi->controller->last_cs[idx] == spi_get_chipselect(spi, idx))
last = true;
}
}
return last;
}
static void spi_set_cs(struct spi_device *spi, bool enable, bool force) static void spi_set_cs(struct spi_device *spi, bool enable, bool force)
{ {
bool activate = enable; bool activate = enable;
u8 idx;
/* /*
* Avoid calling into the driver (or doing delays) if the chip select * Avoid calling into the driver (or doing delays) if the chip select
* isn't actually changing from the last time this was called. * isn't actually changing from the last time this was called.
*/ */
if (!force && ((enable && spi->controller->last_cs == spi_get_chipselect(spi, 0)) || if (!force && ((enable && spi->controller->last_cs_index_mask == spi->cs_index_mask &&
(!enable && spi->controller->last_cs != spi_get_chipselect(spi, 0))) && spi_is_last_cs(spi)) ||
(!enable && spi->controller->last_cs_index_mask == spi->cs_index_mask &&
!spi_is_last_cs(spi))) &&
(spi->controller->last_cs_mode_high == (spi->mode & SPI_CS_HIGH))) (spi->controller->last_cs_mode_high == (spi->mode & SPI_CS_HIGH)))
return; return;
trace_spi_set_cs(spi, activate); trace_spi_set_cs(spi, activate);
spi->controller->last_cs = enable ? spi_get_chipselect(spi, 0) : -1; spi->controller->last_cs_index_mask = spi->cs_index_mask;
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
spi->controller->last_cs[idx] = enable ? spi_get_chipselect(spi, 0) : -1;
spi->controller->last_cs_mode_high = spi->mode & SPI_CS_HIGH; spi->controller->last_cs_mode_high = spi->mode & SPI_CS_HIGH;
if ((spi_get_csgpiod(spi, 0) || !spi->controller->set_cs_timing) && !activate)
spi_delay_exec(&spi->cs_hold, NULL);
if (spi->mode & SPI_CS_HIGH) if (spi->mode & SPI_CS_HIGH)
enable = !enable; enable = !enable;
if (spi_get_csgpiod(spi, 0)) { if (spi_is_csgpiod(spi)) {
if (!spi->controller->set_cs_timing && !activate)
spi_delay_exec(&spi->cs_hold, NULL);
if (!(spi->mode & SPI_NO_CS)) { if (!(spi->mode & SPI_NO_CS)) {
/* /*
* Historically ACPI has no means of the GPIO polarity and * Historically ACPI has no means of the GPIO polarity and
...@@ -979,26 +1057,38 @@ static void spi_set_cs(struct spi_device *spi, bool enable, bool force) ...@@ -979,26 +1057,38 @@ static void spi_set_cs(struct spi_device *spi, bool enable, bool force)
* ambiguity. That's why we use enable, that takes SPI_CS_HIGH * ambiguity. That's why we use enable, that takes SPI_CS_HIGH
* into account. * into account.
*/ */
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
if (((spi->cs_index_mask >> idx) & 0x01) &&
spi_get_csgpiod(spi, idx)) {
if (has_acpi_companion(&spi->dev)) if (has_acpi_companion(&spi->dev))
gpiod_set_value_cansleep(spi_get_csgpiod(spi, 0), !enable); gpiod_set_value_cansleep(spi_get_csgpiod(spi, idx),
!enable);
else else
/* Polarity handled by GPIO library */ /* Polarity handled by GPIO library */
gpiod_set_value_cansleep(spi_get_csgpiod(spi, 0), activate); gpiod_set_value_cansleep(spi_get_csgpiod(spi, idx),
activate);
if (activate)
spi_delay_exec(&spi->cs_setup, NULL);
else
spi_delay_exec(&spi->cs_inactive, NULL);
}
}
} }
/* Some SPI masters need both GPIO CS & slave_select */ /* Some SPI masters need both GPIO CS & slave_select */
if ((spi->controller->flags & SPI_CONTROLLER_GPIO_SS) && if ((spi->controller->flags & SPI_CONTROLLER_GPIO_SS) &&
spi->controller->set_cs) spi->controller->set_cs)
spi->controller->set_cs(spi, !enable); spi->controller->set_cs(spi, !enable);
} else if (spi->controller->set_cs) {
spi->controller->set_cs(spi, !enable);
}
if (spi_get_csgpiod(spi, 0) || !spi->controller->set_cs_timing) { if (!spi->controller->set_cs_timing) {
if (activate) if (activate)
spi_delay_exec(&spi->cs_setup, NULL); spi_delay_exec(&spi->cs_setup, NULL);
else else
spi_delay_exec(&spi->cs_inactive, NULL); spi_delay_exec(&spi->cs_inactive, NULL);
} }
} else if (spi->controller->set_cs) {
spi->controller->set_cs(spi, !enable);
}
} }
#ifdef CONFIG_HAS_DMA #ifdef CONFIG_HAS_DMA
...@@ -2225,8 +2315,8 @@ static void of_spi_parse_dt_cs_delay(struct device_node *nc, ...@@ -2225,8 +2315,8 @@ static void of_spi_parse_dt_cs_delay(struct device_node *nc,
static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi, static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
struct device_node *nc) struct device_node *nc)
{ {
u32 value; u32 value, cs[SPI_CS_CNT_MAX];
int rc; int rc, idx;
/* Mode (clock phase/polarity/etc.) */ /* Mode (clock phase/polarity/etc.) */
if (of_property_read_bool(nc, "spi-cpha")) if (of_property_read_bool(nc, "spi-cpha"))
...@@ -2298,14 +2388,53 @@ static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi, ...@@ -2298,14 +2388,53 @@ static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
return 0; return 0;
} }
if (ctlr->num_chipselect > SPI_CS_CNT_MAX) {
dev_err(&ctlr->dev, "No. of CS is more than max. no. of supported CS\n");
return -EINVAL;
}
/*
* Zero(0) is a valid physical CS value and can be located at any
* logical CS in the spi->chip_select[]. If all the physical CS
* are initialized to 0 then It would be difficult to differentiate
* between a valid physical CS 0 & an unused logical CS whose physical
* CS can be 0. As a solution to this issue initialize all the CS to 0xFF.
* Now all the unused logical CS will have 0xFF physical CS value & can be
* ignore while performing physical CS validity checks.
*/
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
spi_set_chipselect(spi, idx, 0xFF);
/* Device address */ /* Device address */
rc = of_property_read_u32(nc, "reg", &value); rc = of_property_read_variable_u32_array(nc, "reg", &cs[0], 1,
if (rc) { SPI_CS_CNT_MAX);
if (rc < 0) {
dev_err(&ctlr->dev, "%pOF has no valid 'reg' property (%d)\n", dev_err(&ctlr->dev, "%pOF has no valid 'reg' property (%d)\n",
nc, rc); nc, rc);
return rc; return rc;
} }
spi_set_chipselect(spi, 0, value); if (rc > ctlr->num_chipselect) {
dev_err(&ctlr->dev, "%pOF has number of CS > ctlr->num_chipselect (%d)\n",
nc, rc);
return rc;
}
if ((of_property_read_bool(nc, "parallel-memories")) &&
(!(ctlr->flags & SPI_CONTROLLER_MULTI_CS))) {
dev_err(&ctlr->dev, "SPI controller doesn't support multi CS\n");
return -EINVAL;
}
for (idx = 0; idx < rc; idx++)
spi_set_chipselect(spi, idx, cs[idx]);
/*
* spi->chip_select[i] gives the corresponding physical CS for logical CS i
* logical CS number is represented by setting the ith bit in spi->cs_index_mask
* So, for example, if spi->cs_index_mask = 0x01 then logical CS number is 0 and
* spi->chip_select[0] will give the physical CS.
* By default spi->chip_select[0] will hold the physical CS number so, set
* spi->cs_index_mask as 0x01.
*/
spi->cs_index_mask = 0x01;
/* Device speed */ /* Device speed */
if (!of_property_read_u32(nc, "spi-max-frequency", &value)) if (!of_property_read_u32(nc, "spi-max-frequency", &value))
...@@ -2411,6 +2540,7 @@ struct spi_device *spi_new_ancillary_device(struct spi_device *spi, ...@@ -2411,6 +2540,7 @@ struct spi_device *spi_new_ancillary_device(struct spi_device *spi,
struct spi_controller *ctlr = spi->controller; struct spi_controller *ctlr = spi->controller;
struct spi_device *ancillary; struct spi_device *ancillary;
int rc = 0; int rc = 0;
u8 idx;
/* Alloc an spi_device */ /* Alloc an spi_device */
ancillary = spi_alloc_device(ctlr); ancillary = spi_alloc_device(ctlr);
...@@ -2421,12 +2551,33 @@ struct spi_device *spi_new_ancillary_device(struct spi_device *spi, ...@@ -2421,12 +2551,33 @@ struct spi_device *spi_new_ancillary_device(struct spi_device *spi,
strscpy(ancillary->modalias, "dummy", sizeof(ancillary->modalias)); strscpy(ancillary->modalias, "dummy", sizeof(ancillary->modalias));
/*
* Zero(0) is a valid physical CS value and can be located at any
* logical CS in the spi->chip_select[]. If all the physical CS
* are initialized to 0 then It would be difficult to differentiate
* between a valid physical CS 0 & an unused logical CS whose physical
* CS can be 0. As a solution to this issue initialize all the CS to 0xFF.
* Now all the unused logical CS will have 0xFF physical CS value & can be
* ignore while performing physical CS validity checks.
*/
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
spi_set_chipselect(ancillary, idx, 0xFF);
/* Use provided chip-select for ancillary device */ /* Use provided chip-select for ancillary device */
spi_set_chipselect(ancillary, 0, chip_select); spi_set_chipselect(ancillary, 0, chip_select);
/* Take over SPI mode/speed from SPI main device */ /* Take over SPI mode/speed from SPI main device */
ancillary->max_speed_hz = spi->max_speed_hz; ancillary->max_speed_hz = spi->max_speed_hz;
ancillary->mode = spi->mode; ancillary->mode = spi->mode;
/*
* spi->chip_select[i] gives the corresponding physical CS for logical CS i
* logical CS number is represented by setting the ith bit in spi->cs_index_mask
* So, for example, if spi->cs_index_mask = 0x01 then logical CS number is 0 and
* spi->chip_select[0] will give the physical CS.
* By default spi->chip_select[0] will hold the physical CS number so, set
* spi->cs_index_mask as 0x01.
*/
ancillary->cs_index_mask = 0x01;
WARN_ON(!mutex_is_locked(&ctlr->add_lock)); WARN_ON(!mutex_is_locked(&ctlr->add_lock));
...@@ -2629,6 +2780,7 @@ struct spi_device *acpi_spi_device_alloc(struct spi_controller *ctlr, ...@@ -2629,6 +2780,7 @@ struct spi_device *acpi_spi_device_alloc(struct spi_controller *ctlr,
struct acpi_spi_lookup lookup = {}; struct acpi_spi_lookup lookup = {};
struct spi_device *spi; struct spi_device *spi;
int ret; int ret;
u8 idx;
if (!ctlr && index == -1) if (!ctlr && index == -1)
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
...@@ -2664,12 +2816,33 @@ struct spi_device *acpi_spi_device_alloc(struct spi_controller *ctlr, ...@@ -2664,12 +2816,33 @@ struct spi_device *acpi_spi_device_alloc(struct spi_controller *ctlr,
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }
/*
* Zero(0) is a valid physical CS value and can be located at any
* logical CS in the spi->chip_select[]. If all the physical CS
* are initialized to 0 then It would be difficult to differentiate
* between a valid physical CS 0 & an unused logical CS whose physical
* CS can be 0. As a solution to this issue initialize all the CS to 0xFF.
* Now all the unused logical CS will have 0xFF physical CS value & can be
* ignore while performing physical CS validity checks.
*/
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
spi_set_chipselect(spi, idx, 0xFF);
ACPI_COMPANION_SET(&spi->dev, adev); ACPI_COMPANION_SET(&spi->dev, adev);
spi->max_speed_hz = lookup.max_speed_hz; spi->max_speed_hz = lookup.max_speed_hz;
spi->mode |= lookup.mode; spi->mode |= lookup.mode;
spi->irq = lookup.irq; spi->irq = lookup.irq;
spi->bits_per_word = lookup.bits_per_word; spi->bits_per_word = lookup.bits_per_word;
spi_set_chipselect(spi, 0, lookup.chip_select); spi_set_chipselect(spi, 0, lookup.chip_select);
/*
* spi->chip_select[i] gives the corresponding physical CS for logical CS i
* logical CS number is represented by setting the ith bit in spi->cs_index_mask
* So, for example, if spi->cs_index_mask = 0x01 then logical CS number is 0 and
* spi->chip_select[0] will give the physical CS.
* By default spi->chip_select[0] will hold the physical CS number so, set
* spi->cs_index_mask as 0x01.
*/
spi->cs_index_mask = 0x01;
return spi; return spi;
} }
...@@ -3103,6 +3276,7 @@ int spi_register_controller(struct spi_controller *ctlr) ...@@ -3103,6 +3276,7 @@ int spi_register_controller(struct spi_controller *ctlr)
struct boardinfo *bi; struct boardinfo *bi;
int first_dynamic; int first_dynamic;
int status; int status;
int idx;
if (!dev) if (!dev)
return -ENODEV; return -ENODEV;
...@@ -3167,7 +3341,8 @@ int spi_register_controller(struct spi_controller *ctlr) ...@@ -3167,7 +3341,8 @@ int spi_register_controller(struct spi_controller *ctlr)
} }
/* Setting last_cs to -1 means no chip selected */ /* Setting last_cs to -1 means no chip selected */
ctlr->last_cs = -1; for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
ctlr->last_cs[idx] = -1;
status = device_add(&ctlr->dev); status = device_add(&ctlr->dev);
if (status < 0) if (status < 0)
...@@ -3892,7 +4067,7 @@ static int __spi_validate(struct spi_device *spi, struct spi_message *message) ...@@ -3892,7 +4067,7 @@ static int __spi_validate(struct spi_device *spi, struct spi_message *message)
* cs_change is set for each transfer. * cs_change is set for each transfer.
*/ */
if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) || if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) ||
spi_get_csgpiod(spi, 0))) { spi_is_csgpiod(spi))) {
size_t maxsize = BITS_TO_BYTES(spi->bits_per_word); size_t maxsize = BITS_TO_BYTES(spi->bits_per_word);
int ret; int ret;
......
...@@ -20,6 +20,9 @@ ...@@ -20,6 +20,9 @@
#include <uapi/linux/spi/spi.h> #include <uapi/linux/spi/spi.h>
/* Max no. of CS supported per spi device */
#define SPI_CS_CNT_MAX 4
struct dma_chan; struct dma_chan;
struct software_node; struct software_node;
struct ptp_system_timestamp; struct ptp_system_timestamp;
...@@ -132,7 +135,8 @@ extern void spi_transfer_cs_change_delay_exec(struct spi_message *msg, ...@@ -132,7 +135,8 @@ extern void spi_transfer_cs_change_delay_exec(struct spi_message *msg,
* @max_speed_hz: Maximum clock rate to be used with this chip * @max_speed_hz: Maximum clock rate to be used with this chip
* (on this board); may be changed by the device's driver. * (on this board); may be changed by the device's driver.
* The spi_transfer.speed_hz can override this for each transfer. * The spi_transfer.speed_hz can override this for each transfer.
* @chip_select: Chipselect, distinguishing chips handled by @controller. * @chip_select: Array of physical chipselect, spi->chipselect[i] gives
* the corresponding physical CS for logical CS i.
* @mode: The spi mode defines how data is clocked out and in. * @mode: The spi mode defines how data is clocked out and in.
* This may be changed by the device's driver. * This may be changed by the device's driver.
* The "active low" default for chipselect mode can be overridden * The "active low" default for chipselect mode can be overridden
...@@ -157,8 +161,8 @@ extern void spi_transfer_cs_change_delay_exec(struct spi_message *msg, ...@@ -157,8 +161,8 @@ extern void spi_transfer_cs_change_delay_exec(struct spi_message *msg,
* the device will bind to the named driver and only the named driver. * the device will bind to the named driver and only the named driver.
* Do not set directly, because core frees it; use driver_set_override() to * Do not set directly, because core frees it; use driver_set_override() to
* set or clear it. * set or clear it.
* @cs_gpiod: GPIO descriptor of the chipselect line (optional, NULL when * @cs_gpiod: Array of GPIO descriptors of the corresponding chipselect lines
* not using a GPIO line) * (optional, NULL when not using a GPIO line)
* @word_delay: delay to be inserted between consecutive * @word_delay: delay to be inserted between consecutive
* words of a transfer * words of a transfer
* @cs_setup: delay to be introduced by the controller after CS is asserted * @cs_setup: delay to be introduced by the controller after CS is asserted
...@@ -167,6 +171,7 @@ extern void spi_transfer_cs_change_delay_exec(struct spi_message *msg, ...@@ -167,6 +171,7 @@ extern void spi_transfer_cs_change_delay_exec(struct spi_message *msg,
* deasserted. If @cs_change_delay is used from @spi_transfer, then the * deasserted. If @cs_change_delay is used from @spi_transfer, then the
* two delays will be added up. * two delays will be added up.
* @pcpu_statistics: statistics for the spi_device * @pcpu_statistics: statistics for the spi_device
* @cs_index_mask: Bit mask of the active chipselect(s) in the chipselect array
* *
* A @spi_device is used to interchange data between an SPI slave * A @spi_device is used to interchange data between an SPI slave
* (usually a discrete chip) and CPU memory. * (usually a discrete chip) and CPU memory.
...@@ -182,7 +187,7 @@ struct spi_device { ...@@ -182,7 +187,7 @@ struct spi_device {
struct spi_controller *controller; struct spi_controller *controller;
struct spi_controller *master; /* Compatibility layer */ struct spi_controller *master; /* Compatibility layer */
u32 max_speed_hz; u32 max_speed_hz;
u8 chip_select; u8 chip_select[SPI_CS_CNT_MAX];
u8 bits_per_word; u8 bits_per_word;
bool rt; bool rt;
#define SPI_NO_TX BIT(31) /* No transmit wire */ #define SPI_NO_TX BIT(31) /* No transmit wire */
...@@ -213,7 +218,7 @@ struct spi_device { ...@@ -213,7 +218,7 @@ struct spi_device {
void *controller_data; void *controller_data;
char modalias[SPI_NAME_SIZE]; char modalias[SPI_NAME_SIZE];
const char *driver_override; const char *driver_override;
struct gpio_desc *cs_gpiod; /* Chip select GPIO descriptor */ struct gpio_desc *cs_gpiod[SPI_CS_CNT_MAX]; /* Chip select gpio desc */
struct spi_delay word_delay; /* Inter-word delay */ struct spi_delay word_delay; /* Inter-word delay */
/* CS delays */ /* CS delays */
struct spi_delay cs_setup; struct spi_delay cs_setup;
...@@ -223,6 +228,13 @@ struct spi_device { ...@@ -223,6 +228,13 @@ struct spi_device {
/* The statistics */ /* The statistics */
struct spi_statistics __percpu *pcpu_statistics; struct spi_statistics __percpu *pcpu_statistics;
/* Bit mask of the chipselect(s) that the driver need to use from
* the chipselect array.When the controller is capable to handle
* multiple chip selects & memories are connected in parallel
* then more than one bit need to be set in cs_index_mask.
*/
u32 cs_index_mask : SPI_CS_CNT_MAX;
/* /*
* Likely need more hooks for more protocol options affecting how * Likely need more hooks for more protocol options affecting how
* the controller talks to each chip, like: * the controller talks to each chip, like:
...@@ -279,22 +291,33 @@ static inline void *spi_get_drvdata(const struct spi_device *spi) ...@@ -279,22 +291,33 @@ static inline void *spi_get_drvdata(const struct spi_device *spi)
static inline u8 spi_get_chipselect(const struct spi_device *spi, u8 idx) static inline u8 spi_get_chipselect(const struct spi_device *spi, u8 idx)
{ {
return spi->chip_select; return spi->chip_select[idx];
} }
static inline void spi_set_chipselect(struct spi_device *spi, u8 idx, u8 chipselect) static inline void spi_set_chipselect(struct spi_device *spi, u8 idx, u8 chipselect)
{ {
spi->chip_select = chipselect; spi->chip_select[idx] = chipselect;
} }
static inline struct gpio_desc *spi_get_csgpiod(const struct spi_device *spi, u8 idx) static inline struct gpio_desc *spi_get_csgpiod(const struct spi_device *spi, u8 idx)
{ {
return spi->cs_gpiod; return spi->cs_gpiod[idx];
} }
static inline void spi_set_csgpiod(struct spi_device *spi, u8 idx, struct gpio_desc *csgpiod) static inline void spi_set_csgpiod(struct spi_device *spi, u8 idx, struct gpio_desc *csgpiod)
{ {
spi->cs_gpiod = csgpiod; spi->cs_gpiod[idx] = csgpiod;
}
static inline bool spi_is_csgpiod(struct spi_device *spi)
{
u8 idx;
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
if (spi_get_csgpiod(spi, idx))
return true;
}
return false;
} }
/** /**
...@@ -399,6 +422,8 @@ extern struct spi_device *spi_new_ancillary_device(struct spi_device *spi, u8 ch ...@@ -399,6 +422,8 @@ extern struct spi_device *spi_new_ancillary_device(struct spi_device *spi, u8 ch
* @bus_lock_spinlock: spinlock for SPI bus locking * @bus_lock_spinlock: spinlock for SPI bus locking
* @bus_lock_mutex: mutex for exclusion of multiple callers * @bus_lock_mutex: mutex for exclusion of multiple callers
* @bus_lock_flag: indicates that the SPI bus is locked for exclusive use * @bus_lock_flag: indicates that the SPI bus is locked for exclusive use
* @multi_cs_cap: indicates that the SPI Controller can assert/de-assert
* more than one chip select at once.
* @setup: updates the device mode and clocking records used by a * @setup: updates the device mode and clocking records used by a
* device's SPI controller; protocol code may call this. This * device's SPI controller; protocol code may call this. This
* must fail if an unrecognized or unsupported mode is requested. * must fail if an unrecognized or unsupported mode is requested.
...@@ -570,6 +595,11 @@ struct spi_controller { ...@@ -570,6 +595,11 @@ struct spi_controller {
#define SPI_CONTROLLER_MUST_TX BIT(4) /* Requires tx */ #define SPI_CONTROLLER_MUST_TX BIT(4) /* Requires tx */
#define SPI_CONTROLLER_GPIO_SS BIT(5) /* GPIO CS must select slave */ #define SPI_CONTROLLER_GPIO_SS BIT(5) /* GPIO CS must select slave */
#define SPI_CONTROLLER_SUSPENDED BIT(6) /* Currently suspended */ #define SPI_CONTROLLER_SUSPENDED BIT(6) /* Currently suspended */
/*
* The spi-controller has multi chip select capability and can
* assert/de-assert more than one chip select at once.
*/
#define SPI_CONTROLLER_MULTI_CS BIT(7)
/* Flag indicating if the allocation of this struct is devres-managed */ /* Flag indicating if the allocation of this struct is devres-managed */
bool devm_allocated; bool devm_allocated;
...@@ -680,7 +710,8 @@ struct spi_controller { ...@@ -680,7 +710,8 @@ struct spi_controller {
bool rt; bool rt;
bool auto_runtime_pm; bool auto_runtime_pm;
bool cur_msg_mapped; bool cur_msg_mapped;
char last_cs; char last_cs[SPI_CS_CNT_MAX];
char last_cs_index_mask;
bool last_cs_mode_high; bool last_cs_mode_high;
bool fallback; bool fallback;
struct completion xfer_completion; struct completion xfer_completion;
......
...@@ -29,7 +29,7 @@ static int cs35l56_hda_spi_probe(struct spi_device *spi) ...@@ -29,7 +29,7 @@ static int cs35l56_hda_spi_probe(struct spi_device *spi)
return ret; return ret;
} }
ret = cs35l56_hda_common_probe(cs35l56, spi->chip_select); ret = cs35l56_hda_common_probe(cs35l56, spi_get_chipselect(spi, 0));
if (ret) if (ret)
return ret; return ret;
ret = cs35l56_irq_request(&cs35l56->base, spi->irq); ret = cs35l56_irq_request(&cs35l56->base, spi->irq);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment