spi: Get rid of SPI_ATOMIC_SEQUENCING

SPI_ATOMIC_SEQUENCING was added to accomodate spi flash controllers with
the ability to perform tx and rx of flash command and response at the
same time. Instead of introducing this notion at SPI flash driver layer,
clean up the interface to SPI used by flash.

Flash uses a command-response kind of communication. Thus, even though
SPI is duplex, flash command needs to be sent out on SPI bus and then
flash response should be received on the bus. Some specialized x86
flash controllers are capable of handling command and response in a
single transaction.

In order to support all the varied cases:
1. Add spi_xfer_vector that takes as input a vector of SPI operations
and calls back into SPI controller driver to process these operations.
2. In order to accomodate flash command-response model, use two vectors
while calling into spi_xfer_vector -- one with dout set to
non-NULL(command) and other with din set to non-NULL(response).
3. For specialized SPI flash controllers combine two successive vectors
if the transactions look like a command-response pair.
4. Provide helper functions for common cases like supporting only 2
vectors at a time, supporting n vectors at a time, default vector
operation to cycle through all SPI op vectors one by one.

BUG=chrome-os-partner:59832
BRANCH=None
TEST=Compiles successfully

Change-Id: I4c9e78c585ad95c40c0d5af078ff8251da286236
Signed-off-by: Furquan Shaikh <furquan@chromium.org>
Reviewed-on: https://review.coreboot.org/17681
Tested-by: build bot (Jenkins)
Reviewed-by: Aaron Durbin <adurbin@chromium.org>

1 files changed, 60 insertions, 2 deletions

diff --git a/src/include/spi-generic.h b/src/include/spi-generic.h
index d28fefd026..7eb18a6ac8 100644
--- a/src/include/spi-generic.h
+++ b/src/include/spi-generic.h
@@ -36,20 +36,46 @@ struct spi_slave {
 	const struct spi_ctrlr *ctrlr;
 };
 
+/* Representation of SPI operation status. */
+enum spi_op_status {
+	SPI_OP_NOT_EXECUTED = 0,
+	SPI_OP_SUCCESS = 1,
+	SPI_OP_FAILURE = 2,
+};
+
+/*
+ * Representation of a SPI operation.
+ *
+ * dout:	Pointer to data to send.
+ * bytesout:	Count of data in bytes to send.
+ * din:	Pointer to store received data.
+ * bytesin:	Count of data in bytes to receive.
+ */
+struct spi_op {
+	const void *dout;
+	size_t bytesout;
+	void *din;
+	size_t bytesin;
+	enum spi_op_status status;
+};
+
 /*-----------------------------------------------------------------------
  * Representation of a SPI contoller.
  *
  * claim_bus:	Claim SPI bus and prepare for communication.
  * release_bus: Release SPI bus.
- * xfer:	SPI transfer
  * setup:	Setup given SPI device bus.
+ * xfer:	Perform one SPI transfer operation.
+ * xfer_vector: Vector of SPI transfer operations.
  */
 struct spi_ctrlr {
 	int (*claim_bus)(const struct spi_slave *slave);
 	void (*release_bus)(const struct spi_slave *slave);
+	int (*setup)(const struct spi_slave *slave);
 	int (*xfer)(const struct spi_slave *slave, const void *dout,
 		    size_t bytesout, void *din, size_t bytesin);
-	int (*setup)(const struct spi_slave *slave);
+	int (*xfer_vector)(const struct spi_slave *slave,
+			struct spi_op vectors[], size_t count);
 };
 
 /*-----------------------------------------------------------------------
@@ -134,6 +160,19 @@ void spi_release_bus(const struct spi_slave *slave);
 int spi_xfer(const struct spi_slave *slave, const void *dout, size_t bytesout,
 	     void *din, size_t bytesin);
 
+/*-----------------------------------------------------------------------
+ * Vector of SPI transfer operations
+ *
+ * spi_xfer_vector() interface:
+ *   slave:	The SPI slave which will be sending/receiving the data.
+ *   vectors:	Array of SPI op structures.
+ *   count:	Number of SPI op vectors.
+ *
+ *   Returns: 0 on success, not 0 on failure
+ */
+int spi_xfer_vector(const struct spi_slave *slave,
+		struct spi_op vectors[], size_t count);
+
 unsigned int spi_crop_chunk(unsigned int cmd_len, unsigned int buf_len);
 
 /*-----------------------------------------------------------------------
@@ -158,4 +197,23 @@ static inline int spi_w8r8(const struct spi_slave *slave, unsigned char byte)
 	return ret < 0 ? ret : din[1];
 }
 
+/*
+ * Helper function to allow chipsets to combine two vectors if possible. It can
+ * only handle upto 2 vectors.
+ *
+ * This function is provided to support command-response kind of transactions
+ * expected by users like flash. Some special SPI flash controllers can handle
+ * such command-response operations in a single transaction. For these special
+ * controllers, separate command and response vectors can be combined into a
+ * single operation.
+ *
+ * Two vectors are combined if first vector has a non-NULL dout and NULL din and
+ * second vector has a non-NULL din and NULL dout. Otherwise, each vector is
+ * operated upon one at a time.
+ *
+ * Returns 0 on success and non-zero on failure.
+ */
+int spi_xfer_two_vectors(const struct spi_slave *slave,
+			struct spi_op vectors[], size_t count);
+
 #endif	/* _SPI_GENERIC_H_ */