1 /* 2 * linux/drivers/mmc/core/sd_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 #include <linux/mmc/sd.h> 20 21 #include "core.h" 22 #include "sd_ops.h" 23 24 int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card) 25 { 26 int err; 27 struct mmc_command cmd = {0}; 28 29 BUG_ON(!host); 30 BUG_ON(card && (card->host != host)); 31 32 cmd.opcode = MMC_APP_CMD; 33 34 if (card) { 35 cmd.arg = card->rca << 16; 36 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 37 } else { 38 cmd.arg = 0; 39 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR; 40 } 41 42 err = mmc_wait_for_cmd(host, &cmd, 0); 43 if (err) 44 return err; 45 46 /* Check that card supported application commands */ 47 if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD)) 48 return -EOPNOTSUPP; 49 50 return 0; 51 } 52 EXPORT_SYMBOL_GPL(mmc_app_cmd); 53 54 /** 55 * mmc_wait_for_app_cmd - start an application command and wait for 56 completion 57 * @host: MMC host to start command 58 * @card: Card to send MMC_APP_CMD to 59 * @cmd: MMC command to start 60 * @retries: maximum number of retries 61 * 62 * Sends a MMC_APP_CMD, checks the card response, sends the command 63 * in the parameter and waits for it to complete. Return any error 64 * that occurred while the command was executing. Do not attempt to 65 * parse the response. 66 */ 67 int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card, 68 struct mmc_command *cmd, int retries) 69 { 70 struct mmc_request mrq = {0}; 71 72 int i, err; 73 74 BUG_ON(!cmd); 75 BUG_ON(retries < 0); 76 77 err = -EIO; 78 79 /* 80 * We have to resend MMC_APP_CMD for each attempt so 81 * we cannot use the retries field in mmc_command. 82 */ 83 for (i = 0;i <= retries;i++) { 84 err = mmc_app_cmd(host, card); 85 if (err) { 86 /* no point in retrying; no APP commands allowed */ 87 if (mmc_host_is_spi(host)) { 88 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 89 break; 90 } 91 continue; 92 } 93 94 memset(&mrq, 0, sizeof(struct mmc_request)); 95 96 memset(cmd->resp, 0, sizeof(cmd->resp)); 97 cmd->retries = 0; 98 99 mrq.cmd = cmd; 100 cmd->data = NULL; 101 102 mmc_wait_for_req(host, &mrq); 103 104 err = cmd->error; 105 if (!cmd->error) 106 break; 107 108 /* no point in retrying illegal APP commands */ 109 if (mmc_host_is_spi(host)) { 110 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 111 break; 112 } 113 } 114 115 return err; 116 } 117 118 EXPORT_SYMBOL(mmc_wait_for_app_cmd); 119 120 int mmc_app_set_bus_width(struct mmc_card *card, int width) 121 { 122 int err; 123 struct mmc_command cmd = {0}; 124 125 BUG_ON(!card); 126 BUG_ON(!card->host); 127 128 cmd.opcode = SD_APP_SET_BUS_WIDTH; 129 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 130 131 switch (width) { 132 case MMC_BUS_WIDTH_1: 133 cmd.arg = SD_BUS_WIDTH_1; 134 break; 135 case MMC_BUS_WIDTH_4: 136 cmd.arg = SD_BUS_WIDTH_4; 137 break; 138 default: 139 return -EINVAL; 140 } 141 142 err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES); 143 if (err) 144 return err; 145 146 return 0; 147 } 148 149 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) 150 { 151 struct mmc_command cmd = {0}; 152 int i, err = 0; 153 154 BUG_ON(!host); 155 156 cmd.opcode = SD_APP_OP_COND; 157 if (mmc_host_is_spi(host)) 158 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */ 159 else 160 cmd.arg = ocr; 161 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR; 162 163 for (i = 100; i; i--) { 164 err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES); 165 if (err) 166 break; 167 168 /* if we're just probing, do a single pass */ 169 if (ocr == 0) 170 break; 171 172 /* otherwise wait until reset completes */ 173 if (mmc_host_is_spi(host)) { 174 if (!(cmd.resp[0] & R1_SPI_IDLE)) 175 break; 176 } else { 177 if (cmd.resp[0] & MMC_CARD_BUSY) 178 break; 179 } 180 181 err = -ETIMEDOUT; 182 183 mmc_delay(10); 184 } 185 186 if (rocr && !mmc_host_is_spi(host)) 187 *rocr = cmd.resp[0]; 188 189 return err; 190 } 191 192 int mmc_send_if_cond(struct mmc_host *host, u32 ocr) 193 { 194 struct mmc_command cmd = {0}; 195 int err; 196 static const u8 test_pattern = 0xAA; 197 u8 result_pattern; 198 199 /* 200 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND 201 * before SD_APP_OP_COND. This command will harmlessly fail for 202 * SD 1.0 cards. 203 */ 204 cmd.opcode = SD_SEND_IF_COND; 205 cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern; 206 cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR; 207 208 err = mmc_wait_for_cmd(host, &cmd, 0); 209 if (err) 210 return err; 211 212 if (mmc_host_is_spi(host)) 213 result_pattern = cmd.resp[1] & 0xFF; 214 else 215 result_pattern = cmd.resp[0] & 0xFF; 216 217 if (result_pattern != test_pattern) 218 return -EIO; 219 220 return 0; 221 } 222 223 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca) 224 { 225 int err; 226 struct mmc_command cmd = {0}; 227 228 BUG_ON(!host); 229 BUG_ON(!rca); 230 231 cmd.opcode = SD_SEND_RELATIVE_ADDR; 232 cmd.arg = 0; 233 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR; 234 235 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 236 if (err) 237 return err; 238 239 *rca = cmd.resp[0] >> 16; 240 241 return 0; 242 } 243 244 int mmc_app_send_scr(struct mmc_card *card, u32 *scr) 245 { 246 int err; 247 struct mmc_request mrq = {0}; 248 struct mmc_command cmd = {0}; 249 struct mmc_data data = {0}; 250 struct scatterlist sg; 251 void *data_buf; 252 253 BUG_ON(!card); 254 BUG_ON(!card->host); 255 BUG_ON(!scr); 256 257 /* NOTE: caller guarantees scr is heap-allocated */ 258 259 err = mmc_app_cmd(card->host, card); 260 if (err) 261 return err; 262 263 /* dma onto stack is unsafe/nonportable, but callers to this 264 * routine normally provide temporary on-stack buffers ... 265 */ 266 data_buf = kmalloc(sizeof(card->raw_scr), GFP_KERNEL); 267 if (data_buf == NULL) 268 return -ENOMEM; 269 270 mrq.cmd = &cmd; 271 mrq.data = &data; 272 273 cmd.opcode = SD_APP_SEND_SCR; 274 cmd.arg = 0; 275 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 276 277 data.blksz = 8; 278 data.blocks = 1; 279 data.flags = MMC_DATA_READ; 280 data.sg = &sg; 281 data.sg_len = 1; 282 283 sg_init_one(&sg, data_buf, 8); 284 285 mmc_set_data_timeout(&data, card); 286 287 mmc_wait_for_req(card->host, &mrq); 288 289 memcpy(scr, data_buf, sizeof(card->raw_scr)); 290 kfree(data_buf); 291 292 if (cmd.error) 293 return cmd.error; 294 if (data.error) 295 return data.error; 296 297 scr[0] = be32_to_cpu(scr[0]); 298 scr[1] = be32_to_cpu(scr[1]); 299 300 return 0; 301 } 302 303 int mmc_sd_switch(struct mmc_card *card, int mode, int group, 304 u8 value, u8 *resp) 305 { 306 struct mmc_request mrq = {0}; 307 struct mmc_command cmd = {0}; 308 struct mmc_data data = {0}; 309 struct scatterlist sg; 310 311 BUG_ON(!card); 312 BUG_ON(!card->host); 313 314 /* NOTE: caller guarantees resp is heap-allocated */ 315 316 mode = !!mode; 317 value &= 0xF; 318 319 mrq.cmd = &cmd; 320 mrq.data = &data; 321 322 cmd.opcode = SD_SWITCH; 323 cmd.arg = mode << 31 | 0x00FFFFFF; 324 cmd.arg &= ~(0xF << (group * 4)); 325 cmd.arg |= value << (group * 4); 326 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 327 328 data.blksz = 64; 329 data.blocks = 1; 330 data.flags = MMC_DATA_READ; 331 data.sg = &sg; 332 data.sg_len = 1; 333 334 sg_init_one(&sg, resp, 64); 335 336 mmc_set_data_timeout(&data, card); 337 338 mmc_wait_for_req(card->host, &mrq); 339 340 if (cmd.error) 341 return cmd.error; 342 if (data.error) 343 return data.error; 344 345 return 0; 346 } 347 348 int mmc_app_sd_status(struct mmc_card *card, void *ssr) 349 { 350 int err; 351 struct mmc_request mrq = {0}; 352 struct mmc_command cmd = {0}; 353 struct mmc_data data = {0}; 354 struct scatterlist sg; 355 356 BUG_ON(!card); 357 BUG_ON(!card->host); 358 BUG_ON(!ssr); 359 360 /* NOTE: caller guarantees ssr is heap-allocated */ 361 362 err = mmc_app_cmd(card->host, card); 363 if (err) 364 return err; 365 366 mrq.cmd = &cmd; 367 mrq.data = &data; 368 369 cmd.opcode = SD_APP_SD_STATUS; 370 cmd.arg = 0; 371 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC; 372 373 data.blksz = 64; 374 data.blocks = 1; 375 data.flags = MMC_DATA_READ; 376 data.sg = &sg; 377 data.sg_len = 1; 378 379 sg_init_one(&sg, ssr, 64); 380 381 mmc_set_data_timeout(&data, card); 382 383 mmc_wait_for_req(card->host, &mrq); 384 385 if (cmd.error) 386 return cmd.error; 387 if (data.error) 388 return data.error; 389 390 return 0; 391 } 392