Hello Stefan,
-----Original Message-----That’s correct, I missed it.
From: Stefan Binding <sbinding@xxxxxxxxxxxxxxxxxxxxx>
Sent: Tuesday, November 21, 2023 11:07 PM
To: Mahapatra, Amit Kumar <amit.kumar-mahapatra@xxxxxxx>;
broonie@xxxxxxxxxx; tudor.ambarus@xxxxxxxxxx; pratyush@xxxxxxxxxx;
miquel.raynal@xxxxxxxxxxx; richard@xxxxxx; vigneshr@xxxxxx
Cc: linux-spi@xxxxxxxxxxxxxxx; linux-kernel@xxxxxxxxxxxxxxx;
michael@xxxxxxxx; linux-mtd@xxxxxxxxxxxxxxxxxxx;
nicolas.ferre@xxxxxxxxxxxxx; alexandre.belloni@xxxxxxxxxxx;
claudiu.beznea@xxxxxxxxx; Simek, Michal <michal.simek@xxxxxxx>; linux-
arm-kernel@xxxxxxxxxxxxxxxxxxx; git (AMD-Xilinx) <git@xxxxxxx>;
amitrkcian2002@xxxxxxxxx; patches@xxxxxxxxxxxxxxxxxxxxx
Subject: Re: [PATCH v10 1/8] spi: Add multi-cs memories support in SPI core
On 21/11/2023 16:35, Mahapatra, Amit Kumar wrote:
Hello Stefan,setup.
-----Original Message-----chip_select[n].
From: Stefan Binding <sbinding@xxxxxxxxxxxxxxxxxxxxx>
Sent: Tuesday, November 21, 2023 7:28 PM
To: Mahapatra, Amit Kumar <amit.kumar-mahapatra@xxxxxxx>;
broonie@xxxxxxxxxx; tudor.ambarus@xxxxxxxxxx; pratyush@xxxxxxxxxx;
miquel.raynal@xxxxxxxxxxx; richard@xxxxxx; vigneshr@xxxxxx
Cc: linux-spi@xxxxxxxxxxxxxxx; linux-kernel@xxxxxxxxxxxxxxx;
michael@xxxxxxxx; linux-mtd@xxxxxxxxxxxxxxxxxxx;
nicolas.ferre@xxxxxxxxxxxxx; alexandre.belloni@xxxxxxxxxxx;
claudiu.beznea@xxxxxxxxx; Simek, Michal <michal.simek@xxxxxxx>;
linux- arm-kernel@xxxxxxxxxxxxxxxxxxx; git (AMD-Xilinx)
<git@xxxxxxx>; amitrkcian2002@xxxxxxxxx;
patches@xxxxxxxxxxxxxxxxxxxxx
Subject: Re: [PATCH v10 1/8] spi: Add multi-cs memories support in
SPI core
On 21/11/2023 07:39, Mahapatra, Amit Kumar wrote:
Hello Stefan,
-----Original Message-----
From: Stefan Binding <sbinding@xxxxxxxxxxxxxxxxxxxxx>
Sent: Monday, November 20, 2023 8:00 PM
To: Mahapatra, Amit Kumar <amit.kumar-mahapatra@xxxxxxx>;
broonie@xxxxxxxxxx; tudor.ambarus@xxxxxxxxxx; pratyush@xxxxxxxxxx;
miquel.raynal@xxxxxxxxxxx; richard@xxxxxx; vigneshr@xxxxxx
Cc: linux-spi@xxxxxxxxxxxxxxx; linux-kernel@xxxxxxxxxxxxxxx;
michael@xxxxxxxx; linux-mtd@xxxxxxxxxxxxxxxxxxx;
nicolas.ferre@xxxxxxxxxxxxx; alexandre.belloni@xxxxxxxxxxx;
claudiu.beznea@xxxxxxxxx; Simek, Michal <michal.simek@xxxxxxx>;
linux- arm-kernel@xxxxxxxxxxxxxxxxxxx; git (AMD-Xilinx)
<git@xxxxxxx>; amitrkcian2002@xxxxxxxxx;
patches@xxxxxxxxxxxxxxxxxxxxx
Subject: Re: [PATCH v10 1/8] spi: Add multi-cs memories support in
SPI core
On 18/11/2023 13:54, Amit Kumar Mahapatra wrote:
AMD-Xilinx GQSPI controller has two advanced mode that allows theaddress bit.
controller to consider two flashes as one single device.
One of these two mode is the parallel mode in which each byte of
data is stored in both devices, the even bits in the lower flash &
the odd bits in the upper flash. The byte split is automatically
handled by the QSPI controller.
The other mode is the stacked mode in which both the flashes share
the same SPI bus but each of the device contain half of the data.
In this mode, the controller does not follow CS requests but
instead internally wires the two CS levels with the value of the
most significant
For supporting both these modes SPI core need to be updated for
providing multiple CS for a single SPI device.
For adding multi CS support the SPI device need to be aware of all
the CS values. So, the "chip_select" member in the spi_device
structure is now an array that holds all the CS values.
spi_device structure now has a "cs_index_mask" member. This acts
as an index to the chip_select array. If nth bit of
spi->cs_index_mask is set then the driver would assert spi-
In parallel mode all the chip selects are asserted/de-asserted
simultaneously and each byte of data is stored in both devices,
the even bits in one, the odd bits in the other. The split is
automatically handled by the GQSPI controller. The GQSPI
controller supports a maximum of two flashes connected in parallel
mode. A SPI_CONTROLLER_MULTI_CS flag bit is added in the spi
controller flags, through ctlr->flags the spi core will make sure
that the controller is capable of handling multiple chip selects at once.
For supporting multiple CS via GPIO the cs_gpiod member of the
spi_device structure is now an array that holds the gpio
descriptor for each chipselect.
CS GPIO is not tested due to unavailability of necessary hardware
mode.mahapatra@xxxxxxx>Signed-off-by: Amit Kumar Mahapatra <amit.kumar-
---
Hello @Stefen,
We restructured the SPI core implementation, for handling
arbitrary number of devices connected in parallel(multi-cs) or stacked
--We have tested this updated patch on native-cs setup but couldn'tyour feedback.
test cs-gpio due to unavailability of a proper setup. If possible,
could you please retest the cs-gpio use case with this updated
patch and provide
Hi,
I tested this chain on 2 different systems using GPIOs as chip
selects, and see the same error on both:
[ 2.842045] pxa2xx-spi pxa2xx-spi.6: chipselect 0 already in use
Let me know if you need any further testing.
Thanks,
Stefan Binding
---
drivers/spi/spi.c | 192 +++++++++++++++++++++++++++++++-------
nw_idx);include/linux/spi/spi.h | 51 ++++++++---*data)
2 files changed, 191 insertions(+), 52 deletions(-)
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c index
8ead7acb99f3..ff66147ba95f 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -612,10 +612,21 @@ static int spi_dev_check(struct device *dev,
void
{nw_idx++) {
struct spi_device *spi = to_spi_device(dev);
struct spi_device *new_spi = data;
-
- if (spi->controller == new_spi->controller &&
- spi_get_chipselect(spi, 0) == spi_get_chipselect(new_spi, 0))
- return -EBUSY;
+ int idx, nw_idx;
+ u8 cs, cs_nw;
+
+ 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;
+ cs_nw = spi_get_chipselect(spi,
Hi,Thank you for dedicating your time to test my patch.
As per my analysis the error is reported from here as we are
supplying the former SPI device structure to retrieve the CS value
for the new SPI devices.
To fix this, could you kindly substitute the above line with
cs_nw = spi_get_chipselect(new_spi, nw_idx);
and rerun your tests?
If it works correctly, I will incorporate this fix into my upcoming
series.
Regards,
Amit
I've attached my log.
I notice that you add a print to of_spi_parse_dt, however since the laptop I
am using is an x86 laptop, it uses ACPI rather than OF, and I don't think this
function isnt even compiled in.
Upon reviewing the logs, I discovered that in the ACPI flow, I am not
initializing the unused CS[] to FF, as I am doing in the OF flow.
Consequently, in the ACPI flow, all the unused CS[] are automatically
initialized to 0. During the __spi_add_device process, the SPI core faces
difficulty distinguishing between a valid CS value of 0 and an unused CS
value of 0, leading to a failure in the driver probe.
Incorporating the following modifications should resolve this issue.
Kindly apply these changes on top of 1/8 and re-run the test.
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index ff66147ba95f..d0301c17d4f8 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -619,7 +619,7 @@ static int spi_dev_check(struct device *dev, void *data)
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(spi, 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;
@@ -764,6 +764,7 @@ struct spi_device *spi_new_device(struct spi_controller *ctlr,
{
struct spi_device *proxy;
int status;
+ u8 idx;
/*
* NOTE: caller did any chip->bus_num checks necessary.
@@ -779,6 +780,9 @@ struct spi_device *spi_new_device(struct spi_controller *ctlr,
WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
+ for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
+ spi_set_chipselect(proxy, idx, 0xFF);
+
spi_set_chipselect(proxy, 0, chip->chip_select);
proxy->max_speed_hz = chip->max_speed_hz;
proxy->mode = chip->mode;
@@ -2514,6 +2518,7 @@ struct spi_device *spi_new_ancillary_device(struct spi_device *spi,
struct spi_controller *ctlr = spi->controller;
struct spi_device *ancillary;
int rc = 0;
+ u8 idx;
/* Alloc an spi_device */
ancillary = spi_alloc_device(ctlr);
@@ -2524,6 +2529,9 @@ struct spi_device *spi_new_ancillary_device(struct spi_device *spi,
strscpy(ancillary->modalias, "dummy", sizeof(ancillary->modalias));
+ for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
+ spi_set_chipselect(ancillary, idx, 0xFF);
+
/* Use provided chip-select for ancillary device */
spi_set_chipselect(ancillary, 0, chip_select);
@@ -2732,6 +2740,7 @@ struct spi_device *acpi_spi_device_alloc(struct spi_controller *ctlr,
struct acpi_spi_lookup lookup = {};
struct spi_device *spi;
int ret;
+ u8 idx;
if (!ctlr && index == -1)
return ERR_PTR(-EINVAL);
@@ -2767,6 +2776,9 @@ struct spi_device *acpi_spi_device_alloc(struct spi_controller *ctlr,
return ERR_PTR(-ENOMEM);
}
+ for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
+ spi_set_chipselect(spi, idx, 0xFF);
+
ACPI_COMPANION_SET(&spi->dev, adev);
spi->max_speed_hz = lookup.max_speed_hz;
spi->mode |= lookup.mode;
Regards,
Amit
Thanks,
Stefan
*data)Hi,Thank you for the quick testing. For further analysis I have
I still see the same error:
[ 2.748546] pxa2xx-spi pxa2xx-spi.6: chipselect 0 already in use
incorporated additional debug prints on top of 1/8 patch. The
corresponding diff is shared below. Kindly implement the specified
changes, rerun your test and share the kernel logs.
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c index
ff66147ba95f..7f59ea81593d 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -618,8 +618,10 @@ static int spi_dev_check(struct device *dev, void
if (spi->controller == new_spi->controller) {cs_nw);
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
cs = spi_get_chipselect(spi, idx);
+ printk("%s() [%d] CS[%d] = [%d]\n", __func__,
+ __LINE__, idx, cs);
for (nw_idx = 0; nw_idx < SPI_CS_CNT_MAX; nw_idx++) {
- cs_nw = spi_get_chipselect(spi, nw_idx);
+ cs_nw = spi_get_chipselect(new_spi, nw_idx);
+ printk("%s() [%d] CS_NEW[%d] =
+ [%d]\n", __func__, __LINE__, nw_idx, cs_nw);
if (cs != 0xFF && cs_nw != 0xFF && cs == cs_nw) {
dev_err(dev, "chipselect %d already in use\n",
return -EBUSY; @@ -659,8==
+661,10 @@ static int __spi_add_device(struct spi_device *spi)
*/
for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
cs = spi_get_chipselect(spi, idx);
+ printk("%s() [%d] CS[%d] = [%d]\n", __func__,
+ __LINE__, idx, cs);
for (nw_idx = idx + 1; nw_idx < SPI_CS_CNT_MAX; nw_idx++) {
nw_cs = spi_get_chipselect(spi, nw_idx);
+ printk("%s() [%d] CS_NEW[%d] = [%d]\n",
+ __func__, __LINE__, nw_idx, nw_cs);
if (cs != 0xFF && nw_cs != 0xFF && cs == nw_cs) {
dev_err(dev, "chipselect %d already in use\n", nw_cs);
return -EBUSY; @@ -2401,6 +2405,9 @@
static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
for (idx = 0; idx < rc; idx++)
spi_set_chipselect(spi, idx, cs[idx]);
+ for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
+ printk("%s() [%d] CS[%d] = [%d]\n", __func__,
+ __LINE__, idx, spi_get_chipselect(spi, 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
Regards,
Amit
Thanks,
Stefan
+ if (cs != 0xFF && cs_nw != 0xFF && cs
already incs_nw) {
+ dev_err(dev, "chipselect %d
so on.*spi)use\n", cs_nw);
+ return -EBUSY;
+ }
+ }
+ }
+ }
return 0;
}
@@ -629,13 +640,32 @@ static int __spi_add_device(struct
spi_device
{spi_get_chipselect(spi, idx),
struct spi_controller *ctlr = spi->controller;
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. */
+ cs = spi_get_chipselect(spi, idx);
+ if (cs != 0xFF && cs >= ctlr->num_chipselect) {
+ dev_err(dev, "cs%d >= max %d\n",
+ ctlr->num_chipselect);physical CS.
+ return -EINVAL;
+ }
+ }
- /* Chipselects are numbered 0..max; validate. */
- if (spi_get_chipselect(spi, 0) >= ctlr->num_chipselect) {
- dev_err(dev, "cs%d >= max %d\n", spi_get_chipselect(spi, 0),
- ctlr->num_chipselect);
- return -EINVAL;
+ /*
+ * Make sure that multiple logical CS doesn't map to the same
+ * For example, spi->chip_select[0] != spi->chip_select[1] and
nw_idx++) {+ */
+ 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_cs) {+ nw_cs = spi_get_chipselect(spi, nw_idx);
+ if (cs != 0xFF && nw_cs != 0xFF && cs ==
use\n",+ dev_err(dev, "chipselect %d already in
spi_dev_check);*spi)nw_cs);
+ return -EBUSY;
+ }
+ }
}
/* Set the bus ID string */
@@ -647,11 +677,8 @@ static int __spi_add_device(struct spi_device
* its configuration.
*/
status = bus_for_each_dev(&spi_bus_type, NULL, spi,
+686,15 @@- if (status) {
- dev_err(dev, "chipselect %d already in use\n",
- spi_get_chipselect(spi, 0));
+ if (status)
return status;
- }
/* Controller may unregister concurrently */
if (IS_ENABLED(CONFIG_SPI_DYNAMIC) && @@ -659,8
staticcs_gpiods[cs]);static
int __spi_add_device(struct spi_device *spi)0)]);
return -ENODEV;
}
- if (ctlr->cs_gpiods)
- spi_set_csgpiod(spi, 0, ctlr->cs_gpiods[spi_get_chipselect(spi,
+ if (ctlr->cs_gpiods) {
+ 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-
+ }
+ }
/*
* Drivers may modify this initial i/o setup, but will @@
-701,6
+735,9 @@ int spi_add_device(struct spi_device *spi)
struct spi_controller *ctlr = spi->controller;
int status;
+ /* Set the bus ID string */
+ spi_dev_set_name(spi);
+
mutex_lock(&ctlr->add_lock);
status = __spi_add_device(spi);
mutex_unlock(&ctlr->add_lock); @@ -942,32 +979,51 @@
selectvoid spi_res_release(struct spi_controller*ctlr, struct spi_message *mes
}spi_get_chipselect(spi, idx))
/*----------------------------------------------------------------
--
--
-----*/
+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] ==
+ last = true;
+ }
+ }
+ return last;
+}
+
static void spi_set_cs(struct spi_device *spi, bool enable, bool force)
{
bool activate = enable;
+ u8 idx;
/*
* Avoid calling into the driver (or doing delays) if the chip
==* isn't actually changing from the last time this was called.spi_get_chipselect(spi, 0)) ||
*/
- if (!force && ((enable && spi->controller->last_cs ==
- (!enable && spi->controller->last_cs !=spi_get_chipselect(spi, 0))) &&
+ if (!force && ((enable && spi->controller->last_cs_index_mask
== spi-+spi-
cs_index_mask &&
+ spi_is_last_cs(spi)) ||
+ (!enable && spi->controller->last_cs_index_mask
SPI_CS_HIGH;cs_index_mask &&SPI_CS_HIGH)))
+ !spi_is_last_cs(spi))) &&
(spi->controller->last_cs_mode_high == (spi->mode &
return;0)
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,
+: -1;
spi->controller->last_cs_mode_high = spi->mode &
polarity- 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)
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)) {
/*
* Historically ACPI has no means of the GPIO
takesand @@
-979,26 +1035,38 @@ static void spi_set_cs(struct spi_device *spi,enable, bool force)
bool
* ambiguity. That's why we use enable, that
0x01) &&SPI_CS_HIGH
* into account.gpiod_set_value_cansleep(spi_get_csgpiod(spi, 0), !enable);
*/
- if (has_acpi_companion(&spi->dev))
-
- elsegpiod_set_value_cansleep(spi_get_csgpiod(spi, 0), activate);
- /* Polarity handled by GPIO library */
-
+ for (idx = 0; idx < SPI_CS_CNT_MAX; idx++) {
+ if (((spi->cs_index_mask >> idx) &
GPIOdev))+ spi_get_csgpiod(spi, idx)) {
+ if (has_acpi_companion(&spi-
+gpiod_set_value_cansleep(spi_get_csgpiod(spi, idx),
+!enable);
+ else
+ /* Polarity handled by
slave_select */library */
+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 &
SPI_CONTROLLER_GPIO_SS) &&if ((spi->controller->flags &
NULL);spi->controller->set_cs)
spi->controller->set_cs(spi, !enable);
+
+ if (!spi->controller->set_cs_timing) {
+ if (activate)
+ spi_delay_exec(&spi->cs_setup,
NULL);+ else
+ spi_delay_exec(&spi->cs_inactive,
*spi,*spi,+ }device_node *nc,
} else if (spi->controller->set_cs) {
spi->controller->set_cs(spi, !enable);
}
-
- if (spi_get_csgpiod(spi, 0) || !spi->controller->set_cs_timing) {
- if (activate)
- spi_delay_exec(&spi->cs_setup, NULL);
- else
- spi_delay_exec(&spi->cs_inactive, NULL);
- }
}
#ifdef CONFIG_HAS_DMA
@@ -2222,8 +2290,8 @@ static void of_spi_parse_dt_cs_delay(struct
static int of_spi_parse_dt(struct spi_controller *ctlr, struct
spi_device
struct device_node *nc)@@
{
- u32 value;
- int rc;
+ u32 value, cs[SPI_CS_CNT_MAX];
+ int rc, idx;
/* Mode (clock phase/polarity/etc.) */
if (of_property_read_bool(nc, "spi-cpha")) @@ -2295,14
+2363,52
static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device
ofreturn 0;
}
+ if (ctlr->num_chipselect > SPI_CS_CNT_MAX) {
+ dev_err(&ctlr->dev, "No. of CS is more than max. no.
anysupported CS\n");
+ return -EINVAL;
+ }
+
+ /*
+ * Zero(0) is a valid physical CS value and can be located at
0xFF.+ * logical CS in the spi->chip_select[]. If all the physical CSphysical
+ * are initialized to 0 then It would be difficult to differentiate
+ * between a valid physical CS 0 & an unused logical CS whose
+ * CS can be 0. As a solution to this issue initialize all the CS to
1,+ * Now all the unused logical CS will have 0xFF physical CSbe
+value & can
+ * ignore while performing physical CS validity checks.
+ */
+ for (idx = 0; idx < SPI_CS_CNT_MAX; idx++)
+ spi_set_chipselect(spi, idx, 0xFF);
+
/* Device address */
- rc = of_property_read_u32(nc, "reg", &value);
- if (rc) {
+ rc = of_property_read_variable_u32_array(nc, "reg", &cs[0],
multi+ SPI_CS_CNT_MAX);(%d)\n",
+ if (rc < 0) {
dev_err(&ctlr->dev, "%pOF has no valid 'reg' property
nc, 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
CSCS\n");
+ return -EINVAL;i
+ }
+ 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
+ * 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
*ctlr)number is 0 and
+ * spi->chip_select[0] will give the physical CS.set
+ * By default spi->chip_select[0] will hold the physical CS
+number so,
+ * spi->cs_index_mask as 0x01.
+ */
+ spi->cs_index_mask = 0x01;
/* Device speed */
if (!of_property_read_u32(nc, "spi-max-frequency", &value))
@@
-3100,6 +3206,7 @@ int spi_register_controller(struct spi_controller
@controller.struct boardinfo *bi;*ctlr)
int first_dynamic;
int status;
+ int idx;
if (!dev)
return -ENODEV;
@@ -3164,7 +3271,8 @@ int spi_register_controller(struct
spi_controller
}struct spi_message *message)
/* 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);
if (status < 0)
@@ -3889,7 +3997,7 @@ static int __spi_validate(struct spi_device
*spi,
* cs_change is set for each transfer.SPI_CS_WORD) ||
*/
if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits &
- spi_get_csgpiod(spi, 0))) {spi_transfer_cs_change_delay_exec(struct spi_message *msg,
+ spi_is_csgpiod(spi))) {
size_t maxsize = BITS_TO_BYTES(spi->bits_per_word);
int ret;
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 7b4baff63c5c..871d3a6d879b 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -20,6 +20,9 @@
#include <uapi/linux/spi/spi.h>
+/* Max no. of CS supported per spi device */ #define
+SPI_CS_CNT_MAX
+4
+
struct dma_chan;
struct software_node;
struct ptp_system_timestamp;
@@ -132,7 +135,8 @@ extern void
* @max_speed_hz: Maximum clock rate to be used with this chip
* (on this board); may be changed by the device's driver.
* The spi_transfer.speed_hz can override this for each transfer.
- * @chip_select: Chipselect, distinguishing chips handled by
overridden+ * @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.
* This may be changed by the device's driver.
* The "active low" default for chipselect mode can be
driver.@@ -157,8 +161,8 @@ extern voidspi_transfer_cs_change_delay_exec(struct spi_message *msg,
* the device will bind to the named driver and only the named
driver_set_override() to* Do not set directly, because core frees it; use
thenwhen* set or clear it.
- * @cs_gpiod: GPIO descriptor of the chipselect line (optional,
NULL
- * not using a GPIO line)lines
+ * @cs_gpiod: Array of GPIO descriptors of the corresponding
+ chipselect
+ * (optional, NULL when not using a GPIO line)spi_transfer_cs_change_delay_exec(struct spi_message *msg,
* @word_delay: delay to be inserted between consecutive
* words of a transfer
* @cs_setup: delay to be introduced by the controller after
CS is asserted @@ -167,6 +171,7 @@ extern void
* deasserted. If @cs_change_delay is used from @spi_transfer,
*/the
* two delays will be added up.
* @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
* (usually a discrete chip) and CPU memory.
@@ -182,7 +187,7 @@ struct spi_device {
struct spi_controller *controller;
struct spi_controller *master; /* Compatibility layer
Chip selectu32 max_speed_hz;*/
- u8 chip_select;
+ u8 chip_select[SPI_CS_CNT_MAX];
u8 bits_per_word;
bool rt;
#define SPI_NO_TX BIT(31) /* No transmit wire */
@@ -213,7 +218,7 @@ struct spi_device {
void *controller_data;
char modalias[SPI_NAME_SIZE];
const char *driver_override;
- struct gpio_desc *cs_gpiod; /* Chip select GPIO descriptor
+ struct gpio_desc *cs_gpiod[SPI_CS_CNT_MAX]; /*
fromgpio desc */
struct spi_delay word_delay; /* Inter-word delay */
/* CS delays */
struct spi_delay cs_setup;
@@ -223,6 +228,13 @@ struct spi_device {
/* The statistics */
struct spi_statistics __percpu *pcpu_statistics;
+ /* Bit mask of the chipselect(s) that the driver need to use
handle+ * the chipselect array.When the controller is capable to
how+ * 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
assert* the controller talks to each chip, like:chipselect)
@@ -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)
{
- return spi->chip_select;
+ return spi->chip_select[idx];
}
static inline void spi_set_chipselect(struct spi_device *spi,
u8 idx, u8
{u8 idx)
- spi->chip_select = chipselect;
+ spi->chip_select[idx] = chipselect;
}
static inline struct gpio_desc *spi_get_csgpiod(const struct
spi_device *spi,
{gpio_desc *csgpiod)
- return spi->cs_gpiod;
+ return spi->cs_gpiod[idx];
}
static inline void spi_set_csgpiod(struct spi_device *spi, u8
idx, struct
{*spi_new_ancillary_device(struct spi_device *spi, u8 ch
- 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
* @bus_lock_spinlock: spinlock for SPI bus locking
* @bus_lock_mutex: mutex for exclusion of multiple callers
* @bus_lock_flag: indicates that the SPI bus is locked for
exclusive use
+ * @multi_cs_cap: indicates that the SPI Controller can assert/de-
requested.+ * more than one chip select at once.
* @setup: updates the device mode and clocking records used by a
* device's SPI controller; protocol code may call this. This
* must fail if an unrecognized or unsupported mode is
managed */*/@@ -567,6 +592,11 @@ struct spi_controller {
#define SPI_CONTROLLER_MUST_TX BIT(4) /* Requires tx
must#define SPI_CONTROLLER_GPIO_SS BIT(5) /* GPIO CS
select slave */
#define SPI_CONTROLLER_SUSPENDED BIT(6) /* Currentlysuspended */
+ /*
+ * 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-
bool devm_allocated;
@@ -677,7 +707,8 @@ struct spi_controller {
bool rt;
bool auto_runtime_pm;
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 fallback;
struct completion xfer_completion;