mmc_ops.rar_mmc_ops

#include <linux/slab.h> #include <linux/export.h> #include <linux/types.h> #include <linux/scatterlist.h> #include <linux/mmc/host.h> #include <linux/mmc/card.h> #include <linux/mmc/mmc.h> #include "core.h" #include "mmc_ops.h" #define MMC_OPS_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */ static inline int __mmc_send_status(struct mmc_card *card, u32 *status, bool ignore_crc) { int err; struct mmc_command cmd = {0}; BUG_ON(!card); BUG_ON(!card->host); cmd.opcode = MMC_SEND_STATUS; if (!mmc_host_is_spi(card->host)) cmd.arg = card->rca << 16; cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; if (ignore_crc) cmd.flags &= ~MMC_RSP_CRC; err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); if (err) return err; /* NOTE: callers are required to understand the difference * between "native" and SPI format status words! */ if (status) *status = cmd.resp[0]; return 0; } int mmc_send_status(struct mmc_card *card, u32 *status) { return __mmc_send_status(card, status, false); } static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card) { int err; struct mmc_command cmd = {0}; BUG_ON(!host); cmd.opcode = MMC_SELECT_CARD; if (card) { cmd.arg = card->rca << 16; cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; } else { cmd.arg = 0; cmd.flags = MMC_RSP_NONE | MMC_CMD_AC; } err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); if (err) return err; return 0; } int mmc_select_card(struct mmc_card *card) { BUG_ON(!card); return _mmc_select_card(card->host, card); } int mmc_deselect_cards(struct mmc_host *host) { return _mmc_select_card(host, NULL); } int mmc_go_idle(struct mmc_host *host) { int err; struct mmc_command cmd = {0}; /* * Non-SPI hosts need to prevent chipselect going active during * GO_IDLE; that would put chips into SPI mode. Remind them of * that in case of hardware that won't pull up DAT3/nCS otherwise. * * SPI hosts ignore ios.chip_select; it's managed according to * rules that must accommodate non-MMC slaves which this layer * won't even know about. */ if (!mmc_host_is_spi(host)) { mmc_set_chip_select(host, MMC_CS_HIGH); mmc_delay(1); } cmd.opcode = MMC_GO_IDLE_STATE; cmd.arg = 0; cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC; err = mmc_wait_for_cmd(host, &cmd, 0); mmc_delay(1); if (!mmc_host_is_spi(host)) { mmc_set_chip_select(host, MMC_CS_DONTCARE); mmc_delay(1); } host->use_spi_crc = 0; return err; } int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) { struct mmc_command cmd = {0}; int i, err = 0; BUG_ON(!host); cmd.opcode = MMC_SEND_OP_COND; cmd.arg = mmc_host_is_spi(host) ? 0 : ocr; cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR; for (i = 100; i; i--) { err = mmc_wait_for_cmd(host, &cmd, 0); if (err) break; /* if we're just probing, do a single pass */ if (ocr == 0) break; /* otherwise wait until reset completes */ if (mmc_host_is_spi(host)) { if (!(cmd.resp[0] & R1_SPI_IDLE)) break; } else { if (cmd.resp[0] & MMC_CARD_BUSY) break; } err = -ETIMEDOUT; mmc_delay(10); } if (rocr && !mmc_host_is_spi(host)) *rocr = cmd.resp[0]; return err; } int mmc_all_send_cid(struct mmc_host *host, u32 *cid) { int err; struct mmc_command cmd = {0}; BUG_ON(!host); BUG_ON(!cid); cmd.opcode = MMC_ALL_SEND_CID; cmd.arg = 0; cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); if (err) return err; memcpy(cid, cmd.resp, sizeof(u32) * 4); return 0; } int mmc_set_relative_addr(struct mmc_card *card) { int err; struct mmc_command cmd = {0}; BUG_ON(!card); BUG_ON(!card->host); cmd.opcode = MMC_SET_RELATIVE_ADDR; cmd.arg = card->rca << 16; cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); if (err) return err; return 0; } static int mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode) { int err; struct mmc_command cmd = {0}; BUG_ON(!host); BUG_ON(!cxd); cmd.opcode = opcode; cmd.arg = arg; cmd.flags = MMC_RSP_R2 | MMC_CMD_AC; err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); if (err) return err; memcpy(cxd, cmd.resp, sizeof(u32) * 4); return 0; } /* * NOTE: void *buf, caller for the buf is required to use DMA-capable * buffer or on-stack buffer (with some overhead in callee). */ static int mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host, u32 opcode, void *buf, unsigned len) { struct mmc_request mrq = {NULL}; struct mmc_command cmd = {0}; struct mmc_data data = {0}; struct scatterlist sg; void *data_buf; int is_on_stack; is_on_stack = object_is_on_stack(buf); if (is_on_stack) { /* * dma onto stack is unsafe/nonportable, but callers to this * routine normally provide temporary on-stack buffers ... */ data_buf = kmalloc(len, GFP_KERNEL); if (!data_buf) return -ENOMEM; } else data_buf = buf; mrq.cmd = &cmd; mrq.data = &data; cmd.opcode = opcode; cmd.arg = 0; /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we * rely on callers to never use this with "native" calls for reading * CSD or CID. Native versions of those commands use the R2 type, * not R1 plus a data block. */ cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; data.blksz = len; data.blocks = 1; data.flags = MMC_DATA_READ; data.sg = &sg; data.sg_len = 1; sg_init_one(&sg, data_buf, len); if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) { /* * The spec states that CSR and CID accesses have a timeout * of 64 clock cycles. */ data.timeout_ns = 0; data.timeout_clks = 64; } else mmc_set_data_timeout(&data, card); mmc_wait_for_req(host, &mrq); if (is_on_stack) { memcpy(buf, data_buf, len); kfree(data_buf); } if (cmd.error) return cmd.error; if (data.error) return data.error; return 0; } int mmc_send_csd(struct mmc_card *card, u32 *csd) { int ret, i; u32 *csd_tmp; if (!mmc_host_is_spi(card->host)) return mmc_send_cxd_native(card->host, card->rca << 16, csd, MMC_SEND_CSD); csd_tmp = kmalloc(16, GFP_KERNEL); if (!csd_tmp) return -ENOMEM; ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16); if (ret) goto err; for (i = 0;i < 4;i++) csd[i] = be32_to_cpu(csd_tmp[i]); err: kfree(csd_tmp); return ret; } int mmc_send_cid(struct mmc_host *host, u32 *cid) { int ret, i; u32 *cid_tmp; if (!mmc_host_is_spi(host)) { if (!host->card) return -EINVAL; return mmc_send_cxd_native(host, host->card->rca << 16, cid, MMC_SEND_CID); } cid_tmp = kmalloc(16, GFP_KERNEL); if (!cid_tmp) return -ENOMEM; ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16); if (ret) goto err; for (i = 0;i < 4;i++) cid[i] = be32_to_cpu(cid_tmp[i]); err: kfree(cid_tmp); return ret; } int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd) { return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, ext_csd, 512); } EXPORT_SYMBOL_GPL(mmc_send_ext_csd); int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp) { struct mmc_command cmd = {0}; int err; cmd.opcode = MMC_SPI_READ_OCR; cmd.arg = highcap ? (1 << 30) : 0; cmd.flags = MMC_RSP_SPI_R3; err = mmc_wait_for_cmd(host, &cmd, 0); *ocrp = cmd.resp[1]; return err; } int mmc_spi_set_crc(struct mmc_host *host, int use_crc) { struct mmc_command cmd = {0}; int err; cmd.opcode = MMC_SPI_CRC_ON_OFF; cmd.flags = MMC_RSP_SPI_R1; cmd.arg = use_crc; err = mmc_wait_for_cmd(host, &cmd, 0); if (!err) host->use_spi_crc = use_crc; return err; } /** * __mmc_switch - modify EXT_CSD register * @card: the MMC card associated with the data transfer * @set: cmd set values * @index: EXT_CSD register index * @value: value to program into EXT_CSD register * @timeout_ms: timeout (ms) for operation performed by register write, * timeout of zero implies maximum possible timeout * @