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