spi-mem-nodm.c 3.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/
  4. */
  5. #include <log.h>
  6. #include <malloc.h>
  7. #include <spi.h>
  8. #include <spi-mem.h>
  9. int spi_mem_exec_op(struct spi_slave *slave,
  10. const struct spi_mem_op *op)
  11. {
  12. unsigned int pos = 0;
  13. const u8 *tx_buf = NULL;
  14. u8 *rx_buf = NULL;
  15. u8 *op_buf;
  16. int op_len;
  17. u32 flag;
  18. int ret;
  19. int i;
  20. if (op->data.nbytes) {
  21. if (op->data.dir == SPI_MEM_DATA_IN)
  22. rx_buf = op->data.buf.in;
  23. else
  24. tx_buf = op->data.buf.out;
  25. }
  26. op_len = op->cmd.nbytes + op->addr.nbytes + op->dummy.nbytes;
  27. op_buf = calloc(1, op_len);
  28. ret = spi_claim_bus(slave);
  29. if (ret < 0)
  30. return ret;
  31. op_buf[pos++] = op->cmd.opcode;
  32. if (op->addr.nbytes) {
  33. for (i = 0; i < op->addr.nbytes; i++)
  34. op_buf[pos + i] = op->addr.val >>
  35. (8 * (op->addr.nbytes - i - 1));
  36. pos += op->addr.nbytes;
  37. }
  38. if (op->dummy.nbytes)
  39. memset(op_buf + pos, 0xff, op->dummy.nbytes);
  40. /* 1st transfer: opcode + address + dummy cycles */
  41. flag = SPI_XFER_BEGIN;
  42. /* Make sure to set END bit if no tx or rx data messages follow */
  43. if (!tx_buf && !rx_buf)
  44. flag |= SPI_XFER_END;
  45. ret = spi_xfer(slave, op_len * 8, op_buf, NULL, flag);
  46. if (ret)
  47. return ret;
  48. /* 2nd transfer: rx or tx data path */
  49. if (tx_buf || rx_buf) {
  50. ret = spi_xfer(slave, op->data.nbytes * 8, tx_buf,
  51. rx_buf, SPI_XFER_END);
  52. if (ret)
  53. return ret;
  54. }
  55. spi_release_bus(slave);
  56. for (i = 0; i < pos; i++)
  57. debug("%02x ", op_buf[i]);
  58. debug("| [%dB %s] ",
  59. tx_buf || rx_buf ? op->data.nbytes : 0,
  60. tx_buf || rx_buf ? (tx_buf ? "out" : "in") : "-");
  61. for (i = 0; i < op->data.nbytes; i++)
  62. debug("%02x ", tx_buf ? tx_buf[i] : rx_buf[i]);
  63. debug("[ret %d]\n", ret);
  64. free(op_buf);
  65. if (ret < 0)
  66. return ret;
  67. return 0;
  68. }
  69. int spi_mem_adjust_op_size(struct spi_slave *slave,
  70. struct spi_mem_op *op)
  71. {
  72. unsigned int len;
  73. len = op->cmd.nbytes + op->addr.nbytes + op->dummy.nbytes;
  74. if (slave->max_write_size && len > slave->max_write_size)
  75. return -EINVAL;
  76. if (op->data.dir == SPI_MEM_DATA_IN) {
  77. if (slave->max_read_size)
  78. op->data.nbytes = min(op->data.nbytes,
  79. slave->max_read_size);
  80. } else if (slave->max_write_size) {
  81. op->data.nbytes = min(op->data.nbytes,
  82. slave->max_write_size - len);
  83. }
  84. if (!op->data.nbytes)
  85. return -EINVAL;
  86. return 0;
  87. }
  88. static int spi_check_buswidth_req(struct spi_slave *slave, u8 buswidth, bool tx)
  89. {
  90. u32 mode = slave->mode;
  91. switch (buswidth) {
  92. case 1:
  93. return 0;
  94. case 2:
  95. if ((tx && (mode & (SPI_TX_DUAL | SPI_TX_QUAD))) ||
  96. (!tx && (mode & (SPI_RX_DUAL | SPI_RX_QUAD))))
  97. return 0;
  98. break;
  99. case 4:
  100. if ((tx && (mode & SPI_TX_QUAD)) ||
  101. (!tx && (mode & SPI_RX_QUAD)))
  102. return 0;
  103. break;
  104. case 8:
  105. if ((tx && (mode & SPI_TX_OCTAL)) ||
  106. (!tx && (mode & SPI_RX_OCTAL)))
  107. return 0;
  108. break;
  109. default:
  110. break;
  111. }
  112. return -ENOTSUPP;
  113. }
  114. bool spi_mem_supports_op(struct spi_slave *slave, const struct spi_mem_op *op)
  115. {
  116. if (spi_check_buswidth_req(slave, op->cmd.buswidth, true))
  117. return false;
  118. if (op->addr.nbytes &&
  119. spi_check_buswidth_req(slave, op->addr.buswidth, true))
  120. return false;
  121. if (op->dummy.nbytes &&
  122. spi_check_buswidth_req(slave, op->dummy.buswidth, true))
  123. return false;
  124. if (op->data.nbytes &&
  125. spi_check_buswidth_req(slave, op->data.buswidth,
  126. op->data.dir == SPI_MEM_DATA_OUT))
  127. return false;
  128. if (op->cmd.dtr || op->addr.dtr || op->dummy.dtr || op->data.dtr)
  129. return false;
  130. if (op->cmd.nbytes != 1)
  131. return false;
  132. return true;
  133. }