greybus: spi: fix message transfer over greybus
The actual implementation of transfer_one_message have problems with some cases in the possible transfer options. We try to maximize the number of spi transfers in one greybus operation and need to save state until the full message is dispatch over greybus. Signed-off-by: Rui Miguel Silva <rui.silva@linaro.org> Tested-by: Philip Yang <philipy@bsquare.com> Tested-by: Axel Haslam <ahaslam@baylibre.com> Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Rui Miguel Silva
Greg Kroah-Hartman
Родитель
192c70dcf6
Коммит
0928b2e440
|
|
@ -18,6 +18,11 @@
|
|||
|
||||
struct gb_spi {
|
||||
struct gb_connection *connection;
|
||||
struct spi_transfer *first_xfer;
|
||||
struct spi_transfer *last_xfer;
|
||||
u32 rx_xfer_offset;
|
||||
u32 tx_xfer_offset;
|
||||
u32 last_xfer_size;
|
||||
u16 mode;
|
||||
u16 flags;
|
||||
u32 bits_per_word_mask;
|
||||
|
|
@ -26,6 +31,13 @@ struct gb_spi {
|
|||
u32 max_speed_hz;
|
||||
};
|
||||
|
||||
#define GB_SPI_STATE_MSG_DONE ((void *)0)
|
||||
#define GB_SPI_STATE_MSG_IDLE ((void *)1)
|
||||
#define GB_SPI_STATE_MSG_RUNNING ((void *)2)
|
||||
#define GB_SPI_STATE_OP_READY ((void *)3)
|
||||
#define GB_SPI_STATE_OP_DONE ((void *)4)
|
||||
#define GB_SPI_STATE_MSG_ERROR ((void *)-1)
|
||||
|
||||
static struct spi_master *get_master_from_spi(struct gb_spi *spi)
|
||||
{
|
||||
return gb_connection_get_data(spi->connection);
|
||||
|
|
@ -76,58 +88,120 @@ static size_t calc_tx_xfer_size(u32 tx_size, u32 count, size_t len,
|
|||
return len;
|
||||
}
|
||||
|
||||
static void clean_xfer_state(struct gb_spi *spi)
|
||||
{
|
||||
spi->first_xfer = NULL;
|
||||
spi->last_xfer = NULL;
|
||||
spi->rx_xfer_offset = 0;
|
||||
spi->tx_xfer_offset = 0;
|
||||
spi->last_xfer_size = 0;
|
||||
}
|
||||
|
||||
static int setup_next_xfer(struct gb_spi *spi, struct spi_message *msg)
|
||||
{
|
||||
struct spi_transfer *last_xfer = spi->last_xfer;
|
||||
|
||||
if (msg->state != GB_SPI_STATE_OP_DONE)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* if we transferred all content of the last transfer, reset values and
|
||||
* check if this was the last transfer in the message
|
||||
*/
|
||||
if ((spi->tx_xfer_offset + spi->last_xfer_size == last_xfer->len) ||
|
||||
(spi->rx_xfer_offset + spi->last_xfer_size == last_xfer->len)) {
|
||||
spi->tx_xfer_offset = 0;
|
||||
spi->rx_xfer_offset = 0;
|
||||
if (last_xfer == list_last_entry(&msg->transfers,
|
||||
struct spi_transfer,
|
||||
transfer_list))
|
||||
msg->state = GB_SPI_STATE_MSG_DONE;
|
||||
else
|
||||
spi->first_xfer = list_next_entry(last_xfer,
|
||||
transfer_list);
|
||||
return 0;
|
||||
}
|
||||
|
||||
spi->first_xfer = last_xfer;
|
||||
if (last_xfer->tx_buf)
|
||||
spi->tx_xfer_offset += spi->last_xfer_size;
|
||||
|
||||
if (last_xfer->rx_buf)
|
||||
spi->rx_xfer_offset += spi->last_xfer_size;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct spi_transfer *get_next_xfer(struct spi_transfer *xfer,
|
||||
struct spi_message *msg)
|
||||
{
|
||||
if (xfer == list_last_entry(&msg->transfers, struct spi_transfer,
|
||||
transfer_list))
|
||||
return NULL;
|
||||
|
||||
return list_next_entry(xfer, transfer_list);
|
||||
}
|
||||
|
||||
/* Routines to transfer data */
|
||||
static struct gb_operation *
|
||||
gb_spi_operation_create(struct gb_connection *connection,
|
||||
struct spi_message *msg, u32 *total_len)
|
||||
gb_spi_operation_create(struct gb_spi *spi, struct gb_connection *connection,
|
||||
struct spi_message *msg)
|
||||
{
|
||||
struct gb_spi_transfer_request *request;
|
||||
struct spi_device *dev = msg->spi;
|
||||
struct spi_transfer *xfer;
|
||||
struct gb_spi_transfer *gb_xfer;
|
||||
struct gb_operation *operation;
|
||||
struct spi_transfer *last_xfer = NULL;
|
||||
u32 tx_size = 0, rx_size = 0, count = 0, xfer_len = 0, request_size;
|
||||
u32 tx_xfer_size = 0, rx_xfer_size = 0, last_xfer_size = 0;
|
||||
u32 tx_xfer_size = 0, rx_xfer_size = 0, len;
|
||||
u32 total_len = 0;
|
||||
size_t data_max;
|
||||
void *tx_data;
|
||||
|
||||
data_max = gb_operation_get_payload_size_max(connection);
|
||||
xfer = spi->first_xfer;
|
||||
|
||||
/* Find number of transfers queued and tx/rx length in the message */
|
||||
list_for_each_entry(xfer, &msg->transfers, transfer_list) {
|
||||
|
||||
while (msg->state != GB_SPI_STATE_OP_READY) {
|
||||
msg->state = GB_SPI_STATE_MSG_RUNNING;
|
||||
spi->last_xfer = xfer;
|
||||
|
||||
if (!xfer->tx_buf && !xfer->rx_buf) {
|
||||
dev_err(&connection->bundle->dev,
|
||||
"bufferless transfer, length %u\n", xfer->len);
|
||||
msg->state = GB_SPI_STATE_MSG_ERROR;
|
||||
return NULL;
|
||||
}
|
||||
last_xfer = xfer;
|
||||
|
||||
tx_xfer_size = 0;
|
||||
rx_xfer_size = 0;
|
||||
|
||||
if (xfer->tx_buf) {
|
||||
len = xfer->len - spi->tx_xfer_offset;
|
||||
if (!tx_header_fit_operation(tx_size, count, data_max))
|
||||
break;
|
||||
tx_xfer_size = calc_tx_xfer_size(tx_size, count,
|
||||
xfer->len, data_max);
|
||||
last_xfer_size = tx_xfer_size;
|
||||
len, data_max);
|
||||
spi->last_xfer_size = tx_xfer_size;
|
||||
}
|
||||
|
||||
if (xfer->rx_buf) {
|
||||
len = xfer->len - spi->rx_xfer_offset;
|
||||
rx_xfer_size = calc_rx_xfer_size(rx_size, &tx_xfer_size,
|
||||
xfer->len, data_max);
|
||||
last_xfer_size = rx_xfer_size;
|
||||
len, data_max);
|
||||
spi->last_xfer_size = rx_xfer_size;
|
||||
}
|
||||
|
||||
tx_size += tx_xfer_size;
|
||||
rx_size += rx_xfer_size;
|
||||
|
||||
*total_len += last_xfer_size;
|
||||
total_len += spi->last_xfer_size;
|
||||
count++;
|
||||
|
||||
if (xfer->len != last_xfer_size)
|
||||
break;
|
||||
xfer = get_next_xfer(xfer, msg);
|
||||
if (!xfer || total_len >= data_max)
|
||||
msg->state = GB_SPI_STATE_OP_READY;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -153,9 +227,10 @@ gb_spi_operation_create(struct gb_connection *connection,
|
|||
tx_data = gb_xfer + count; /* place tx data after last gb_xfer */
|
||||
|
||||
/* Fill in the transfers array */
|
||||
list_for_each_entry(xfer, &msg->transfers, transfer_list) {
|
||||
if (last_xfer && xfer == last_xfer)
|
||||
xfer_len = last_xfer_size;
|
||||
xfer = spi->first_xfer;
|
||||
while (msg->state != GB_SPI_STATE_OP_DONE) {
|
||||
if (xfer == spi->last_xfer)
|
||||
xfer_len = spi->last_xfer_size;
|
||||
else
|
||||
xfer_len = xfer->len;
|
||||
|
||||
|
|
@ -168,34 +243,54 @@ gb_spi_operation_create(struct gb_connection *connection,
|
|||
/* Copy tx data */
|
||||
if (xfer->tx_buf) {
|
||||
gb_xfer->rdwr |= GB_SPI_XFER_WRITE;
|
||||
memcpy(tx_data, xfer->tx_buf, xfer_len);
|
||||
memcpy(tx_data, xfer->tx_buf + spi->tx_xfer_offset,
|
||||
xfer_len);
|
||||
tx_data += xfer_len;
|
||||
}
|
||||
|
||||
if (xfer->rx_buf)
|
||||
gb_xfer->rdwr |= GB_SPI_XFER_READ;
|
||||
|
||||
if (last_xfer && xfer == last_xfer)
|
||||
break;
|
||||
if (xfer == spi->last_xfer) {
|
||||
msg->state = GB_SPI_STATE_OP_DONE;
|
||||
continue;
|
||||
}
|
||||
|
||||
gb_xfer++;
|
||||
xfer = get_next_xfer(xfer, msg);
|
||||
}
|
||||
|
||||
msg->actual_length += total_len;
|
||||
|
||||
return operation;
|
||||
}
|
||||
|
||||
static void gb_spi_decode_response(struct spi_message *msg,
|
||||
static void gb_spi_decode_response(struct gb_spi *spi, struct spi_message *msg,
|
||||
struct gb_spi_transfer_response *response)
|
||||
{
|
||||
struct spi_transfer *xfer;
|
||||
struct spi_transfer *xfer = spi->first_xfer;
|
||||
void *rx_data = response->data;
|
||||
u32 xfer_len;
|
||||
|
||||
list_for_each_entry(xfer, &msg->transfers, transfer_list) {
|
||||
while (xfer) {
|
||||
/* Copy rx data */
|
||||
if (xfer->rx_buf) {
|
||||
memcpy(xfer->rx_buf, rx_data, xfer->len);
|
||||
rx_data += xfer->len;
|
||||
if (xfer == spi->first_xfer)
|
||||
xfer_len = xfer->len - spi->rx_xfer_offset;
|
||||
else if (xfer == spi->last_xfer)
|
||||
xfer_len = spi->last_xfer_size;
|
||||
else
|
||||
xfer_len = xfer->len;
|
||||
|
||||
memcpy(xfer->rx_buf + spi->rx_xfer_offset, rx_data,
|
||||
xfer_len);
|
||||
rx_data += xfer_len;
|
||||
}
|
||||
|
||||
if (xfer == spi->last_xfer)
|
||||
break;
|
||||
|
||||
xfer = list_next_entry(xfer, transfer_list);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -206,27 +301,45 @@ static int gb_spi_transfer_one_message(struct spi_master *master,
|
|||
struct gb_connection *connection = spi->connection;
|
||||
struct gb_spi_transfer_response *response;
|
||||
struct gb_operation *operation;
|
||||
u32 len = 0;
|
||||
int ret;
|
||||
int ret = 0;
|
||||
|
||||
operation = gb_spi_operation_create(connection, msg, &len);
|
||||
if (!operation)
|
||||
return -ENOMEM;
|
||||
|
||||
ret = gb_operation_request_send_sync(operation);
|
||||
if (!ret) {
|
||||
response = operation->response->payload;
|
||||
if (response)
|
||||
gb_spi_decode_response(msg, response);
|
||||
} else {
|
||||
dev_err(&connection->bundle->dev,
|
||||
"transfer operation failed: %d\n", ret);
|
||||
spi->first_xfer = list_first_entry_or_null(&msg->transfers,
|
||||
struct spi_transfer,
|
||||
transfer_list);
|
||||
if (!spi->first_xfer) {
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
gb_operation_put(operation);
|
||||
msg->state = GB_SPI_STATE_MSG_IDLE;
|
||||
|
||||
msg->actual_length = len;
|
||||
msg->status = 0;
|
||||
while (msg->state != GB_SPI_STATE_MSG_DONE &&
|
||||
msg->state != GB_SPI_STATE_MSG_ERROR) {
|
||||
operation = gb_spi_operation_create(spi, connection, msg);
|
||||
if (!operation) {
|
||||
msg->state = GB_SPI_STATE_MSG_ERROR;
|
||||
ret = -EINVAL;
|
||||
continue;
|
||||
}
|
||||
|
||||
ret = gb_operation_request_send_sync(operation);
|
||||
if (!ret) {
|
||||
response = operation->response->payload;
|
||||
if (response)
|
||||
gb_spi_decode_response(spi, msg, response);
|
||||
} else {
|
||||
dev_err(&connection->bundle->dev,
|
||||
"transfer operation failed: %d\n", ret);
|
||||
msg->state = GB_SPI_STATE_MSG_ERROR;
|
||||
}
|
||||
|
||||
gb_operation_put(operation);
|
||||
setup_next_xfer(spi, msg);
|
||||
}
|
||||
|
||||
out:
|
||||
msg->status = ret;
|
||||
clean_xfer_state(spi);
|
||||
spi_finalize_current_message(master);
|
||||
|
||||
return ret;
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче