drivers/mmc/core/mmc_ops.c

   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 "host.h"
  23 #include "mmc_ops.h"
  24
  25 #define MMC_OPS_TIMEOUT_MS      (10 * 60 * 1000) /* 10 minute timeout */
  26
  27 static const u8 tuning_blk_pattern_4bit[] = {
  28         0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc,
  29         0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
  30         0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
  31         0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
  32         0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
  33         0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
  34         0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
  35         0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
  36 };
  37
  38 static const u8 tuning_blk_pattern_8bit[] = {
  39         0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
  40         0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
  41         0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff,
  42         0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
  43         0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd,
  44         0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
  45         0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff,
  46         0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff,
  47         0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
  48         0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc,
  49         0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff,
  50         0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee,
  51         0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd,
  52         0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff,
  53         0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff,
  54         0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee,
  55 };
  56
  57 static inline int __mmc_send_status(struct mmc_card *card, u32 *status,
  58                                     bool ignore_crc)
  59 {
  60         int err;
  61         struct mmc_command cmd = {0};
  62
  63         BUG_ON(!card);
  64         BUG_ON(!card->host);
  65
  66         cmd.opcode = MMC_SEND_STATUS;
  67         if (!mmc_host_is_spi(card->host))
  68                 cmd.arg = card->rca << 16;
  69         cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
  70         if (ignore_crc)
  71                 cmd.flags &= ~MMC_RSP_CRC;
  72
  73         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
  74         if (err)
  75                 return err;
  76
  77         /* NOTE: callers are required to understand the difference
  78          * between "native" and SPI format status words!
  79          */
  80         if (status)
  81                 *status = cmd.resp[0];
  82
  83         return 0;
  84 }
  85
  86 int mmc_send_status(struct mmc_card *card, u32 *status)
  87 {
  88         return __mmc_send_status(card, status, false);
  89 }
  90
  91 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
  92 {
  93         int err;
  94         struct mmc_command cmd = {0};
  95
  96         BUG_ON(!host);
  97
  98         cmd.opcode = MMC_SELECT_CARD;
  99
 100         if (card) {
 101                 cmd.arg = card->rca << 16;
 102                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 103         } else {
 104                 cmd.arg = 0;
 105                 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
 106         }
 107
 108         err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
 109         if (err)
 110                 return err;
 111
 112         return 0;
 113 }
 114
 115 int mmc_select_card(struct mmc_card *card)
 116 {
 117         BUG_ON(!card);
 118
 119         return _mmc_select_card(card->host, card);
 120 }
 121
 122 int mmc_deselect_cards(struct mmc_host *host)
 123 {
 124         return _mmc_select_card(host, NULL);
 125 }
 126
 127 /*
 128  * Write the value specified in the device tree or board code into the optional
 129  * 16 bit Driver Stage Register. This can be used to tune raise/fall times and
 130  * drive strength of the DAT and CMD outputs. The actual meaning of a given
 131  * value is hardware dependant.
 132  * The presence of the DSR register can be determined from the CSD register,
 133  * bit 76.
 134  */
 135 int mmc_set_dsr(struct mmc_host *host)
 136 {
 137         struct mmc_command cmd = {0};
 138
 139         cmd.opcode = MMC_SET_DSR;
 140
 141         cmd.arg = (host->dsr << 16) | 0xffff;
 142         cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
 143
 144         return mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
 145 }
 146
 147 int mmc_go_idle(struct mmc_host *host)
 148 {
 149         int err;
 150         struct mmc_command cmd = {0};
 151
 152         /*
 153          * Non-SPI hosts need to prevent chipselect going active during
 154          * GO_IDLE; that would put chips into SPI mode.  Remind them of
 155          * that in case of hardware that won't pull up DAT3/nCS otherwise.
 156          *
 157          * SPI hosts ignore ios.chip_select; it's managed according to
 158          * rules that must accommodate non-MMC slaves which this layer
 159          * won't even know about.
 160          */
 161         if (!mmc_host_is_spi(host)) {
 162                 mmc_set_chip_select(host, MMC_CS_HIGH);
 163                 mmc_delay(1);
 164         }
 165
 166         cmd.opcode = MMC_GO_IDLE_STATE;
 167         cmd.arg = 0;
 168         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;
 169
 170         err = mmc_wait_for_cmd(host, &cmd, 0);
 171
 172         mmc_delay(1);
 173
 174         if (!mmc_host_is_spi(host)) {
 175                 mmc_set_chip_select(host, MMC_CS_DONTCARE);
 176                 mmc_delay(1);
 177         }
 178
 179         host->use_spi_crc = 0;
 180
 181         return err;
 182 }
 183
 184 int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 185 {
 186         struct mmc_command cmd = {0};
 187         int i, err = 0;
 188
 189         BUG_ON(!host);
 190
 191         cmd.opcode = MMC_SEND_OP_COND;
 192         cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
 193         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
 194
 195         for (i = 100; i; i--) {
 196                 err = mmc_wait_for_cmd(host, &cmd, 0);
 197                 if (err)
 198                         break;
 199
 200                 /* if we're just probing, do a single pass */
 201                 if (ocr == 0)
 202                         break;
 203
 204                 /* otherwise wait until reset completes */
 205                 if (mmc_host_is_spi(host)) {
 206                         if (!(cmd.resp[0] & R1_SPI_IDLE))
 207                                 break;
 208                 } else {
 209                         if (cmd.resp[0] & MMC_CARD_BUSY)
 210                                 break;
 211                 }
 212
 213                 err = -ETIMEDOUT;
 214
 215                 mmc_delay(10);
 216         }
 217
 218         if (rocr && !mmc_host_is_spi(host))
 219                 *rocr = cmd.resp[0];
 220
 221         return err;
 222 }
 223
 224 int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
 225 {
 226         int err;
 227         struct mmc_command cmd = {0};
 228
 229         BUG_ON(!host);
 230         BUG_ON(!cid);
 231
 232         cmd.opcode = MMC_ALL_SEND_CID;
 233         cmd.arg = 0;
 234         cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
 235
 236         err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
 237         if (err)
 238                 return err;
 239
 240         memcpy(cid, cmd.resp, sizeof(u32) * 4);
 241
 242         return 0;
 243 }
 244
 245 int mmc_set_relative_addr(struct mmc_card *card)
 246 {
 247         int err;
 248         struct mmc_command cmd = {0};
 249
 250         BUG_ON(!card);
 251         BUG_ON(!card->host);
 252
 253         cmd.opcode = MMC_SET_RELATIVE_ADDR;
 254         cmd.arg = card->rca << 16;
 255         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 256
 257         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
 258         if (err)
 259                 return err;
 260
 261         return 0;
 262 }
 263
 264 static int
 265 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
 266 {
 267         int err;
 268         struct mmc_command cmd = {0};
 269
 270         BUG_ON(!host);
 271         BUG_ON(!cxd);
 272
 273         cmd.opcode = opcode;
 274         cmd.arg = arg;
 275         cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
 276
 277         err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
 278         if (err)
 279                 return err;
 280
 281         memcpy(cxd, cmd.resp, sizeof(u32) * 4);
 282
 283         return 0;
 284 }
 285
 286 /*
 287  * NOTE: void *buf, caller for the buf is required to use DMA-capable
 288  * buffer or on-stack buffer (with some overhead in callee).
 289  */
 290 static int
 291 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
 292                 u32 opcode, void *buf, unsigned len)
 293 {
 294         struct mmc_request mrq = {NULL};
 295         struct mmc_command cmd = {0};
 296         struct mmc_data data = {0};
 297         struct scatterlist sg;
 298
 299         mrq.cmd = &cmd;
 300         mrq.data = &data;
 301
 302         cmd.opcode = opcode;
 303         cmd.arg = 0;
 304
 305         /* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
 306          * rely on callers to never use this with "native" calls for reading
 307          * CSD or CID.  Native versions of those commands use the R2 type,
 308          * not R1 plus a data block.
 309          */
 310         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
 311
 312         data.blksz = len;
 313         data.blocks = 1;
 314         data.flags = MMC_DATA_READ;
 315         data.sg = &sg;
 316         data.sg_len = 1;
 317
 318         sg_init_one(&sg, buf, len);
 319
 320         if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
 321                 /*
 322                  * The spec states that CSR and CID accesses have a timeout
 323                  * of 64 clock cycles.
 324                  */
 325                 data.timeout_ns = 0;
 326                 data.timeout_clks = 64;
 327         } else
 328                 mmc_set_data_timeout(&data, card);
 329
 330         mmc_wait_for_req(host, &mrq);
 331
 332         if (cmd.error)
 333                 return cmd.error;
 334         if (data.error)
 335                 return data.error;
 336
 337         return 0;
 338 }
 339
 340 int mmc_send_csd(struct mmc_card *card, u32 *csd)
 341 {
 342         int ret, i;
 343         u32 *csd_tmp;
 344
 345         if (!mmc_host_is_spi(card->host))
 346                 return mmc_send_cxd_native(card->host, card->rca << 16,
 347                                 csd, MMC_SEND_CSD);
 348
 349         csd_tmp = kzalloc(16, GFP_KERNEL);
 350         if (!csd_tmp)
 351                 return -ENOMEM;
 352
 353         ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16);
 354         if (ret)
 355                 goto err;
 356
 357         for (i = 0;i < 4;i++)
 358                 csd[i] = be32_to_cpu(csd_tmp[i]);
 359
 360 err:
 361         kfree(csd_tmp);
 362         return ret;
 363 }
 364
 365 int mmc_send_cid(struct mmc_host *host, u32 *cid)
 366 {
 367         int ret, i;
 368         u32 *cid_tmp;
 369
 370         if (!mmc_host_is_spi(host)) {
 371                 if (!host->card)
 372                         return -EINVAL;
 373                 return mmc_send_cxd_native(host, host->card->rca << 16,
 374                                 cid, MMC_SEND_CID);
 375         }
 376
 377         cid_tmp = kzalloc(16, GFP_KERNEL);
 378         if (!cid_tmp)
 379                 return -ENOMEM;
 380
 381         ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16);
 382         if (ret)
 383                 goto err;
 384
 385         for (i = 0;i < 4;i++)
 386                 cid[i] = be32_to_cpu(cid_tmp[i]);
 387
 388 err:
 389         kfree(cid_tmp);
 390         return ret;
 391 }
 392
 393 int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
 394 {
 395         int err;
 396         u8 *ext_csd;
 397
 398         if (!card || !new_ext_csd)
 399                 return -EINVAL;
 400
 401         if (!mmc_can_ext_csd(card))
 402                 return -EOPNOTSUPP;
 403
 404         /*
 405          * As the ext_csd is so large and mostly unused, we don't store the
 406          * raw block in mmc_card.
 407          */
 408         ext_csd = kzalloc(512, GFP_KERNEL);
 409         if (!ext_csd)
 410                 return -ENOMEM;
 411
 412         err = mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, ext_csd,
 413                                 512);
 414         if (err)
 415                 kfree(ext_csd);
 416         else
 417                 *new_ext_csd = ext_csd;
 418
 419         return err;
 420 }
 421 EXPORT_SYMBOL_GPL(mmc_get_ext_csd);
 422
 423 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
 424 {
 425         struct mmc_command cmd = {0};
 426         int err;
 427
 428         cmd.opcode = MMC_SPI_READ_OCR;
 429         cmd.arg = highcap ? (1 << 30) : 0;
 430         cmd.flags = MMC_RSP_SPI_R3;
 431
 432         err = mmc_wait_for_cmd(host, &cmd, 0);
 433
 434         *ocrp = cmd.resp[1];
 435         return err;
 436 }
 437
 438 int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
 439 {
 440         struct mmc_command cmd = {0};
 441         int err;
 442
 443         cmd.opcode = MMC_SPI_CRC_ON_OFF;
 444         cmd.flags = MMC_RSP_SPI_R1;
 445         cmd.arg = use_crc;
 446
 447         err = mmc_wait_for_cmd(host, &cmd, 0);
 448         if (!err)
 449                 host->use_spi_crc = use_crc;
 450         return err;
 451 }
 452
 453 int mmc_switch_status_error(struct mmc_host *host, u32 status)
 454 {
 455         if (mmc_host_is_spi(host)) {
 456                 if (status & R1_SPI_ILLEGAL_COMMAND)
 457                         return -EBADMSG;
 458         } else {
 459                 if (status & 0xFDFFA000)
 460                         pr_warn("%s: unexpected status %#x after switch\n",
 461                                 mmc_hostname(host), status);
 462                 if (status & R1_SWITCH_ERROR)
 463                         return -EBADMSG;
 464         }
 465         return 0;
 466 }
 467
 468 /**
 469  *      __mmc_switch - modify EXT_CSD register
 470  *      @card: the MMC card associated with the data transfer
 471  *      @set: cmd set values
 472  *      @index: EXT_CSD register index
 473  *      @value: value to program into EXT_CSD register
 474  *      @timeout_ms: timeout (ms) for operation performed by register write,
 475  *                   timeout of zero implies maximum possible timeout
 476  *      @use_busy_signal: use the busy signal as response type
 477  *      @send_status: send status cmd to poll for busy
 478  *      @ignore_crc: ignore CRC errors when sending status cmd to poll for busy
 479  *
 480  *      Modifies the EXT_CSD register for selected card.
 481  */
 482 int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
 483                 unsigned int timeout_ms, bool use_busy_signal, bool send_status,
 484                 bool ignore_crc)
 485 {
 486         struct mmc_host *host = card->host;
 487         int err;
 488         struct mmc_command cmd = {0};
 489         unsigned long timeout;
 490         u32 status = 0;
 491         bool use_r1b_resp = use_busy_signal;
 492
 493         mmc_retune_hold(host);
 494
 495         /*
 496          * If the cmd timeout and the max_busy_timeout of the host are both
 497          * specified, let's validate them. A failure means we need to prevent
 498          * the host from doing hw busy detection, which is done by converting
 499          * to a R1 response instead of a R1B.
 500          */
 501         if (timeout_ms && host->max_busy_timeout &&
 502                 (timeout_ms > host->max_busy_timeout))
 503                 use_r1b_resp = false;
 504
 505         cmd.opcode = MMC_SWITCH;
 506         cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 507                   (index << 16) |
 508                   (value << 8) |
 509                   set;
 510         cmd.flags = MMC_CMD_AC;
 511         if (use_r1b_resp) {
 512                 cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B;
 513                 /*
 514                  * A busy_timeout of zero means the host can decide to use
 515                  * whatever value it finds suitable.
 516                  */
 517                 cmd.busy_timeout = timeout_ms;
 518         } else {
 519                 cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1;
 520         }
 521
 522         if (index == EXT_CSD_SANITIZE_START)
 523                 cmd.sanitize_busy = true;
 524
 525         err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
 526         if (err)
 527                 goto out;
 528
 529         /* No need to check card status in case of unblocking command */
 530         if (!use_busy_signal)
 531                 goto out;
 532
 533         /*
 534          * CRC errors shall only be ignored in cases were CMD13 is used to poll
 535          * to detect busy completion.
 536          */
 537         if ((host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp)
 538                 ignore_crc = false;
 539
 540         /* We have an unspecified cmd timeout, use the fallback value. */
 541         if (!timeout_ms)
 542                 timeout_ms = MMC_OPS_TIMEOUT_MS;
 543
 544         /* Must check status to be sure of no errors. */
 545         timeout = jiffies + msecs_to_jiffies(timeout_ms);
 546         do {
 547                 if (send_status) {
 548                         err = __mmc_send_status(card, &status, ignore_crc);
 549                         if (err)
 550                                 goto out;
 551                 }
 552                 if ((host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp)
 553                         break;
 554                 if (mmc_host_is_spi(host))
 555                         break;
 556
 557                 /*
 558                  * We are not allowed to issue a status command and the host
 559                  * does'nt support MMC_CAP_WAIT_WHILE_BUSY, then we can only
 560                  * rely on waiting for the stated timeout to be sufficient.
 561                  */
 562                 if (!send_status) {
 563                         mmc_delay(timeout_ms);
 564                         goto out;
 565                 }
 566
 567                 /* Timeout if the device never leaves the program state. */
 568                 if (time_after(jiffies, timeout)) {
 569                         pr_err("%s: Card stuck in programming state! %s\n",
 570                                 mmc_hostname(host), __func__);
 571                         err = -ETIMEDOUT;
 572                         goto out;
 573                 }
 574         } while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
 575
 576         err = mmc_switch_status_error(host, status);
 577 out:
 578         mmc_retune_release(host);
 579
 580         return err;
 581 }
 582
 583 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
 584                 unsigned int timeout_ms)
 585 {
 586         return __mmc_switch(card, set, index, value, timeout_ms, true, true,
 587                                 false);
 588 }
 589 EXPORT_SYMBOL_GPL(mmc_switch);
 590
 591 int mmc_send_tuning(struct mmc_host *host, u32 opcode, int *cmd_error)
 592 {
 593         struct mmc_request mrq = {NULL};
 594         struct mmc_command cmd = {0};
 595         struct mmc_data data = {0};
 596         struct scatterlist sg;
 597         struct mmc_ios *ios = &host->ios;
 598         const u8 *tuning_block_pattern;
 599         int size, err = 0;
 600         u8 *data_buf;
 601
 602         if (ios->bus_width == MMC_BUS_WIDTH_8) {
 603                 tuning_block_pattern = tuning_blk_pattern_8bit;
 604                 size = sizeof(tuning_blk_pattern_8bit);
 605         } else if (ios->bus_width == MMC_BUS_WIDTH_4) {
 606                 tuning_block_pattern = tuning_blk_pattern_4bit;
 607                 size = sizeof(tuning_blk_pattern_4bit);
 608         } else
 609                 return -EINVAL;
 610
 611         data_buf = kzalloc(size, GFP_KERNEL);
 612         if (!data_buf)
 613                 return -ENOMEM;
 614
 615         mrq.cmd = &cmd;
 616         mrq.data = &data;
 617
 618         cmd.opcode = opcode;
 619         cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
 620
 621         data.blksz = size;
 622         data.blocks = 1;
 623         data.flags = MMC_DATA_READ;
 624
 625         /*
 626          * According to the tuning specs, Tuning process
 627          * is normally shorter 40 executions of CMD19,
 628          * and timeout value should be shorter than 150 ms
 629          */
 630         data.timeout_ns = 150 * NSEC_PER_MSEC;
 631
 632         data.sg = &sg;
 633         data.sg_len = 1;
 634         sg_init_one(&sg, data_buf, size);
 635
 636         mmc_wait_for_req(host, &mrq);
 637
 638         if (cmd_error)
 639                 *cmd_error = cmd.error;
 640
 641         if (cmd.error) {
 642                 err = cmd.error;
 643                 goto out;
 644         }
 645
 646         if (data.error) {
 647                 err = data.error;
 648                 goto out;
 649         }
 650
 651         if (memcmp(data_buf, tuning_block_pattern, size))
 652                 err = -EIO;
 653
 654 out:
 655         kfree(data_buf);
 656         return err;
 657 }
 658 EXPORT_SYMBOL_GPL(mmc_send_tuning);
 659
 660 static int
 661 mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
 662                   u8 len)
 663 {
 664         struct mmc_request mrq = {NULL};
 665         struct mmc_command cmd = {0};
 666         struct mmc_data data = {0};
 667         struct scatterlist sg;
 668         u8 *data_buf;
 669         u8 *test_buf;
 670         int i, err;
 671         static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
 672         static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };
 673
 674         /* dma onto stack is unsafe/nonportable, but callers to this
 675          * routine normally provide temporary on-stack buffers ...
 676          */
 677         data_buf = kmalloc(len, GFP_KERNEL);
 678         if (!data_buf)
 679                 return -ENOMEM;
 680
 681         if (len == 8)
 682                 test_buf = testdata_8bit;
 683         else if (len == 4)
 684                 test_buf = testdata_4bit;
 685         else {
 686                 pr_err("%s: Invalid bus_width %d\n",
 687                        mmc_hostname(host), len);
 688                 kfree(data_buf);
 689                 return -EINVAL;
 690         }
 691
 692         if (opcode == MMC_BUS_TEST_W)
 693                 memcpy(data_buf, test_buf, len);
 694
 695         mrq.cmd = &cmd;
 696         mrq.data = &data;
 697         cmd.opcode = opcode;
 698         cmd.arg = 0;
 699
 700         /* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
 701          * rely on callers to never use this with "native" calls for reading
 702          * CSD or CID.  Native versions of those commands use the R2 type,
 703          * not R1 plus a data block.
 704          */
 705         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
 706
 707         data.blksz = len;
 708         data.blocks = 1;
 709         if (opcode == MMC_BUS_TEST_R)
 710                 data.flags = MMC_DATA_READ;
 711         else
 712                 data.flags = MMC_DATA_WRITE;
 713
 714         data.sg = &sg;
 715         data.sg_len = 1;
 716         mmc_set_data_timeout(&data, card);
 717         sg_init_one(&sg, data_buf, len);
 718         mmc_wait_for_req(host, &mrq);
 719         err = 0;
 720         if (opcode == MMC_BUS_TEST_R) {
 721                 for (i = 0; i < len / 4; i++)
 722                         if ((test_buf[i] ^ data_buf[i]) != 0xff) {
 723                                 err = -EIO;
 724                                 break;
 725                         }
 726         }
 727         kfree(data_buf);
 728
 729         if (cmd.error)
 730                 return cmd.error;
 731         if (data.error)
 732                 return data.error;
 733
 734         return err;
 735 }
 736
 737 int mmc_bus_test(struct mmc_card *card, u8 bus_width)
 738 {
 739         int err, width;
 740
 741         if (bus_width == MMC_BUS_WIDTH_8)
 742                 width = 8;
 743         else if (bus_width == MMC_BUS_WIDTH_4)
 744                 width = 4;
 745         else if (bus_width == MMC_BUS_WIDTH_1)
 746                 return 0; /* no need for test */
 747         else
 748                 return -EINVAL;
 749
 750         /*
 751          * Ignore errors from BUS_TEST_W.  BUS_TEST_R will fail if there
 752          * is a problem.  This improves chances that the test will work.
 753          */
 754         mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
 755         err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
 756         return err;
 757 }
 758
 759 int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status)
 760 {
 761         struct mmc_command cmd = {0};
 762         unsigned int opcode;
 763         int err;
 764
 765         if (!card->ext_csd.hpi) {
 766                 pr_warn("%s: Card didn't support HPI command\n",
 767                         mmc_hostname(card->host));
 768                 return -EINVAL;
 769         }
 770
 771         opcode = card->ext_csd.hpi_cmd;
 772         if (opcode == MMC_STOP_TRANSMISSION)
 773                 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
 774         else if (opcode == MMC_SEND_STATUS)
 775                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 776
 777         cmd.opcode = opcode;
 778         cmd.arg = card->rca << 16 | 1;
 779
 780         err = mmc_wait_for_cmd(card->host, &cmd, 0);
 781         if (err) {
 782                 pr_warn("%s: error %d interrupting operation. "
 783                         "HPI command response %#x\n", mmc_hostname(card->host),
 784                         err, cmd.resp[0]);
 785                 return err;
 786         }
 787         if (status)
 788                 *status = cmd.resp[0];
 789
 790         return 0;
 791 }
 792
 793 int mmc_can_ext_csd(struct mmc_card *card)
 794 {
 795         return (card && card->csd.mmca_vsn > CSD_SPEC_VER_3);
 796 }