1 /* 2 * linux/drivers/mmc/core/mmc_ops.h 3 * 4 * Copyright 2006-2007 Pierre Ossman 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or (at 9 * your option) any later version. 10 */ 11 12 #include <linux/slab.h> 13 #include <linux/export.h> 14 #include <linux/types.h> 15 #include <linux/scatterlist.h> 16 17 #include <linux/mmc/host.h> 18 #include <linux/mmc/card.h> 19 #include <linux/mmc/mmc.h> 20 21 #include "core.h" 22 #include "mmc_ops.h" 23 24 #define MMC_OPS_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */ 25 26 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card) 27 { 28 int err; 29 struct mmc_command cmd = {0}; 30 31 BUG_ON(!host); 32 33 cmd.opcode = MMC_SELECT_CARD; 34 35 if (card) { 36 cmd.arg = card->rca << 16; 37 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 38 } else { 39 cmd.arg = 0; 40 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC; 41 } 42 43 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 44 if (err) 45 return err; 46 47 return 0; 48 } 49 50 int mmc_select_card(struct mmc_card *card) 51 { 52 BUG_ON(!card); 53 54 return _mmc_select_card(card->host, card); 55 } 56 57 int mmc_deselect_cards(struct mmc_host *host) 58 { 59 return _mmc_select_card(host, NULL); 60 } 61 62 int mmc_go_idle(struct mmc_host *host) 63 { 64 int err; 65 struct mmc_command cmd = {0}; 66 67 /* 68 * Non-SPI hosts need to prevent chipselect going active during 69 * GO_IDLE; that would put chips into SPI mode. Remind them of 70 * that in case of hardware that won't pull up DAT3/nCS otherwise. 71 * 72 * SPI hosts ignore ios.chip_select; it's managed according to 73 * rules that must accommodate non-MMC slaves which this layer 74 * won't even know about. 75 */ 76 if (!mmc_host_is_spi(host)) { 77 mmc_set_chip_select(host, MMC_CS_HIGH); 78 mmc_delay(1); 79 } 80 81 cmd.opcode = MMC_GO_IDLE_STATE; 82 cmd.arg = 0; 83 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC; 84 85 err = mmc_wait_for_cmd(host, &cmd, 0); 86 87 mmc_delay(1); 88 89 if (!mmc_host_is_spi(host)) { 90 mmc_set_chip_select(host, MMC_CS_DONTCARE); 91 mmc_delay(1); 92 } 93 94 host->use_spi_crc = 0; 95 96 return err; 97 } 98 99 int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) 100 { 101 struct mmc_command cmd = {0}; 102 int i, err = 0; 103 104 BUG_ON(!host); 105 106 cmd.opcode = MMC_SEND_OP_COND; 107 cmd.arg = mmc_host_is_spi(host) ? 0 : ocr; 108 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR; 109 110 for (i = 100; i; i--) { 111 err = mmc_wait_for_cmd(host, &cmd, 0); 112 if (err) 113 break; 114 115 /* if we're just probing, do a single pass */ 116 if (ocr == 0) 117 break; 118 119 /* otherwise wait until reset completes */ 120 if (mmc_host_is_spi(host)) { 121 if (!(cmd.resp[0] & R1_SPI_IDLE)) 122 break; 123 } else { 124 if (cmd.resp[0] & MMC_CARD_BUSY) 125 break; 126 } 127 128 err = -ETIMEDOUT; 129 130 mmc_delay(10); 131 } 132 133 if (rocr && !mmc_host_is_spi(host)) 134 *rocr = cmd.resp[0]; 135 136 return err; 137 } 138 139 int mmc_all_send_cid(struct mmc_host *host, u32 *cid) 140 { 141 int err; 142 struct mmc_command cmd = {0}; 143 144 BUG_ON(!host); 145 BUG_ON(!cid); 146 147 cmd.opcode = MMC_ALL_SEND_CID; 148 cmd.arg = 0; 149 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 150 151 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 152 if (err) 153 return err; 154 155 memcpy(cid, cmd.resp, sizeof(u32) * 4); 156 157 return 0; 158 } 159 160 int mmc_set_relative_addr(struct mmc_card *card) 161 { 162 int err; 163 struct mmc_command cmd = {0}; 164 165 BUG_ON(!card); 166 BUG_ON(!card->host); 167 168 cmd.opcode = MMC_SET_RELATIVE_ADDR; 169 cmd.arg = card->rca << 16; 170 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 171 172 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 173 if (err) 174 return err; 175 176 return 0; 177 } 178 179 static int 180 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode) 181 { 182 int err; 183 struct mmc_command cmd = {0}; 184 185 BUG_ON(!host); 186 BUG_ON(!cxd); 187 188 cmd.opcode = opcode; 189 cmd.arg = arg; 190 cmd.flags = MMC_RSP_R2 | MMC_CMD_AC; 191 192 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 193 if (err) 194 return err; 195 196 memcpy(cxd, cmd.resp, sizeof(u32) * 4); 197 198 return 0; 199 } 200 201 /* 202 * NOTE: void *buf, caller for the buf is required to use DMA-capable 203 * buffer or on-stack buffer (with some overhead in callee). 204 */ 205 static int 206 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host, 207 u32 opcode, void *buf, unsigned len) 208 { 209 struct mmc_request mrq = {NULL}; 210 struct mmc_command cmd = {0}; 211 struct mmc_data data = {0}; 212 struct scatterlist sg; 213 void *data_buf; 214 int is_on_stack; 215 216 is_on_stack = object_is_on_stack(buf); 217 if (is_on_stack) { 218 /* 219 * dma onto stack is unsafe/nonportable, but callers to this 220 * routine normally provide temporary on-stack buffers ... 221 */ 222 data_buf = kmalloc(len, GFP_KERNEL); 223 if (!data_buf) 224 return -ENOMEM; 225 } else 226 data_buf = buf; 227 228 mrq.cmd = &cmd; 229 mrq.data = &data; 230 231 cmd.opcode = opcode; 232 cmd.arg = 0; 233 234 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we 235 * rely on callers to never use this with "native" calls for reading 236 * CSD or CID. Native versions of those commands use the R2 type, 237 * not R1 plus a data block. 238 */ 239 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 240 241 data.blksz = len; 242 data.blocks = 1; 243 data.flags = MMC_DATA_READ; 244 data.sg = &sg; 245 data.sg_len = 1; 246 247 sg_init_one(&sg, data_buf, len); 248 249 if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) { 250 /* 251 * The spec states that CSR and CID accesses have a timeout 252 * of 64 clock cycles. 253 */ 254 data.timeout_ns = 0; 255 data.timeout_clks = 64; 256 } else 257 mmc_set_data_timeout(&data, card); 258 259 mmc_wait_for_req(host, &mrq); 260 261 if (is_on_stack) { 262 memcpy(buf, data_buf, len); 263 kfree(data_buf); 264 } 265 266 if (cmd.error) 267 return cmd.error; 268 if (data.error) 269 return data.error; 270 271 return 0; 272 } 273 274 int mmc_send_csd(struct mmc_card *card, u32 *csd) 275 { 276 int ret, i; 277 u32 *csd_tmp; 278 279 if (!mmc_host_is_spi(card->host)) 280 return mmc_send_cxd_native(card->host, card->rca << 16, 281 csd, MMC_SEND_CSD); 282 283 csd_tmp = kmalloc(16, GFP_KERNEL); 284 if (!csd_tmp) 285 return -ENOMEM; 286 287 ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16); 288 if (ret) 289 goto err; 290 291 for (i = 0;i < 4;i++) 292 csd[i] = be32_to_cpu(csd_tmp[i]); 293 294 err: 295 kfree(csd_tmp); 296 return ret; 297 } 298 299 int mmc_send_cid(struct mmc_host *host, u32 *cid) 300 { 301 int ret, i; 302 u32 *cid_tmp; 303 304 if (!mmc_host_is_spi(host)) { 305 if (!host->card) 306 return -EINVAL; 307 return mmc_send_cxd_native(host, host->card->rca << 16, 308 cid, MMC_SEND_CID); 309 } 310 311 cid_tmp = kmalloc(16, GFP_KERNEL); 312 if (!cid_tmp) 313 return -ENOMEM; 314 315 ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16); 316 if (ret) 317 goto err; 318 319 for (i = 0;i < 4;i++) 320 cid[i] = be32_to_cpu(cid_tmp[i]); 321 322 err: 323 kfree(cid_tmp); 324 return ret; 325 } 326 327 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd) 328 { 329 return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, 330 ext_csd, 512); 331 } 332 EXPORT_SYMBOL_GPL(mmc_send_ext_csd); 333 334 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp) 335 { 336 struct mmc_command cmd = {0}; 337 int err; 338 339 cmd.opcode = MMC_SPI_READ_OCR; 340 cmd.arg = highcap ? (1 << 30) : 0; 341 cmd.flags = MMC_RSP_SPI_R3; 342 343 err = mmc_wait_for_cmd(host, &cmd, 0); 344 345 *ocrp = cmd.resp[1]; 346 return err; 347 } 348 349 int mmc_spi_set_crc(struct mmc_host *host, int use_crc) 350 { 351 struct mmc_command cmd = {0}; 352 int err; 353 354 cmd.opcode = MMC_SPI_CRC_ON_OFF; 355 cmd.flags = MMC_RSP_SPI_R1; 356 cmd.arg = use_crc; 357 358 err = mmc_wait_for_cmd(host, &cmd, 0); 359 if (!err) 360 host->use_spi_crc = use_crc; 361 return err; 362 } 363 364 /** 365 * __mmc_switch - modify EXT_CSD register 366 * @card: the MMC card associated with the data transfer 367 * @set: cmd set values 368 * @index: EXT_CSD register index 369 * @value: value to program into EXT_CSD register 370 * @timeout_ms: timeout (ms) for operation performed by register write, 371 * timeout of zero implies maximum possible timeout 372 * @use_busy_signal: use the busy signal as response type 373 * 374 * Modifies the EXT_CSD register for selected card. 375 */ 376 int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, 377 unsigned int timeout_ms, bool use_busy_signal) 378 { 379 int err; 380 struct mmc_command cmd = {0}; 381 unsigned long timeout; 382 u32 status; 383 384 BUG_ON(!card); 385 BUG_ON(!card->host); 386 387 cmd.opcode = MMC_SWITCH; 388 cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 389 (index << 16) | 390 (value << 8) | 391 set; 392 cmd.flags = MMC_CMD_AC; 393 if (use_busy_signal) 394 cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B; 395 else 396 cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1; 397 398 399 cmd.cmd_timeout_ms = timeout_ms; 400 if (index == EXT_CSD_SANITIZE_START) 401 cmd.sanitize_busy = true; 402 403 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 404 if (err) 405 return err; 406 407 /* No need to check card status in case of unblocking command */ 408 if (!use_busy_signal) 409 return 0; 410 411 /* Must check status to be sure of no errors */ 412 timeout = jiffies + msecs_to_jiffies(MMC_OPS_TIMEOUT_MS); 413 do { 414 err = mmc_send_status(card, &status); 415 if (err) 416 return err; 417 if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) 418 break; 419 if (mmc_host_is_spi(card->host)) 420 break; 421 422 /* Timeout if the device never leaves the program state. */ 423 if (time_after(jiffies, timeout)) { 424 pr_err("%s: Card stuck in programming state! %s\n", 425 mmc_hostname(card->host), __func__); 426 return -ETIMEDOUT; 427 } 428 } while (R1_CURRENT_STATE(status) == R1_STATE_PRG); 429 430 if (mmc_host_is_spi(card->host)) { 431 if (status & R1_SPI_ILLEGAL_COMMAND) 432 return -EBADMSG; 433 } else { 434 if (status & 0xFDFFA000) 435 pr_warning("%s: unexpected status %#x after " 436 "switch", mmc_hostname(card->host), status); 437 if (status & R1_SWITCH_ERROR) 438 return -EBADMSG; 439 } 440 441 return 0; 442 } 443 EXPORT_SYMBOL_GPL(__mmc_switch); 444 445 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, 446 unsigned int timeout_ms) 447 { 448 return __mmc_switch(card, set, index, value, timeout_ms, true); 449 } 450 EXPORT_SYMBOL_GPL(mmc_switch); 451 452 int mmc_send_status(struct mmc_card *card, u32 *status) 453 { 454 int err; 455 struct mmc_command cmd = {0}; 456 457 BUG_ON(!card); 458 BUG_ON(!card->host); 459 460 cmd.opcode = MMC_SEND_STATUS; 461 if (!mmc_host_is_spi(card->host)) 462 cmd.arg = card->rca << 16; 463 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; 464 465 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 466 if (err) 467 return err; 468 469 /* NOTE: callers are required to understand the difference 470 * between "native" and SPI format status words! 471 */ 472 if (status) 473 *status = cmd.resp[0]; 474 475 return 0; 476 } 477 478 static int 479 mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode, 480 u8 len) 481 { 482 struct mmc_request mrq = {NULL}; 483 struct mmc_command cmd = {0}; 484 struct mmc_data data = {0}; 485 struct scatterlist sg; 486 u8 *data_buf; 487 u8 *test_buf; 488 int i, err; 489 static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 }; 490 static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 }; 491 492 /* dma onto stack is unsafe/nonportable, but callers to this 493 * routine normally provide temporary on-stack buffers ... 494 */ 495 data_buf = kmalloc(len, GFP_KERNEL); 496 if (!data_buf) 497 return -ENOMEM; 498 499 if (len == 8) 500 test_buf = testdata_8bit; 501 else if (len == 4) 502 test_buf = testdata_4bit; 503 else { 504 pr_err("%s: Invalid bus_width %d\n", 505 mmc_hostname(host), len); 506 kfree(data_buf); 507 return -EINVAL; 508 } 509 510 if (opcode == MMC_BUS_TEST_W) 511 memcpy(data_buf, test_buf, len); 512 513 mrq.cmd = &cmd; 514 mrq.data = &data; 515 cmd.opcode = opcode; 516 cmd.arg = 0; 517 518 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we 519 * rely on callers to never use this with "native" calls for reading 520 * CSD or CID. Native versions of those commands use the R2 type, 521 * not R1 plus a data block. 522 */ 523 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 524 525 data.blksz = len; 526 data.blocks = 1; 527 if (opcode == MMC_BUS_TEST_R) 528 data.flags = MMC_DATA_READ; 529 else 530 data.flags = MMC_DATA_WRITE; 531 532 data.sg = &sg; 533 data.sg_len = 1; 534 mmc_set_data_timeout(&data, card); 535 sg_init_one(&sg, data_buf, len); 536 mmc_wait_for_req(host, &mrq); 537 err = 0; 538 if (opcode == MMC_BUS_TEST_R) { 539 for (i = 0; i < len / 4; i++) 540 if ((test_buf[i] ^ data_buf[i]) != 0xff) { 541 err = -EIO; 542 break; 543 } 544 } 545 kfree(data_buf); 546 547 if (cmd.error) 548 return cmd.error; 549 if (data.error) 550 return data.error; 551 552 return err; 553 } 554 555 int mmc_bus_test(struct mmc_card *card, u8 bus_width) 556 { 557 int err, width; 558 559 if (bus_width == MMC_BUS_WIDTH_8) 560 width = 8; 561 else if (bus_width == MMC_BUS_WIDTH_4) 562 width = 4; 563 else if (bus_width == MMC_BUS_WIDTH_1) 564 return 0; /* no need for test */ 565 else 566 return -EINVAL; 567 568 /* 569 * Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there 570 * is a problem. This improves chances that the test will work. 571 */ 572 mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width); 573 err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width); 574 return err; 575 } 576 577 int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status) 578 { 579 struct mmc_command cmd = {0}; 580 unsigned int opcode; 581 int err; 582 583 if (!card->ext_csd.hpi) { 584 pr_warning("%s: Card didn't support HPI command\n", 585 mmc_hostname(card->host)); 586 return -EINVAL; 587 } 588 589 opcode = card->ext_csd.hpi_cmd; 590 if (opcode == MMC_STOP_TRANSMISSION) 591 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 592 else if (opcode == MMC_SEND_STATUS) 593 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 594 595 cmd.opcode = opcode; 596 cmd.arg = card->rca << 16 | 1; 597 598 err = mmc_wait_for_cmd(card->host, &cmd, 0); 599 if (err) { 600 pr_warn("%s: error %d interrupting operation. " 601 "HPI command response %#x\n", mmc_hostname(card->host), 602 err, cmd.resp[0]); 603 return err; 604 } 605 if (status) 606 *status = cmd.resp[0]; 607 608 return 0; 609 } 610