sdio_ops.c 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * linux/drivers/mmc/sdio_ops.c
  4. *
  5. * Copyright 2006-2007 Pierre Ossman
  6. */
  7. #include <linux/scatterlist.h>
  8. #include <linux/mmc/host.h>
  9. #include <linux/mmc/card.h>
  10. #include <linux/mmc/mmc.h>
  11. #include <linux/mmc/sdio.h>
  12. #include "core.h"
  13. #include "sdio_ops.h"
  14. int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
  15. {
  16. struct mmc_command cmd = {};
  17. int i, err = 0;
  18. cmd.opcode = SD_IO_SEND_OP_COND;
  19. cmd.arg = ocr;
  20. cmd.flags = MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR;
  21. for (i = 100; i; i--) {
  22. err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
  23. if (err)
  24. break;
  25. /* if we're just probing, do a single pass */
  26. if (ocr == 0)
  27. break;
  28. /* otherwise wait until reset completes */
  29. if (mmc_host_is_spi(host)) {
  30. /*
  31. * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate
  32. * an initialized card under SPI, but some cards
  33. * (Marvell's) only behave when looking at this
  34. * one.
  35. */
  36. if (cmd.resp[1] & MMC_CARD_BUSY)
  37. break;
  38. } else {
  39. if (cmd.resp[0] & MMC_CARD_BUSY)
  40. break;
  41. }
  42. err = -ETIMEDOUT;
  43. mmc_delay(10);
  44. }
  45. if (rocr)
  46. *rocr = cmd.resp[mmc_host_is_spi(host) ? 1 : 0];
  47. return err;
  48. }
  49. static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
  50. unsigned addr, u8 in, u8 *out)
  51. {
  52. struct mmc_command cmd = {};
  53. int err;
  54. if (fn > 7)
  55. return -EINVAL;
  56. /* sanity check */
  57. if (addr & ~0x1FFFF)
  58. return -EINVAL;
  59. cmd.opcode = SD_IO_RW_DIRECT;
  60. cmd.arg = write ? 0x80000000 : 0x00000000;
  61. cmd.arg |= fn << 28;
  62. cmd.arg |= (write && out) ? 0x08000000 : 0x00000000;
  63. cmd.arg |= addr << 9;
  64. cmd.arg |= in;
  65. cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
  66. err = mmc_wait_for_cmd(host, &cmd, 0);
  67. if (err)
  68. return err;
  69. if (mmc_host_is_spi(host)) {
  70. /* host driver already reported errors */
  71. } else {
  72. if (cmd.resp[0] & R5_ERROR)
  73. return -EIO;
  74. if (cmd.resp[0] & R5_FUNCTION_NUMBER)
  75. return -EINVAL;
  76. if (cmd.resp[0] & R5_OUT_OF_RANGE)
  77. return -ERANGE;
  78. }
  79. if (out) {
  80. if (mmc_host_is_spi(host))
  81. *out = (cmd.resp[0] >> 8) & 0xFF;
  82. else
  83. *out = cmd.resp[0] & 0xFF;
  84. }
  85. return 0;
  86. }
  87. int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
  88. unsigned addr, u8 in, u8 *out)
  89. {
  90. return mmc_io_rw_direct_host(card->host, write, fn, addr, in, out);
  91. }
  92. int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
  93. unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
  94. {
  95. struct mmc_request mrq = {};
  96. struct mmc_command cmd = {};
  97. struct mmc_data data = {};
  98. struct scatterlist sg, *sg_ptr;
  99. struct sg_table sgtable;
  100. unsigned int nents, left_size, i;
  101. unsigned int seg_size = card->host->max_seg_size;
  102. int err;
  103. WARN_ON(blksz == 0);
  104. /* sanity check */
  105. if (addr & ~0x1FFFF)
  106. return -EINVAL;
  107. mrq.cmd = &cmd;
  108. mrq.data = &data;
  109. cmd.opcode = SD_IO_RW_EXTENDED;
  110. cmd.arg = write ? 0x80000000 : 0x00000000;
  111. cmd.arg |= fn << 28;
  112. cmd.arg |= incr_addr ? 0x04000000 : 0x00000000;
  113. cmd.arg |= addr << 9;
  114. if (blocks == 0)
  115. cmd.arg |= (blksz == 512) ? 0 : blksz; /* byte mode */
  116. else
  117. cmd.arg |= 0x08000000 | blocks; /* block mode */
  118. cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
  119. data.blksz = blksz;
  120. /* Code in host drivers/fwk assumes that "blocks" always is >=1 */
  121. data.blocks = blocks ? blocks : 1;
  122. data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
  123. left_size = data.blksz * data.blocks;
  124. nents = DIV_ROUND_UP(left_size, seg_size);
  125. if (nents > 1) {
  126. if (sg_alloc_table(&sgtable, nents, GFP_KERNEL))
  127. return -ENOMEM;
  128. data.sg = sgtable.sgl;
  129. data.sg_len = nents;
  130. for_each_sg(data.sg, sg_ptr, data.sg_len, i) {
  131. sg_set_buf(sg_ptr, buf + i * seg_size,
  132. min(seg_size, left_size));
  133. left_size -= seg_size;
  134. }
  135. } else {
  136. data.sg = &sg;
  137. data.sg_len = 1;
  138. sg_init_one(&sg, buf, left_size);
  139. }
  140. mmc_set_data_timeout(&data, card);
  141. mmc_pre_req(card->host, &mrq);
  142. mmc_wait_for_req(card->host, &mrq);
  143. if (cmd.error)
  144. err = cmd.error;
  145. else if (data.error)
  146. err = data.error;
  147. else if (mmc_host_is_spi(card->host))
  148. /* host driver already reported errors */
  149. err = 0;
  150. else if (cmd.resp[0] & R5_ERROR)
  151. err = -EIO;
  152. else if (cmd.resp[0] & R5_FUNCTION_NUMBER)
  153. err = -EINVAL;
  154. else if (cmd.resp[0] & R5_OUT_OF_RANGE)
  155. err = -ERANGE;
  156. else
  157. err = 0;
  158. mmc_post_req(card->host, &mrq, err);
  159. if (nents > 1)
  160. sg_free_table(&sgtable);
  161. return err;
  162. }
  163. int sdio_reset(struct mmc_host *host)
  164. {
  165. int ret;
  166. u8 abort;
  167. /* SDIO Simplified Specification V2.0, 4.4 Reset for SDIO */
  168. ret = mmc_io_rw_direct_host(host, 0, 0, SDIO_CCCR_ABORT, 0, &abort);
  169. if (ret)
  170. abort = 0x08;
  171. else
  172. abort |= 0x08;
  173. return mmc_io_rw_direct_host(host, 1, 0, SDIO_CCCR_ABORT, abort, NULL);
  174. }