1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (c) 2015, The Linux Foundation. All rights reserved. 3 */ 4 5 #include <linux/delay.h> 6 #include <linux/highmem.h> 7 #include <linux/io.h> 8 #include <linux/iopoll.h> 9 #include <linux/module.h> 10 #include <linux/dma-mapping.h> 11 #include <linux/slab.h> 12 #include <linux/scatterlist.h> 13 #include <linux/platform_device.h> 14 #include <linux/ktime.h> 15 16 #include <linux/mmc/mmc.h> 17 #include <linux/mmc/host.h> 18 #include <linux/mmc/card.h> 19 20 #include "cqhci.h" 21 #include "cqhci-crypto.h" 22 23 #define DCMD_SLOT 31 24 #define NUM_SLOTS 32 25 26 struct cqhci_slot { 27 struct mmc_request *mrq; 28 unsigned int flags; 29 #define CQHCI_EXTERNAL_TIMEOUT BIT(0) 30 #define CQHCI_COMPLETED BIT(1) 31 #define CQHCI_HOST_CRC BIT(2) 32 #define CQHCI_HOST_TIMEOUT BIT(3) 33 #define CQHCI_HOST_OTHER BIT(4) 34 }; 35 36 static inline u8 *get_desc(struct cqhci_host *cq_host, u8 tag) 37 { 38 return cq_host->desc_base + (tag * cq_host->slot_sz); 39 } 40 41 static inline u8 *get_link_desc(struct cqhci_host *cq_host, u8 tag) 42 { 43 u8 *desc = get_desc(cq_host, tag); 44 45 return desc + cq_host->task_desc_len; 46 } 47 48 static inline size_t get_trans_desc_offset(struct cqhci_host *cq_host, u8 tag) 49 { 50 return cq_host->trans_desc_len * cq_host->mmc->max_segs * tag; 51 } 52 53 static inline dma_addr_t get_trans_desc_dma(struct cqhci_host *cq_host, u8 tag) 54 { 55 size_t offset = get_trans_desc_offset(cq_host, tag); 56 57 return cq_host->trans_desc_dma_base + offset; 58 } 59 60 static inline u8 *get_trans_desc(struct cqhci_host *cq_host, u8 tag) 61 { 62 size_t offset = get_trans_desc_offset(cq_host, tag); 63 64 return cq_host->trans_desc_base + offset; 65 } 66 67 static void setup_trans_desc(struct cqhci_host *cq_host, u8 tag) 68 { 69 u8 *link_temp; 70 dma_addr_t trans_temp; 71 72 link_temp = get_link_desc(cq_host, tag); 73 trans_temp = get_trans_desc_dma(cq_host, tag); 74 75 memset(link_temp, 0, cq_host->link_desc_len); 76 if (cq_host->link_desc_len > 8) 77 *(link_temp + 8) = 0; 78 79 if (tag == DCMD_SLOT && (cq_host->mmc->caps2 & MMC_CAP2_CQE_DCMD)) { 80 *link_temp = CQHCI_VALID(0) | CQHCI_ACT(0) | CQHCI_END(1); 81 return; 82 } 83 84 *link_temp = CQHCI_VALID(1) | CQHCI_ACT(0x6) | CQHCI_END(0); 85 86 if (cq_host->dma64) { 87 __le64 *data_addr = (__le64 __force *)(link_temp + 4); 88 89 data_addr[0] = cpu_to_le64(trans_temp); 90 } else { 91 __le32 *data_addr = (__le32 __force *)(link_temp + 4); 92 93 data_addr[0] = cpu_to_le32(trans_temp); 94 } 95 } 96 97 static void cqhci_set_irqs(struct cqhci_host *cq_host, u32 set) 98 { 99 cqhci_writel(cq_host, set, CQHCI_ISTE); 100 cqhci_writel(cq_host, set, CQHCI_ISGE); 101 } 102 103 #define DRV_NAME "cqhci" 104 105 #define CQHCI_DUMP(f, x...) \ 106 pr_err("%s: " DRV_NAME ": " f, mmc_hostname(mmc), ## x) 107 108 static void cqhci_dumpregs(struct cqhci_host *cq_host) 109 { 110 struct mmc_host *mmc = cq_host->mmc; 111 112 CQHCI_DUMP("============ CQHCI REGISTER DUMP ===========\n"); 113 114 CQHCI_DUMP("Caps: 0x%08x | Version: 0x%08x\n", 115 cqhci_readl(cq_host, CQHCI_CAP), 116 cqhci_readl(cq_host, CQHCI_VER)); 117 CQHCI_DUMP("Config: 0x%08x | Control: 0x%08x\n", 118 cqhci_readl(cq_host, CQHCI_CFG), 119 cqhci_readl(cq_host, CQHCI_CTL)); 120 CQHCI_DUMP("Int stat: 0x%08x | Int enab: 0x%08x\n", 121 cqhci_readl(cq_host, CQHCI_IS), 122 cqhci_readl(cq_host, CQHCI_ISTE)); 123 CQHCI_DUMP("Int sig: 0x%08x | Int Coal: 0x%08x\n", 124 cqhci_readl(cq_host, CQHCI_ISGE), 125 cqhci_readl(cq_host, CQHCI_IC)); 126 CQHCI_DUMP("TDL base: 0x%08x | TDL up32: 0x%08x\n", 127 cqhci_readl(cq_host, CQHCI_TDLBA), 128 cqhci_readl(cq_host, CQHCI_TDLBAU)); 129 CQHCI_DUMP("Doorbell: 0x%08x | TCN: 0x%08x\n", 130 cqhci_readl(cq_host, CQHCI_TDBR), 131 cqhci_readl(cq_host, CQHCI_TCN)); 132 CQHCI_DUMP("Dev queue: 0x%08x | Dev Pend: 0x%08x\n", 133 cqhci_readl(cq_host, CQHCI_DQS), 134 cqhci_readl(cq_host, CQHCI_DPT)); 135 CQHCI_DUMP("Task clr: 0x%08x | SSC1: 0x%08x\n", 136 cqhci_readl(cq_host, CQHCI_TCLR), 137 cqhci_readl(cq_host, CQHCI_SSC1)); 138 CQHCI_DUMP("SSC2: 0x%08x | DCMD rsp: 0x%08x\n", 139 cqhci_readl(cq_host, CQHCI_SSC2), 140 cqhci_readl(cq_host, CQHCI_CRDCT)); 141 CQHCI_DUMP("RED mask: 0x%08x | TERRI: 0x%08x\n", 142 cqhci_readl(cq_host, CQHCI_RMEM), 143 cqhci_readl(cq_host, CQHCI_TERRI)); 144 CQHCI_DUMP("Resp idx: 0x%08x | Resp arg: 0x%08x\n", 145 cqhci_readl(cq_host, CQHCI_CRI), 146 cqhci_readl(cq_host, CQHCI_CRA)); 147 148 if (cq_host->ops->dumpregs) 149 cq_host->ops->dumpregs(mmc); 150 else 151 CQHCI_DUMP(": ===========================================\n"); 152 } 153 154 /* 155 * The allocated descriptor table for task, link & transfer descriptors 156 * looks like: 157 * |----------| 158 * |task desc | |->|----------| 159 * |----------| | |trans desc| 160 * |link desc-|->| |----------| 161 * |----------| . 162 * . . 163 * no. of slots max-segs 164 * . |----------| 165 * |----------| 166 * The idea here is to create the [task+trans] table and mark & point the 167 * link desc to the transfer desc table on a per slot basis. 168 */ 169 static int cqhci_host_alloc_tdl(struct cqhci_host *cq_host) 170 { 171 int i = 0; 172 173 /* task descriptor can be 64/128 bit irrespective of arch */ 174 if (cq_host->caps & CQHCI_TASK_DESC_SZ_128) { 175 cqhci_writel(cq_host, cqhci_readl(cq_host, CQHCI_CFG) | 176 CQHCI_TASK_DESC_SZ, CQHCI_CFG); 177 cq_host->task_desc_len = 16; 178 } else { 179 cq_host->task_desc_len = 8; 180 } 181 182 /* 183 * 96 bits length of transfer desc instead of 128 bits which means 184 * ADMA would expect next valid descriptor at the 96th bit 185 * or 128th bit 186 */ 187 if (cq_host->dma64) { 188 if (cq_host->quirks & CQHCI_QUIRK_SHORT_TXFR_DESC_SZ) 189 cq_host->trans_desc_len = 12; 190 else 191 cq_host->trans_desc_len = 16; 192 cq_host->link_desc_len = 16; 193 } else { 194 cq_host->trans_desc_len = 8; 195 cq_host->link_desc_len = 8; 196 } 197 198 /* total size of a slot: 1 task & 1 transfer (link) */ 199 cq_host->slot_sz = cq_host->task_desc_len + cq_host->link_desc_len; 200 201 cq_host->desc_size = cq_host->slot_sz * cq_host->num_slots; 202 203 cq_host->data_size = get_trans_desc_offset(cq_host, cq_host->mmc->cqe_qdepth); 204 205 pr_debug("%s: cqhci: desc_size: %zu data_sz: %zu slot-sz: %d\n", 206 mmc_hostname(cq_host->mmc), cq_host->desc_size, cq_host->data_size, 207 cq_host->slot_sz); 208 209 /* 210 * allocate a dma-mapped chunk of memory for the descriptors 211 * allocate a dma-mapped chunk of memory for link descriptors 212 * setup each link-desc memory offset per slot-number to 213 * the descriptor table. 214 */ 215 cq_host->desc_base = dmam_alloc_coherent(mmc_dev(cq_host->mmc), 216 cq_host->desc_size, 217 &cq_host->desc_dma_base, 218 GFP_KERNEL); 219 if (!cq_host->desc_base) 220 return -ENOMEM; 221 222 cq_host->trans_desc_base = dmam_alloc_coherent(mmc_dev(cq_host->mmc), 223 cq_host->data_size, 224 &cq_host->trans_desc_dma_base, 225 GFP_KERNEL); 226 if (!cq_host->trans_desc_base) { 227 dmam_free_coherent(mmc_dev(cq_host->mmc), cq_host->desc_size, 228 cq_host->desc_base, 229 cq_host->desc_dma_base); 230 cq_host->desc_base = NULL; 231 cq_host->desc_dma_base = 0; 232 return -ENOMEM; 233 } 234 235 pr_debug("%s: cqhci: desc-base: 0x%p trans-base: 0x%p\n desc_dma 0x%llx trans_dma: 0x%llx\n", 236 mmc_hostname(cq_host->mmc), cq_host->desc_base, cq_host->trans_desc_base, 237 (unsigned long long)cq_host->desc_dma_base, 238 (unsigned long long)cq_host->trans_desc_dma_base); 239 240 for (; i < (cq_host->num_slots); i++) 241 setup_trans_desc(cq_host, i); 242 243 return 0; 244 } 245 246 static void __cqhci_enable(struct cqhci_host *cq_host) 247 { 248 struct mmc_host *mmc = cq_host->mmc; 249 u32 cqcfg; 250 251 cqcfg = cqhci_readl(cq_host, CQHCI_CFG); 252 253 /* Configuration must not be changed while enabled */ 254 if (cqcfg & CQHCI_ENABLE) { 255 cqcfg &= ~CQHCI_ENABLE; 256 cqhci_writel(cq_host, cqcfg, CQHCI_CFG); 257 } 258 259 cqcfg &= ~(CQHCI_DCMD | CQHCI_TASK_DESC_SZ); 260 261 if (mmc->caps2 & MMC_CAP2_CQE_DCMD) 262 cqcfg |= CQHCI_DCMD; 263 264 if (cq_host->caps & CQHCI_TASK_DESC_SZ_128) 265 cqcfg |= CQHCI_TASK_DESC_SZ; 266 267 if (mmc->caps2 & MMC_CAP2_CRYPTO) 268 cqcfg |= CQHCI_CRYPTO_GENERAL_ENABLE; 269 270 cqhci_writel(cq_host, cqcfg, CQHCI_CFG); 271 272 cqhci_writel(cq_host, lower_32_bits(cq_host->desc_dma_base), 273 CQHCI_TDLBA); 274 cqhci_writel(cq_host, upper_32_bits(cq_host->desc_dma_base), 275 CQHCI_TDLBAU); 276 277 cqhci_writel(cq_host, cq_host->rca, CQHCI_SSC2); 278 279 cqhci_set_irqs(cq_host, 0); 280 281 cqcfg |= CQHCI_ENABLE; 282 283 cqhci_writel(cq_host, cqcfg, CQHCI_CFG); 284 285 if (cqhci_readl(cq_host, CQHCI_CTL) & CQHCI_HALT) 286 cqhci_writel(cq_host, 0, CQHCI_CTL); 287 288 mmc->cqe_on = true; 289 290 if (cq_host->ops->enable) 291 cq_host->ops->enable(mmc); 292 293 /* Ensure all writes are done before interrupts are enabled */ 294 wmb(); 295 296 cqhci_set_irqs(cq_host, CQHCI_IS_MASK); 297 298 cq_host->activated = true; 299 } 300 301 static void __cqhci_disable(struct cqhci_host *cq_host) 302 { 303 u32 cqcfg; 304 305 cqcfg = cqhci_readl(cq_host, CQHCI_CFG); 306 cqcfg &= ~CQHCI_ENABLE; 307 cqhci_writel(cq_host, cqcfg, CQHCI_CFG); 308 309 cq_host->mmc->cqe_on = false; 310 311 cq_host->activated = false; 312 } 313 314 int cqhci_deactivate(struct mmc_host *mmc) 315 { 316 struct cqhci_host *cq_host = mmc->cqe_private; 317 318 if (cq_host->enabled && cq_host->activated) 319 __cqhci_disable(cq_host); 320 321 return 0; 322 } 323 EXPORT_SYMBOL(cqhci_deactivate); 324 325 int cqhci_resume(struct mmc_host *mmc) 326 { 327 /* Re-enable is done upon first request */ 328 return 0; 329 } 330 EXPORT_SYMBOL(cqhci_resume); 331 332 static int cqhci_enable(struct mmc_host *mmc, struct mmc_card *card) 333 { 334 struct cqhci_host *cq_host = mmc->cqe_private; 335 int err; 336 337 if (!card->ext_csd.cmdq_en) 338 return -EINVAL; 339 340 if (cq_host->enabled) 341 return 0; 342 343 cq_host->rca = card->rca; 344 345 err = cqhci_host_alloc_tdl(cq_host); 346 if (err) { 347 pr_err("%s: Failed to enable CQE, error %d\n", 348 mmc_hostname(mmc), err); 349 return err; 350 } 351 352 __cqhci_enable(cq_host); 353 354 cq_host->enabled = true; 355 356 #ifdef DEBUG 357 cqhci_dumpregs(cq_host); 358 #endif 359 return 0; 360 } 361 362 /* CQHCI is idle and should halt immediately, so set a small timeout */ 363 #define CQHCI_OFF_TIMEOUT 100 364 365 static u32 cqhci_read_ctl(struct cqhci_host *cq_host) 366 { 367 return cqhci_readl(cq_host, CQHCI_CTL); 368 } 369 370 static void cqhci_off(struct mmc_host *mmc) 371 { 372 struct cqhci_host *cq_host = mmc->cqe_private; 373 u32 reg; 374 int err; 375 376 if (!cq_host->enabled || !mmc->cqe_on || cq_host->recovery_halt) 377 return; 378 379 if (cq_host->ops->disable) 380 cq_host->ops->disable(mmc, false); 381 382 cqhci_writel(cq_host, CQHCI_HALT, CQHCI_CTL); 383 384 err = readx_poll_timeout(cqhci_read_ctl, cq_host, reg, 385 reg & CQHCI_HALT, 0, CQHCI_OFF_TIMEOUT); 386 if (err < 0) 387 pr_err("%s: cqhci: CQE stuck on\n", mmc_hostname(mmc)); 388 else 389 pr_debug("%s: cqhci: CQE off\n", mmc_hostname(mmc)); 390 391 if (cq_host->ops->post_disable) 392 cq_host->ops->post_disable(mmc); 393 394 mmc->cqe_on = false; 395 } 396 397 static void cqhci_disable(struct mmc_host *mmc) 398 { 399 struct cqhci_host *cq_host = mmc->cqe_private; 400 401 if (!cq_host->enabled) 402 return; 403 404 cqhci_off(mmc); 405 406 __cqhci_disable(cq_host); 407 408 dmam_free_coherent(mmc_dev(mmc), cq_host->data_size, 409 cq_host->trans_desc_base, 410 cq_host->trans_desc_dma_base); 411 412 dmam_free_coherent(mmc_dev(mmc), cq_host->desc_size, 413 cq_host->desc_base, 414 cq_host->desc_dma_base); 415 416 cq_host->trans_desc_base = NULL; 417 cq_host->desc_base = NULL; 418 419 cq_host->enabled = false; 420 } 421 422 static void cqhci_prep_task_desc(struct mmc_request *mrq, 423 struct cqhci_host *cq_host, int tag) 424 { 425 __le64 *task_desc = (__le64 __force *)get_desc(cq_host, tag); 426 u32 req_flags = mrq->data->flags; 427 u64 desc0; 428 429 desc0 = CQHCI_VALID(1) | 430 CQHCI_END(1) | 431 CQHCI_INT(1) | 432 CQHCI_ACT(0x5) | 433 CQHCI_FORCED_PROG(!!(req_flags & MMC_DATA_FORCED_PRG)) | 434 CQHCI_DATA_TAG(!!(req_flags & MMC_DATA_DAT_TAG)) | 435 CQHCI_DATA_DIR(!!(req_flags & MMC_DATA_READ)) | 436 CQHCI_PRIORITY(!!(req_flags & MMC_DATA_PRIO)) | 437 CQHCI_QBAR(!!(req_flags & MMC_DATA_QBR)) | 438 CQHCI_REL_WRITE(!!(req_flags & MMC_DATA_REL_WR)) | 439 CQHCI_BLK_COUNT(mrq->data->blocks) | 440 CQHCI_BLK_ADDR((u64)mrq->data->blk_addr); 441 442 task_desc[0] = cpu_to_le64(desc0); 443 444 if (cq_host->caps & CQHCI_TASK_DESC_SZ_128) { 445 u64 desc1 = cqhci_crypto_prep_task_desc(mrq); 446 447 task_desc[1] = cpu_to_le64(desc1); 448 449 pr_debug("%s: cqhci: tag %d task descriptor 0x%016llx%016llx\n", 450 mmc_hostname(mrq->host), mrq->tag, desc1, desc0); 451 } else { 452 pr_debug("%s: cqhci: tag %d task descriptor 0x%016llx\n", 453 mmc_hostname(mrq->host), mrq->tag, desc0); 454 } 455 } 456 457 static int cqhci_dma_map(struct mmc_host *host, struct mmc_request *mrq) 458 { 459 int sg_count; 460 struct mmc_data *data = mrq->data; 461 462 if (!data) 463 return -EINVAL; 464 465 sg_count = dma_map_sg(mmc_dev(host), data->sg, 466 data->sg_len, 467 (data->flags & MMC_DATA_WRITE) ? 468 DMA_TO_DEVICE : DMA_FROM_DEVICE); 469 if (!sg_count) { 470 pr_err("%s: sg-len: %d\n", __func__, data->sg_len); 471 return -ENOMEM; 472 } 473 474 return sg_count; 475 } 476 477 static void cqhci_set_tran_desc(u8 *desc, dma_addr_t addr, int len, bool end, 478 bool dma64) 479 { 480 __le32 *attr = (__le32 __force *)desc; 481 482 *attr = (CQHCI_VALID(1) | 483 CQHCI_END(end ? 1 : 0) | 484 CQHCI_INT(0) | 485 CQHCI_ACT(0x4) | 486 CQHCI_DAT_LENGTH(len)); 487 488 if (dma64) { 489 __le64 *dataddr = (__le64 __force *)(desc + 4); 490 491 dataddr[0] = cpu_to_le64(addr); 492 } else { 493 __le32 *dataddr = (__le32 __force *)(desc + 4); 494 495 dataddr[0] = cpu_to_le32(addr); 496 } 497 } 498 499 static int cqhci_prep_tran_desc(struct mmc_request *mrq, 500 struct cqhci_host *cq_host, int tag) 501 { 502 struct mmc_data *data = mrq->data; 503 int i, sg_count, len; 504 bool end = false; 505 bool dma64 = cq_host->dma64; 506 dma_addr_t addr; 507 u8 *desc; 508 struct scatterlist *sg; 509 510 sg_count = cqhci_dma_map(mrq->host, mrq); 511 if (sg_count < 0) { 512 pr_err("%s: %s: unable to map sg lists, %d\n", 513 mmc_hostname(mrq->host), __func__, sg_count); 514 return sg_count; 515 } 516 517 desc = get_trans_desc(cq_host, tag); 518 519 for_each_sg(data->sg, sg, sg_count, i) { 520 addr = sg_dma_address(sg); 521 len = sg_dma_len(sg); 522 523 if ((i+1) == sg_count) 524 end = true; 525 cqhci_set_tran_desc(desc, addr, len, end, dma64); 526 desc += cq_host->trans_desc_len; 527 } 528 529 return 0; 530 } 531 532 static void cqhci_prep_dcmd_desc(struct mmc_host *mmc, 533 struct mmc_request *mrq) 534 { 535 u64 *task_desc = NULL; 536 u64 data = 0; 537 u8 resp_type; 538 u8 *desc; 539 __le64 *dataddr; 540 struct cqhci_host *cq_host = mmc->cqe_private; 541 u8 timing; 542 543 if (!(mrq->cmd->flags & MMC_RSP_PRESENT)) { 544 resp_type = 0x0; 545 timing = 0x1; 546 } else { 547 if (mrq->cmd->flags & MMC_RSP_R1B) { 548 resp_type = 0x3; 549 timing = 0x0; 550 } else { 551 resp_type = 0x2; 552 timing = 0x1; 553 } 554 } 555 556 task_desc = (__le64 __force *)get_desc(cq_host, cq_host->dcmd_slot); 557 memset(task_desc, 0, cq_host->task_desc_len); 558 data |= (CQHCI_VALID(1) | 559 CQHCI_END(1) | 560 CQHCI_INT(1) | 561 CQHCI_QBAR(1) | 562 CQHCI_ACT(0x5) | 563 CQHCI_CMD_INDEX(mrq->cmd->opcode) | 564 CQHCI_CMD_TIMING(timing) | CQHCI_RESP_TYPE(resp_type)); 565 if (cq_host->ops->update_dcmd_desc) 566 cq_host->ops->update_dcmd_desc(mmc, mrq, &data); 567 *task_desc |= data; 568 desc = (u8 *)task_desc; 569 pr_debug("%s: cqhci: dcmd: cmd: %d timing: %d resp: %d\n", 570 mmc_hostname(mmc), mrq->cmd->opcode, timing, resp_type); 571 dataddr = (__le64 __force *)(desc + 4); 572 dataddr[0] = cpu_to_le64((u64)mrq->cmd->arg); 573 574 } 575 576 static void cqhci_post_req(struct mmc_host *host, struct mmc_request *mrq) 577 { 578 struct mmc_data *data = mrq->data; 579 580 if (data) { 581 dma_unmap_sg(mmc_dev(host), data->sg, data->sg_len, 582 (data->flags & MMC_DATA_READ) ? 583 DMA_FROM_DEVICE : DMA_TO_DEVICE); 584 } 585 } 586 587 static inline int cqhci_tag(struct mmc_request *mrq) 588 { 589 return mrq->cmd ? DCMD_SLOT : mrq->tag; 590 } 591 592 static int cqhci_request(struct mmc_host *mmc, struct mmc_request *mrq) 593 { 594 int err = 0; 595 int tag = cqhci_tag(mrq); 596 struct cqhci_host *cq_host = mmc->cqe_private; 597 unsigned long flags; 598 599 if (!cq_host->enabled) { 600 pr_err("%s: cqhci: not enabled\n", mmc_hostname(mmc)); 601 return -EINVAL; 602 } 603 604 /* First request after resume has to re-enable */ 605 if (!cq_host->activated) 606 __cqhci_enable(cq_host); 607 608 if (!mmc->cqe_on) { 609 if (cq_host->ops->pre_enable) 610 cq_host->ops->pre_enable(mmc); 611 612 cqhci_writel(cq_host, 0, CQHCI_CTL); 613 mmc->cqe_on = true; 614 pr_debug("%s: cqhci: CQE on\n", mmc_hostname(mmc)); 615 if (cqhci_readl(cq_host, CQHCI_CTL) && CQHCI_HALT) { 616 pr_err("%s: cqhci: CQE failed to exit halt state\n", 617 mmc_hostname(mmc)); 618 } 619 if (cq_host->ops->enable) 620 cq_host->ops->enable(mmc); 621 } 622 623 if (mrq->data) { 624 cqhci_prep_task_desc(mrq, cq_host, tag); 625 626 err = cqhci_prep_tran_desc(mrq, cq_host, tag); 627 if (err) { 628 pr_err("%s: cqhci: failed to setup tx desc: %d\n", 629 mmc_hostname(mmc), err); 630 return err; 631 } 632 } else { 633 cqhci_prep_dcmd_desc(mmc, mrq); 634 } 635 636 spin_lock_irqsave(&cq_host->lock, flags); 637 638 if (cq_host->recovery_halt) { 639 err = -EBUSY; 640 goto out_unlock; 641 } 642 643 cq_host->slot[tag].mrq = mrq; 644 cq_host->slot[tag].flags = 0; 645 646 cq_host->qcnt += 1; 647 /* Make sure descriptors are ready before ringing the doorbell */ 648 wmb(); 649 cqhci_writel(cq_host, 1 << tag, CQHCI_TDBR); 650 if (!(cqhci_readl(cq_host, CQHCI_TDBR) & (1 << tag))) 651 pr_debug("%s: cqhci: doorbell not set for tag %d\n", 652 mmc_hostname(mmc), tag); 653 out_unlock: 654 spin_unlock_irqrestore(&cq_host->lock, flags); 655 656 if (err) 657 cqhci_post_req(mmc, mrq); 658 659 return err; 660 } 661 662 static void cqhci_recovery_needed(struct mmc_host *mmc, struct mmc_request *mrq, 663 bool notify) 664 { 665 struct cqhci_host *cq_host = mmc->cqe_private; 666 667 if (!cq_host->recovery_halt) { 668 cq_host->recovery_halt = true; 669 pr_debug("%s: cqhci: recovery needed\n", mmc_hostname(mmc)); 670 wake_up(&cq_host->wait_queue); 671 if (notify && mrq->recovery_notifier) 672 mrq->recovery_notifier(mrq); 673 } 674 } 675 676 static unsigned int cqhci_error_flags(int error1, int error2) 677 { 678 int error = error1 ? error1 : error2; 679 680 switch (error) { 681 case -EILSEQ: 682 return CQHCI_HOST_CRC; 683 case -ETIMEDOUT: 684 return CQHCI_HOST_TIMEOUT; 685 default: 686 return CQHCI_HOST_OTHER; 687 } 688 } 689 690 static void cqhci_error_irq(struct mmc_host *mmc, u32 status, int cmd_error, 691 int data_error) 692 { 693 struct cqhci_host *cq_host = mmc->cqe_private; 694 struct cqhci_slot *slot; 695 u32 terri; 696 u32 tdpe; 697 int tag; 698 699 spin_lock(&cq_host->lock); 700 701 terri = cqhci_readl(cq_host, CQHCI_TERRI); 702 703 pr_debug("%s: cqhci: error IRQ status: 0x%08x cmd error %d data error %d TERRI: 0x%08x\n", 704 mmc_hostname(mmc), status, cmd_error, data_error, terri); 705 706 /* Forget about errors when recovery has already been triggered */ 707 if (cq_host->recovery_halt) 708 goto out_unlock; 709 710 if (!cq_host->qcnt) { 711 WARN_ONCE(1, "%s: cqhci: error when idle. IRQ status: 0x%08x cmd error %d data error %d TERRI: 0x%08x\n", 712 mmc_hostname(mmc), status, cmd_error, data_error, 713 terri); 714 goto out_unlock; 715 } 716 717 if (CQHCI_TERRI_C_VALID(terri)) { 718 tag = CQHCI_TERRI_C_TASK(terri); 719 slot = &cq_host->slot[tag]; 720 if (slot->mrq) { 721 slot->flags = cqhci_error_flags(cmd_error, data_error); 722 cqhci_recovery_needed(mmc, slot->mrq, true); 723 } 724 } 725 726 if (CQHCI_TERRI_D_VALID(terri)) { 727 tag = CQHCI_TERRI_D_TASK(terri); 728 slot = &cq_host->slot[tag]; 729 if (slot->mrq) { 730 slot->flags = cqhci_error_flags(data_error, cmd_error); 731 cqhci_recovery_needed(mmc, slot->mrq, true); 732 } 733 } 734 735 /* 736 * Handle ICCE ("Invalid Crypto Configuration Error"). This should 737 * never happen, since the block layer ensures that all crypto-enabled 738 * I/O requests have a valid keyslot before they reach the driver. 739 * 740 * Note that GCE ("General Crypto Error") is different; it already got 741 * handled above by checking TERRI. 742 */ 743 if (status & CQHCI_IS_ICCE) { 744 tdpe = cqhci_readl(cq_host, CQHCI_TDPE); 745 WARN_ONCE(1, 746 "%s: cqhci: invalid crypto configuration error. IRQ status: 0x%08x TDPE: 0x%08x\n", 747 mmc_hostname(mmc), status, tdpe); 748 while (tdpe != 0) { 749 tag = __ffs(tdpe); 750 tdpe &= ~(1 << tag); 751 slot = &cq_host->slot[tag]; 752 if (!slot->mrq) 753 continue; 754 slot->flags = cqhci_error_flags(data_error, cmd_error); 755 cqhci_recovery_needed(mmc, slot->mrq, true); 756 } 757 } 758 759 if (!cq_host->recovery_halt) { 760 /* 761 * The only way to guarantee forward progress is to mark at 762 * least one task in error, so if none is indicated, pick one. 763 */ 764 for (tag = 0; tag < NUM_SLOTS; tag++) { 765 slot = &cq_host->slot[tag]; 766 if (!slot->mrq) 767 continue; 768 slot->flags = cqhci_error_flags(data_error, cmd_error); 769 cqhci_recovery_needed(mmc, slot->mrq, true); 770 break; 771 } 772 } 773 774 out_unlock: 775 spin_unlock(&cq_host->lock); 776 } 777 778 static void cqhci_finish_mrq(struct mmc_host *mmc, unsigned int tag) 779 { 780 struct cqhci_host *cq_host = mmc->cqe_private; 781 struct cqhci_slot *slot = &cq_host->slot[tag]; 782 struct mmc_request *mrq = slot->mrq; 783 struct mmc_data *data; 784 785 if (!mrq) { 786 WARN_ONCE(1, "%s: cqhci: spurious TCN for tag %d\n", 787 mmc_hostname(mmc), tag); 788 return; 789 } 790 791 /* No completions allowed during recovery */ 792 if (cq_host->recovery_halt) { 793 slot->flags |= CQHCI_COMPLETED; 794 return; 795 } 796 797 slot->mrq = NULL; 798 799 cq_host->qcnt -= 1; 800 801 data = mrq->data; 802 if (data) { 803 if (data->error) 804 data->bytes_xfered = 0; 805 else 806 data->bytes_xfered = data->blksz * data->blocks; 807 } 808 809 mmc_cqe_request_done(mmc, mrq); 810 } 811 812 irqreturn_t cqhci_irq(struct mmc_host *mmc, u32 intmask, int cmd_error, 813 int data_error) 814 { 815 u32 status; 816 unsigned long tag = 0, comp_status; 817 struct cqhci_host *cq_host = mmc->cqe_private; 818 819 status = cqhci_readl(cq_host, CQHCI_IS); 820 cqhci_writel(cq_host, status, CQHCI_IS); 821 822 pr_debug("%s: cqhci: IRQ status: 0x%08x\n", mmc_hostname(mmc), status); 823 824 if ((status & (CQHCI_IS_RED | CQHCI_IS_GCE | CQHCI_IS_ICCE)) || 825 cmd_error || data_error) { 826 if (status & CQHCI_IS_RED) 827 mmc_debugfs_err_stats_inc(mmc, MMC_ERR_CMDQ_RED); 828 if (status & CQHCI_IS_GCE) 829 mmc_debugfs_err_stats_inc(mmc, MMC_ERR_CMDQ_GCE); 830 if (status & CQHCI_IS_ICCE) 831 mmc_debugfs_err_stats_inc(mmc, MMC_ERR_CMDQ_ICCE); 832 cqhci_error_irq(mmc, status, cmd_error, data_error); 833 } 834 835 if (status & CQHCI_IS_TCC) { 836 /* read TCN and complete the request */ 837 comp_status = cqhci_readl(cq_host, CQHCI_TCN); 838 cqhci_writel(cq_host, comp_status, CQHCI_TCN); 839 pr_debug("%s: cqhci: TCN: 0x%08lx\n", 840 mmc_hostname(mmc), comp_status); 841 842 spin_lock(&cq_host->lock); 843 844 for_each_set_bit(tag, &comp_status, cq_host->num_slots) { 845 /* complete the corresponding mrq */ 846 pr_debug("%s: cqhci: completing tag %lu\n", 847 mmc_hostname(mmc), tag); 848 cqhci_finish_mrq(mmc, tag); 849 } 850 851 if (cq_host->waiting_for_idle && !cq_host->qcnt) { 852 cq_host->waiting_for_idle = false; 853 wake_up(&cq_host->wait_queue); 854 } 855 856 spin_unlock(&cq_host->lock); 857 } 858 859 if (status & CQHCI_IS_TCL) 860 wake_up(&cq_host->wait_queue); 861 862 if (status & CQHCI_IS_HAC) 863 wake_up(&cq_host->wait_queue); 864 865 return IRQ_HANDLED; 866 } 867 EXPORT_SYMBOL(cqhci_irq); 868 869 static bool cqhci_is_idle(struct cqhci_host *cq_host, int *ret) 870 { 871 unsigned long flags; 872 bool is_idle; 873 874 spin_lock_irqsave(&cq_host->lock, flags); 875 is_idle = !cq_host->qcnt || cq_host->recovery_halt; 876 *ret = cq_host->recovery_halt ? -EBUSY : 0; 877 cq_host->waiting_for_idle = !is_idle; 878 spin_unlock_irqrestore(&cq_host->lock, flags); 879 880 return is_idle; 881 } 882 883 static int cqhci_wait_for_idle(struct mmc_host *mmc) 884 { 885 struct cqhci_host *cq_host = mmc->cqe_private; 886 int ret; 887 888 wait_event(cq_host->wait_queue, cqhci_is_idle(cq_host, &ret)); 889 890 return ret; 891 } 892 893 static bool cqhci_timeout(struct mmc_host *mmc, struct mmc_request *mrq, 894 bool *recovery_needed) 895 { 896 struct cqhci_host *cq_host = mmc->cqe_private; 897 int tag = cqhci_tag(mrq); 898 struct cqhci_slot *slot = &cq_host->slot[tag]; 899 unsigned long flags; 900 bool timed_out; 901 902 spin_lock_irqsave(&cq_host->lock, flags); 903 timed_out = slot->mrq == mrq; 904 if (timed_out) { 905 slot->flags |= CQHCI_EXTERNAL_TIMEOUT; 906 cqhci_recovery_needed(mmc, mrq, false); 907 *recovery_needed = cq_host->recovery_halt; 908 } 909 spin_unlock_irqrestore(&cq_host->lock, flags); 910 911 if (timed_out) { 912 pr_err("%s: cqhci: timeout for tag %d, qcnt %d\n", 913 mmc_hostname(mmc), tag, cq_host->qcnt); 914 cqhci_dumpregs(cq_host); 915 } 916 917 return timed_out; 918 } 919 920 static bool cqhci_tasks_cleared(struct cqhci_host *cq_host) 921 { 922 return !(cqhci_readl(cq_host, CQHCI_CTL) & CQHCI_CLEAR_ALL_TASKS); 923 } 924 925 static bool cqhci_clear_all_tasks(struct mmc_host *mmc, unsigned int timeout) 926 { 927 struct cqhci_host *cq_host = mmc->cqe_private; 928 bool ret; 929 u32 ctl; 930 931 cqhci_set_irqs(cq_host, CQHCI_IS_TCL); 932 933 ctl = cqhci_readl(cq_host, CQHCI_CTL); 934 ctl |= CQHCI_CLEAR_ALL_TASKS; 935 cqhci_writel(cq_host, ctl, CQHCI_CTL); 936 937 wait_event_timeout(cq_host->wait_queue, cqhci_tasks_cleared(cq_host), 938 msecs_to_jiffies(timeout) + 1); 939 940 cqhci_set_irqs(cq_host, 0); 941 942 ret = cqhci_tasks_cleared(cq_host); 943 944 if (!ret) 945 pr_warn("%s: cqhci: Failed to clear tasks\n", 946 mmc_hostname(mmc)); 947 948 return ret; 949 } 950 951 static bool cqhci_halted(struct cqhci_host *cq_host) 952 { 953 return cqhci_readl(cq_host, CQHCI_CTL) & CQHCI_HALT; 954 } 955 956 static bool cqhci_halt(struct mmc_host *mmc, unsigned int timeout) 957 { 958 struct cqhci_host *cq_host = mmc->cqe_private; 959 bool ret; 960 u32 ctl; 961 962 if (cqhci_halted(cq_host)) 963 return true; 964 965 cqhci_set_irqs(cq_host, CQHCI_IS_HAC); 966 967 ctl = cqhci_readl(cq_host, CQHCI_CTL); 968 ctl |= CQHCI_HALT; 969 cqhci_writel(cq_host, ctl, CQHCI_CTL); 970 971 wait_event_timeout(cq_host->wait_queue, cqhci_halted(cq_host), 972 msecs_to_jiffies(timeout) + 1); 973 974 cqhci_set_irqs(cq_host, 0); 975 976 ret = cqhci_halted(cq_host); 977 978 if (!ret) 979 pr_warn("%s: cqhci: Failed to halt\n", mmc_hostname(mmc)); 980 981 return ret; 982 } 983 984 /* 985 * After halting we expect to be able to use the command line. We interpret the 986 * failure to halt to mean the data lines might still be in use (and the upper 987 * layers will need to send a STOP command), however failing to halt complicates 988 * the recovery, so set a timeout that would reasonably allow I/O to complete. 989 */ 990 #define CQHCI_START_HALT_TIMEOUT 500 991 992 static void cqhci_recovery_start(struct mmc_host *mmc) 993 { 994 struct cqhci_host *cq_host = mmc->cqe_private; 995 996 pr_debug("%s: cqhci: %s\n", mmc_hostname(mmc), __func__); 997 998 WARN_ON(!cq_host->recovery_halt); 999 1000 cqhci_halt(mmc, CQHCI_START_HALT_TIMEOUT); 1001 1002 if (cq_host->ops->disable) 1003 cq_host->ops->disable(mmc, true); 1004 1005 mmc->cqe_on = false; 1006 } 1007 1008 static int cqhci_error_from_flags(unsigned int flags) 1009 { 1010 if (!flags) 1011 return 0; 1012 1013 /* CRC errors might indicate re-tuning so prefer to report that */ 1014 if (flags & CQHCI_HOST_CRC) 1015 return -EILSEQ; 1016 1017 if (flags & (CQHCI_EXTERNAL_TIMEOUT | CQHCI_HOST_TIMEOUT)) 1018 return -ETIMEDOUT; 1019 1020 return -EIO; 1021 } 1022 1023 static void cqhci_recover_mrq(struct cqhci_host *cq_host, unsigned int tag) 1024 { 1025 struct cqhci_slot *slot = &cq_host->slot[tag]; 1026 struct mmc_request *mrq = slot->mrq; 1027 struct mmc_data *data; 1028 1029 if (!mrq) 1030 return; 1031 1032 slot->mrq = NULL; 1033 1034 cq_host->qcnt -= 1; 1035 1036 data = mrq->data; 1037 if (data) { 1038 data->bytes_xfered = 0; 1039 data->error = cqhci_error_from_flags(slot->flags); 1040 } else { 1041 mrq->cmd->error = cqhci_error_from_flags(slot->flags); 1042 } 1043 1044 mmc_cqe_request_done(cq_host->mmc, mrq); 1045 } 1046 1047 static void cqhci_recover_mrqs(struct cqhci_host *cq_host) 1048 { 1049 int i; 1050 1051 for (i = 0; i < cq_host->num_slots; i++) 1052 cqhci_recover_mrq(cq_host, i); 1053 } 1054 1055 /* 1056 * By now the command and data lines should be unused so there is no reason for 1057 * CQHCI to take a long time to halt, but if it doesn't halt there could be 1058 * problems clearing tasks, so be generous. 1059 */ 1060 #define CQHCI_FINISH_HALT_TIMEOUT 20 1061 1062 /* CQHCI could be expected to clear it's internal state pretty quickly */ 1063 #define CQHCI_CLEAR_TIMEOUT 20 1064 1065 static void cqhci_recovery_finish(struct mmc_host *mmc) 1066 { 1067 struct cqhci_host *cq_host = mmc->cqe_private; 1068 unsigned long flags; 1069 u32 cqcfg; 1070 bool ok; 1071 1072 pr_debug("%s: cqhci: %s\n", mmc_hostname(mmc), __func__); 1073 1074 WARN_ON(!cq_host->recovery_halt); 1075 1076 ok = cqhci_halt(mmc, CQHCI_FINISH_HALT_TIMEOUT); 1077 1078 /* 1079 * The specification contradicts itself, by saying that tasks cannot be 1080 * cleared if CQHCI does not halt, but if CQHCI does not halt, it should 1081 * be disabled/re-enabled, but not to disable before clearing tasks. 1082 * Have a go anyway. 1083 */ 1084 if (!cqhci_clear_all_tasks(mmc, CQHCI_CLEAR_TIMEOUT)) 1085 ok = false; 1086 1087 /* Disable to make sure tasks really are cleared */ 1088 cqcfg = cqhci_readl(cq_host, CQHCI_CFG); 1089 cqcfg &= ~CQHCI_ENABLE; 1090 cqhci_writel(cq_host, cqcfg, CQHCI_CFG); 1091 1092 cqcfg = cqhci_readl(cq_host, CQHCI_CFG); 1093 cqcfg |= CQHCI_ENABLE; 1094 cqhci_writel(cq_host, cqcfg, CQHCI_CFG); 1095 1096 cqhci_halt(mmc, CQHCI_FINISH_HALT_TIMEOUT); 1097 1098 if (!ok) 1099 cqhci_clear_all_tasks(mmc, CQHCI_CLEAR_TIMEOUT); 1100 1101 cqhci_recover_mrqs(cq_host); 1102 1103 WARN_ON(cq_host->qcnt); 1104 1105 spin_lock_irqsave(&cq_host->lock, flags); 1106 cq_host->qcnt = 0; 1107 cq_host->recovery_halt = false; 1108 mmc->cqe_on = false; 1109 spin_unlock_irqrestore(&cq_host->lock, flags); 1110 1111 /* Ensure all writes are done before interrupts are re-enabled */ 1112 wmb(); 1113 1114 cqhci_writel(cq_host, CQHCI_IS_HAC | CQHCI_IS_TCL, CQHCI_IS); 1115 1116 cqhci_set_irqs(cq_host, CQHCI_IS_MASK); 1117 1118 pr_debug("%s: cqhci: recovery done\n", mmc_hostname(mmc)); 1119 } 1120 1121 static const struct mmc_cqe_ops cqhci_cqe_ops = { 1122 .cqe_enable = cqhci_enable, 1123 .cqe_disable = cqhci_disable, 1124 .cqe_request = cqhci_request, 1125 .cqe_post_req = cqhci_post_req, 1126 .cqe_off = cqhci_off, 1127 .cqe_wait_for_idle = cqhci_wait_for_idle, 1128 .cqe_timeout = cqhci_timeout, 1129 .cqe_recovery_start = cqhci_recovery_start, 1130 .cqe_recovery_finish = cqhci_recovery_finish, 1131 }; 1132 1133 struct cqhci_host *cqhci_pltfm_init(struct platform_device *pdev) 1134 { 1135 struct cqhci_host *cq_host; 1136 struct resource *cqhci_memres = NULL; 1137 1138 /* check and setup CMDQ interface */ 1139 cqhci_memres = platform_get_resource_byname(pdev, IORESOURCE_MEM, 1140 "cqhci"); 1141 if (!cqhci_memres) { 1142 dev_dbg(&pdev->dev, "CMDQ not supported\n"); 1143 return ERR_PTR(-EINVAL); 1144 } 1145 1146 cq_host = devm_kzalloc(&pdev->dev, sizeof(*cq_host), GFP_KERNEL); 1147 if (!cq_host) 1148 return ERR_PTR(-ENOMEM); 1149 cq_host->mmio = devm_ioremap(&pdev->dev, 1150 cqhci_memres->start, 1151 resource_size(cqhci_memres)); 1152 if (!cq_host->mmio) { 1153 dev_err(&pdev->dev, "failed to remap cqhci regs\n"); 1154 return ERR_PTR(-EBUSY); 1155 } 1156 dev_dbg(&pdev->dev, "CMDQ ioremap: done\n"); 1157 1158 return cq_host; 1159 } 1160 EXPORT_SYMBOL(cqhci_pltfm_init); 1161 1162 static unsigned int cqhci_ver_major(struct cqhci_host *cq_host) 1163 { 1164 return CQHCI_VER_MAJOR(cqhci_readl(cq_host, CQHCI_VER)); 1165 } 1166 1167 static unsigned int cqhci_ver_minor(struct cqhci_host *cq_host) 1168 { 1169 u32 ver = cqhci_readl(cq_host, CQHCI_VER); 1170 1171 return CQHCI_VER_MINOR1(ver) * 10 + CQHCI_VER_MINOR2(ver); 1172 } 1173 1174 int cqhci_init(struct cqhci_host *cq_host, struct mmc_host *mmc, 1175 bool dma64) 1176 { 1177 int err; 1178 1179 cq_host->dma64 = dma64; 1180 cq_host->mmc = mmc; 1181 cq_host->mmc->cqe_private = cq_host; 1182 1183 cq_host->num_slots = NUM_SLOTS; 1184 cq_host->dcmd_slot = DCMD_SLOT; 1185 1186 mmc->cqe_ops = &cqhci_cqe_ops; 1187 1188 mmc->cqe_qdepth = NUM_SLOTS; 1189 if (mmc->caps2 & MMC_CAP2_CQE_DCMD) 1190 mmc->cqe_qdepth -= 1; 1191 1192 cq_host->slot = devm_kcalloc(mmc_dev(mmc), cq_host->num_slots, 1193 sizeof(*cq_host->slot), GFP_KERNEL); 1194 if (!cq_host->slot) { 1195 err = -ENOMEM; 1196 goto out_err; 1197 } 1198 1199 err = cqhci_crypto_init(cq_host); 1200 if (err) { 1201 pr_err("%s: CQHCI crypto initialization failed\n", 1202 mmc_hostname(mmc)); 1203 goto out_err; 1204 } 1205 1206 spin_lock_init(&cq_host->lock); 1207 1208 init_completion(&cq_host->halt_comp); 1209 init_waitqueue_head(&cq_host->wait_queue); 1210 1211 pr_info("%s: CQHCI version %u.%02u\n", 1212 mmc_hostname(mmc), cqhci_ver_major(cq_host), 1213 cqhci_ver_minor(cq_host)); 1214 1215 return 0; 1216 1217 out_err: 1218 pr_err("%s: CQHCI version %u.%02u failed to initialize, error %d\n", 1219 mmc_hostname(mmc), cqhci_ver_major(cq_host), 1220 cqhci_ver_minor(cq_host), err); 1221 return err; 1222 } 1223 EXPORT_SYMBOL(cqhci_init); 1224 1225 MODULE_AUTHOR("Venkat Gopalakrishnan <venkatg@codeaurora.org>"); 1226 MODULE_DESCRIPTION("Command Queue Host Controller Interface driver"); 1227 MODULE_LICENSE("GPL v2"); 1228