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 (card) 252 mmc_set_data_timeout(&data, card); 253 254 mmc_wait_for_req(host, &mrq); 255 256 memcpy(buf, data_buf, len); 257 kfree(data_buf); 258 259 if (cmd.error) 260 return cmd.error; 261 if (data.error) 262 return data.error; 263 264 return 0; 265 } 266 267 int mmc_send_csd(struct mmc_card *card, u32 *csd) 268 { 269 int ret, i; 270 271 if (!mmc_host_is_spi(card->host)) 272 return mmc_send_cxd_native(card->host, card->rca << 16, 273 csd, MMC_SEND_CSD); 274 275 ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16); 276 if (ret) 277 return ret; 278 279 for (i = 0;i < 4;i++) 280 csd[i] = be32_to_cpu(csd[i]); 281 282 return 0; 283 } 284 285 int mmc_send_cid(struct mmc_host *host, u32 *cid) 286 { 287 int ret, i; 288 289 if (!mmc_host_is_spi(host)) { 290 if (!host->card) 291 return -EINVAL; 292 return mmc_send_cxd_native(host, host->card->rca << 16, 293 cid, MMC_SEND_CID); 294 } 295 296 ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid, 16); 297 if (ret) 298 return ret; 299 300 for (i = 0;i < 4;i++) 301 cid[i] = be32_to_cpu(cid[i]); 302 303 return 0; 304 } 305 306 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd) 307 { 308 return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, 309 ext_csd, 512); 310 } 311 312 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp) 313 { 314 struct mmc_command cmd; 315 int err; 316 317 memset(&cmd, 0, sizeof(struct mmc_command)); 318 319 cmd.opcode = MMC_SPI_READ_OCR; 320 cmd.arg = highcap ? (1 << 30) : 0; 321 cmd.flags = MMC_RSP_SPI_R3; 322 323 err = mmc_wait_for_cmd(host, &cmd, 0); 324 325 *ocrp = cmd.resp[1]; 326 return err; 327 } 328 329 int mmc_spi_set_crc(struct mmc_host *host, int use_crc) 330 { 331 struct mmc_command cmd; 332 int err; 333 334 memset(&cmd, 0, sizeof(struct mmc_command)); 335 336 cmd.opcode = MMC_SPI_CRC_ON_OFF; 337 cmd.flags = MMC_RSP_SPI_R1; 338 cmd.arg = use_crc; 339 340 err = mmc_wait_for_cmd(host, &cmd, 0); 341 if (!err) 342 host->use_spi_crc = use_crc; 343 return err; 344 } 345 346 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value) 347 { 348 int err; 349 struct mmc_command cmd; 350 351 BUG_ON(!card); 352 BUG_ON(!card->host); 353 354 memset(&cmd, 0, sizeof(struct mmc_command)); 355 356 cmd.opcode = MMC_SWITCH; 357 cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 358 (index << 16) | 359 (value << 8) | 360 set; 361 cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 362 363 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 364 if (err) 365 return err; 366 367 return 0; 368 } 369 370 int mmc_send_status(struct mmc_card *card, u32 *status) 371 { 372 int err; 373 struct mmc_command cmd; 374 375 BUG_ON(!card); 376 BUG_ON(!card->host); 377 378 memset(&cmd, 0, sizeof(struct mmc_command)); 379 380 cmd.opcode = MMC_SEND_STATUS; 381 if (!mmc_host_is_spi(card->host)) 382 cmd.arg = card->rca << 16; 383 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; 384 385 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 386 if (err) 387 return err; 388 389 /* NOTE: callers are required to understand the difference 390 * between "native" and SPI format status words! 391 */ 392 if (status) 393 *status = cmd.resp[0]; 394 395 return 0; 396 } 397 398