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/types.h> 13 #include <linux/scatterlist.h> 14 15 #include <linux/mmc/host.h> 16 #include <linux/mmc/card.h> 17 #include <linux/mmc/mmc.h> 18 19 #include "core.h" 20 #include "mmc_ops.h" 21 22 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card) 23 { 24 int err; 25 struct mmc_command cmd; 26 27 BUG_ON(!host); 28 29 memset(&cmd, 0, sizeof(struct mmc_command)); 30 31 cmd.opcode = MMC_SELECT_CARD; 32 33 if (card) { 34 cmd.arg = card->rca << 16; 35 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 36 } else { 37 cmd.arg = 0; 38 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC; 39 } 40 41 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 42 if (err) 43 return err; 44 45 return 0; 46 } 47 48 int mmc_select_card(struct mmc_card *card) 49 { 50 BUG_ON(!card); 51 52 return _mmc_select_card(card->host, card); 53 } 54 55 int mmc_deselect_cards(struct mmc_host *host) 56 { 57 return _mmc_select_card(host, NULL); 58 } 59 60 int mmc_go_idle(struct mmc_host *host) 61 { 62 int err; 63 struct mmc_command cmd; 64 65 /* 66 * Non-SPI hosts need to prevent chipselect going active during 67 * GO_IDLE; that would put chips into SPI mode. Remind them of 68 * that in case of hardware that won't pull up DAT3/nCS otherwise. 69 * 70 * SPI hosts ignore ios.chip_select; it's managed according to 71 * rules that must accomodate non-MMC slaves which this layer 72 * won't even know about. 73 */ 74 if (!mmc_host_is_spi(host)) { 75 mmc_set_chip_select(host, MMC_CS_HIGH); 76 mmc_delay(1); 77 } 78 79 memset(&cmd, 0, sizeof(struct mmc_command)); 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; 102 int i, err = 0; 103 104 BUG_ON(!host); 105 106 memset(&cmd, 0, sizeof(struct mmc_command)); 107 108 cmd.opcode = MMC_SEND_OP_COND; 109 cmd.arg = mmc_host_is_spi(host) ? 0 : ocr; 110 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR; 111 112 for (i = 100; i; i--) { 113 err = mmc_wait_for_cmd(host, &cmd, 0); 114 if (err) 115 break; 116 117 /* if we're just probing, do a single pass */ 118 if (ocr == 0) 119 break; 120 121 /* otherwise wait until reset completes */ 122 if (mmc_host_is_spi(host)) { 123 if (!(cmd.resp[0] & R1_SPI_IDLE)) 124 break; 125 } else { 126 if (cmd.resp[0] & MMC_CARD_BUSY) 127 break; 128 } 129 130 err = -ETIMEDOUT; 131 132 mmc_delay(10); 133 } 134 135 if (rocr && !mmc_host_is_spi(host)) 136 *rocr = cmd.resp[0]; 137 138 return err; 139 } 140 141 int mmc_all_send_cid(struct mmc_host *host, u32 *cid) 142 { 143 int err; 144 struct mmc_command cmd; 145 146 BUG_ON(!host); 147 BUG_ON(!cid); 148 149 memset(&cmd, 0, sizeof(struct mmc_command)); 150 151 cmd.opcode = MMC_ALL_SEND_CID; 152 cmd.arg = 0; 153 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 154 155 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 156 if (err) 157 return err; 158 159 memcpy(cid, cmd.resp, sizeof(u32) * 4); 160 161 return 0; 162 } 163 164 int mmc_set_relative_addr(struct mmc_card *card) 165 { 166 int err; 167 struct mmc_command cmd; 168 169 BUG_ON(!card); 170 BUG_ON(!card->host); 171 172 memset(&cmd, 0, sizeof(struct mmc_command)); 173 174 cmd.opcode = MMC_SET_RELATIVE_ADDR; 175 cmd.arg = card->rca << 16; 176 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 177 178 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 179 if (err) 180 return err; 181 182 return 0; 183 } 184 185 static int 186 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode) 187 { 188 int err; 189 struct mmc_command cmd; 190 191 BUG_ON(!host); 192 BUG_ON(!cxd); 193 194 memset(&cmd, 0, sizeof(struct mmc_command)); 195 196 cmd.opcode = opcode; 197 cmd.arg = arg; 198 cmd.flags = MMC_RSP_R2 | MMC_CMD_AC; 199 200 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 201 if (err) 202 return err; 203 204 memcpy(cxd, cmd.resp, sizeof(u32) * 4); 205 206 return 0; 207 } 208 209 static int 210 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host, 211 u32 opcode, void *buf, unsigned len) 212 { 213 struct mmc_request mrq; 214 struct mmc_command cmd; 215 struct mmc_data data; 216 struct scatterlist sg; 217 void *data_buf; 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 == NULL) 224 return -ENOMEM; 225 226 memset(&mrq, 0, sizeof(struct mmc_request)); 227 memset(&cmd, 0, sizeof(struct mmc_command)); 228 memset(&data, 0, sizeof(struct mmc_data)); 229 230 mrq.cmd = &cmd; 231 mrq.data = &data; 232 233 cmd.opcode = opcode; 234 cmd.arg = 0; 235 236 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we 237 * rely on callers to never use this with "native" calls for reading 238 * CSD or CID. Native versions of those commands use the R2 type, 239 * not R1 plus a data block. 240 */ 241 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 242 243 data.blksz = len; 244 data.blocks = 1; 245 data.flags = MMC_DATA_READ; 246 data.sg = &sg; 247 data.sg_len = 1; 248 249 sg_init_one(&sg, data_buf, len); 250 251 if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) { 252 /* 253 * The spec states that CSR and CID accesses have a timeout 254 * of 64 clock cycles. 255 */ 256 data.timeout_ns = 0; 257 data.timeout_clks = 64; 258 } else 259 mmc_set_data_timeout(&data, card); 260 261 mmc_wait_for_req(host, &mrq); 262 263 memcpy(buf, data_buf, len); 264 kfree(data_buf); 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 278 if (!mmc_host_is_spi(card->host)) 279 return mmc_send_cxd_native(card->host, card->rca << 16, 280 csd, MMC_SEND_CSD); 281 282 ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16); 283 if (ret) 284 return ret; 285 286 for (i = 0;i < 4;i++) 287 csd[i] = be32_to_cpu(csd[i]); 288 289 return 0; 290 } 291 292 int mmc_send_cid(struct mmc_host *host, u32 *cid) 293 { 294 int ret, i; 295 296 if (!mmc_host_is_spi(host)) { 297 if (!host->card) 298 return -EINVAL; 299 return mmc_send_cxd_native(host, host->card->rca << 16, 300 cid, MMC_SEND_CID); 301 } 302 303 ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid, 16); 304 if (ret) 305 return ret; 306 307 for (i = 0;i < 4;i++) 308 cid[i] = be32_to_cpu(cid[i]); 309 310 return 0; 311 } 312 313 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd) 314 { 315 return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, 316 ext_csd, 512); 317 } 318 319 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp) 320 { 321 struct mmc_command cmd; 322 int err; 323 324 memset(&cmd, 0, sizeof(struct mmc_command)); 325 326 cmd.opcode = MMC_SPI_READ_OCR; 327 cmd.arg = highcap ? (1 << 30) : 0; 328 cmd.flags = MMC_RSP_SPI_R3; 329 330 err = mmc_wait_for_cmd(host, &cmd, 0); 331 332 *ocrp = cmd.resp[1]; 333 return err; 334 } 335 336 int mmc_spi_set_crc(struct mmc_host *host, int use_crc) 337 { 338 struct mmc_command cmd; 339 int err; 340 341 memset(&cmd, 0, sizeof(struct mmc_command)); 342 343 cmd.opcode = MMC_SPI_CRC_ON_OFF; 344 cmd.flags = MMC_RSP_SPI_R1; 345 cmd.arg = use_crc; 346 347 err = mmc_wait_for_cmd(host, &cmd, 0); 348 if (!err) 349 host->use_spi_crc = use_crc; 350 return err; 351 } 352 353 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value) 354 { 355 int err; 356 struct mmc_command cmd; 357 358 BUG_ON(!card); 359 BUG_ON(!card->host); 360 361 memset(&cmd, 0, sizeof(struct mmc_command)); 362 363 cmd.opcode = MMC_SWITCH; 364 cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 365 (index << 16) | 366 (value << 8) | 367 set; 368 cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 369 370 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 371 if (err) 372 return err; 373 374 return 0; 375 } 376 377 int mmc_send_status(struct mmc_card *card, u32 *status) 378 { 379 int err; 380 struct mmc_command cmd; 381 382 BUG_ON(!card); 383 BUG_ON(!card->host); 384 385 memset(&cmd, 0, sizeof(struct mmc_command)); 386 387 cmd.opcode = MMC_SEND_STATUS; 388 if (!mmc_host_is_spi(card->host)) 389 cmd.arg = card->rca << 16; 390 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; 391 392 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 393 if (err) 394 return err; 395 396 /* NOTE: callers are required to understand the difference 397 * between "native" and SPI format status words! 398 */ 399 if (status) 400 *status = cmd.resp[0]; 401 402 return 0; 403 } 404 405