1 /* 2 * Copyright (c) 2006-2018, RT-Thread Development Team 3 * 4 * SPDX-License-Identifier: Apache-2.0 5 * 6 * Change Logs: 7 * Date Author Notes 8 * 2012-01-13 weety first version 9 */ 10 11 #include <drivers/mmcsd_core.h> 12 #include <drivers/sdio.h> 13 #include <drivers/sd.h> 14 15 #define DBG_ENABLE 16 #define DBG_SECTION_NAME "SDIO" 17 #ifdef RT_SDIO_DEBUG 18 #define DBG_LEVEL DBG_LOG 19 #else 20 #define DBG_LEVEL DBG_INFO 21 #endif /* RT_SDIO_DEBUG */ 22 #define DBG_COLOR 23 #include <rtdbg.h> 24 25 #ifndef RT_SDIO_STACK_SIZE 26 #define RT_SDIO_STACK_SIZE 512 27 #endif 28 #ifndef RT_SDIO_THREAD_PRIORITY 29 #define RT_SDIO_THREAD_PRIORITY 0x40 30 #endif 31 32 static rt_list_t sdio_cards = RT_LIST_OBJECT_INIT(sdio_cards); 33 static rt_list_t sdio_drivers = RT_LIST_OBJECT_INIT(sdio_drivers); 34 35 struct sdio_card 36 { 37 struct rt_mmcsd_card *card; 38 rt_list_t list; 39 }; 40 41 struct sdio_driver 42 { 43 struct rt_sdio_driver *drv; 44 rt_list_t list; 45 }; 46 47 #define MIN(a, b) (a < b ? a : b) 48 49 static const rt_uint8_t speed_value[16] = 50 { 51 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 52 }; 53 54 static const rt_uint32_t speed_unit[8] = 55 { 56 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 57 }; 58 59 rt_inline rt_int32_t sdio_match_card(struct rt_mmcsd_card *card, 60 const struct rt_sdio_device_id *id); 61 62 63 rt_int32_t sdio_io_send_op_cond(struct rt_mmcsd_host *host, 64 rt_uint32_t ocr, 65 rt_uint32_t *cmd5_resp) 66 { 67 struct rt_mmcsd_cmd cmd; 68 rt_int32_t i, err = 0; 69 70 RT_ASSERT(host != RT_NULL); 71 72 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 73 74 cmd.cmd_code = SD_IO_SEND_OP_COND; 75 cmd.arg = ocr; 76 cmd.flags = RESP_SPI_R4 | RESP_R4 | CMD_BCR; 77 78 for (i = 100; i; i--) 79 { 80 err = mmcsd_send_cmd(host, &cmd, 0); 81 if (err) 82 break; 83 84 /* if we're just probing, do a single pass */ 85 if (ocr == 0) 86 break; 87 88 /* otherwise wait until reset completes */ 89 if (controller_is_spi(host)) 90 { 91 /* 92 * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate 93 * an initialized card under SPI, but some cards 94 * (Marvell's) only behave when looking at this 95 * one. 96 */ 97 if (cmd.resp[1] & CARD_BUSY) 98 break; 99 } 100 else 101 { 102 if (cmd.resp[0] & CARD_BUSY) 103 break; 104 } 105 106 err = -RT_ETIMEOUT; 107 108 mmcsd_delay_ms(10); 109 } 110 111 if (cmd5_resp) 112 *cmd5_resp = cmd.resp[controller_is_spi(host) ? 1 : 0]; 113 114 return err; 115 } 116 117 rt_int32_t sdio_io_rw_direct(struct rt_mmcsd_card *card, 118 rt_int32_t rw, 119 rt_uint32_t fn, 120 rt_uint32_t reg_addr, 121 rt_uint8_t *pdata, 122 rt_uint8_t raw) 123 { 124 struct rt_mmcsd_cmd cmd; 125 rt_int32_t err; 126 127 RT_ASSERT(card != RT_NULL); 128 RT_ASSERT(fn <= SDIO_MAX_FUNCTIONS); 129 RT_ASSERT(pdata != RT_NULL); 130 131 if (reg_addr & ~SDIO_ARG_CMD53_REG_MASK) 132 return -RT_ERROR; 133 134 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 135 136 cmd.cmd_code = SD_IO_RW_DIRECT; 137 cmd.arg = rw ? SDIO_ARG_CMD52_WRITE : SDIO_ARG_CMD52_READ; 138 cmd.arg |= fn << SDIO_ARG_CMD52_FUNC_SHIFT; 139 cmd.arg |= raw ? SDIO_ARG_CMD52_RAW_FLAG : 0x00000000; 140 cmd.arg |= reg_addr << SDIO_ARG_CMD52_REG_SHIFT; 141 cmd.arg |= *pdata; 142 cmd.flags = RESP_SPI_R5 | RESP_R5 | CMD_AC; 143 144 err = mmcsd_send_cmd(card->host, &cmd, 0); 145 if (err) 146 return err; 147 148 if (!controller_is_spi(card->host)) 149 { 150 if (cmd.resp[0] & R5_ERROR) 151 return -RT_EIO; 152 if (cmd.resp[0] & R5_FUNCTION_NUMBER) 153 return -RT_ERROR; 154 if (cmd.resp[0] & R5_OUT_OF_RANGE) 155 return -RT_ERROR; 156 } 157 158 if (!rw || raw) 159 { 160 if (controller_is_spi(card->host)) 161 *pdata = (cmd.resp[0] >> 8) & 0xFF; 162 else 163 *pdata = cmd.resp[0] & 0xFF; 164 } 165 166 return 0; 167 } 168 169 rt_int32_t sdio_io_rw_extended(struct rt_mmcsd_card *card, 170 rt_int32_t rw, 171 rt_uint32_t fn, 172 rt_uint32_t addr, 173 rt_int32_t op_code, 174 rt_uint8_t *buf, 175 rt_uint32_t blocks, 176 rt_uint32_t blksize) 177 { 178 struct rt_mmcsd_req req; 179 struct rt_mmcsd_cmd cmd; 180 struct rt_mmcsd_data data; 181 182 RT_ASSERT(card != RT_NULL); 183 RT_ASSERT(fn <= SDIO_MAX_FUNCTIONS); 184 RT_ASSERT(blocks != 1 || blksize <= 512); 185 RT_ASSERT(blocks != 0); 186 RT_ASSERT(blksize != 0); 187 188 if (addr & ~SDIO_ARG_CMD53_REG_MASK) 189 return -RT_ERROR; 190 191 rt_memset(&req, 0, sizeof(struct rt_mmcsd_req)); 192 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 193 rt_memset(&data, 0, sizeof(struct rt_mmcsd_data)); 194 195 req.cmd = &cmd; 196 req.data = &data; 197 198 cmd.cmd_code = SD_IO_RW_EXTENDED; 199 cmd.arg = rw ? SDIO_ARG_CMD53_WRITE : SDIO_ARG_CMD53_READ; 200 cmd.arg |= fn << SDIO_ARG_CMD53_FUNC_SHIFT; 201 cmd.arg |= op_code ? SDIO_ARG_CMD53_INCREMENT : 0x00000000; 202 cmd.arg |= addr << SDIO_ARG_CMD53_REG_SHIFT; 203 if (blocks == 1 && blksize <= 512) 204 cmd.arg |= (blksize == 512) ? 0 : blksize; /* byte mode */ 205 else 206 cmd.arg |= SDIO_ARG_CMD53_BLOCK_MODE | blocks; /* block mode */ 207 cmd.flags = RESP_SPI_R5 | RESP_R5 | CMD_ADTC; 208 209 data.blksize = blksize; 210 data.blks = blocks; 211 data.flags = rw ? DATA_DIR_WRITE : DATA_DIR_READ; 212 data.buf = (rt_uint32_t *)buf; 213 214 mmcsd_set_data_timeout(&data, card); 215 216 mmcsd_send_request(card->host, &req); 217 218 if (cmd.err) 219 return cmd.err; 220 if (data.err) 221 return data.err; 222 223 if (!controller_is_spi(card->host)) 224 { 225 if (cmd.resp[0] & R5_ERROR) 226 return -RT_EIO; 227 if (cmd.resp[0] & R5_FUNCTION_NUMBER) 228 return -RT_ERROR; 229 if (cmd.resp[0] & R5_OUT_OF_RANGE) 230 return -RT_ERROR; 231 } 232 233 return 0; 234 } 235 236 rt_inline rt_uint32_t sdio_max_block_size(struct rt_sdio_function *func) 237 { 238 rt_uint32_t size = MIN(func->card->host->max_seg_size, 239 func->card->host->max_blk_size); 240 size = MIN(size, func->max_blk_size); 241 242 return MIN(size, 512u); /* maximum size for byte mode */ 243 } 244 245 rt_int32_t sdio_io_rw_extended_block(struct rt_sdio_function *func, 246 rt_int32_t rw, 247 rt_uint32_t addr, 248 rt_int32_t op_code, 249 rt_uint8_t *buf, 250 rt_uint32_t len) 251 { 252 rt_int32_t ret; 253 rt_uint32_t left_size; 254 rt_uint32_t max_blks, blks; 255 256 left_size = len; 257 258 /* Do the bulk of the transfer using block mode (if supported). */ 259 if (func->card->cccr.multi_block && (len > sdio_max_block_size(func))) 260 { 261 max_blks = MIN(func->card->host->max_blk_count, 262 func->card->host->max_seg_size / func->cur_blk_size); 263 max_blks = MIN(max_blks, 511u); 264 265 while (left_size > func->cur_blk_size) 266 { 267 blks = left_size / func->cur_blk_size; 268 if (blks > max_blks) 269 blks = max_blks; 270 len = blks * func->cur_blk_size; 271 272 ret = sdio_io_rw_extended(func->card, rw, func->num, 273 addr, op_code, buf, blks, func->cur_blk_size); 274 if (ret) 275 return ret; 276 277 left_size -= len; 278 buf += len; 279 if (op_code) 280 addr += len; 281 } 282 } 283 284 while (left_size > 0) 285 { 286 len = MIN(left_size, sdio_max_block_size(func)); 287 288 ret = sdio_io_rw_extended(func->card, rw, func->num, 289 addr, op_code, buf, 1, len); 290 if (ret) 291 return ret; 292 293 left_size -= len; 294 buf += len; 295 if (op_code) 296 addr += len; 297 } 298 299 return 0; 300 } 301 302 rt_uint8_t sdio_io_readb(struct rt_sdio_function *func, 303 rt_uint32_t reg, 304 rt_int32_t *err) 305 { 306 rt_uint8_t data = 0; 307 rt_int32_t ret; 308 309 ret = sdio_io_rw_direct(func->card, 0, func->num, reg, &data, 0); 310 311 if (err) 312 { 313 *err = ret; 314 } 315 316 return data; 317 } 318 319 rt_int32_t sdio_io_writeb(struct rt_sdio_function *func, 320 rt_uint32_t reg, 321 rt_uint8_t data) 322 { 323 return sdio_io_rw_direct(func->card, 1, func->num, reg, &data, 0); 324 } 325 326 rt_uint16_t sdio_io_readw(struct rt_sdio_function *func, 327 rt_uint32_t addr, 328 rt_int32_t *err) 329 { 330 rt_int32_t ret; 331 rt_uint32_t dmabuf; 332 333 if (err) 334 *err = 0; 335 336 ret = sdio_io_rw_extended_block(func, 0, addr, 1, (rt_uint8_t *)&dmabuf, 2); 337 if (ret) 338 { 339 if (err) 340 *err = ret; 341 } 342 343 return (rt_uint16_t)dmabuf; 344 } 345 346 rt_int32_t sdio_io_writew(struct rt_sdio_function *func, 347 rt_uint16_t data, 348 rt_uint32_t addr) 349 { 350 rt_uint32_t dmabuf = data; 351 352 return sdio_io_rw_extended_block(func, 1, addr, 1, (rt_uint8_t *)&dmabuf, 2); 353 } 354 355 rt_uint32_t sdio_io_readl(struct rt_sdio_function *func, 356 rt_uint32_t addr, 357 rt_int32_t *err) 358 { 359 rt_int32_t ret; 360 rt_uint32_t dmabuf; 361 362 if (err) 363 *err = 0; 364 365 ret = sdio_io_rw_extended_block(func, 0, addr, 1, (rt_uint8_t *)&dmabuf, 4); 366 if (ret) 367 { 368 if (err) 369 *err = ret; 370 } 371 372 return dmabuf; 373 } 374 375 rt_int32_t sdio_io_writel(struct rt_sdio_function *func, 376 rt_uint32_t data, 377 rt_uint32_t addr) 378 { 379 rt_uint32_t dmabuf = data; 380 381 return sdio_io_rw_extended_block(func, 1, addr, 1, (rt_uint8_t *)&dmabuf, 4); 382 } 383 384 rt_int32_t sdio_io_read_multi_fifo_b(struct rt_sdio_function *func, 385 rt_uint32_t addr, 386 rt_uint8_t *buf, 387 rt_uint32_t len) 388 { 389 return sdio_io_rw_extended_block(func, 0, addr, 0, buf, len); 390 } 391 392 rt_int32_t sdio_io_write_multi_fifo_b(struct rt_sdio_function *func, 393 rt_uint32_t addr, 394 rt_uint8_t *buf, 395 rt_uint32_t len) 396 { 397 return sdio_io_rw_extended_block(func, 1, addr, 0, buf, len); 398 } 399 400 rt_int32_t sdio_io_read_multi_incr_b(struct rt_sdio_function *func, 401 rt_uint32_t addr, 402 rt_uint8_t *buf, 403 rt_uint32_t len) 404 { 405 return sdio_io_rw_extended_block(func, 0, addr, 1, buf, len); 406 } 407 408 rt_int32_t sdio_io_write_multi_incr_b(struct rt_sdio_function *func, 409 rt_uint32_t addr, 410 rt_uint8_t *buf, 411 rt_uint32_t len) 412 { 413 return sdio_io_rw_extended_block(func, 1, addr, 1, buf, len); 414 } 415 416 static rt_int32_t sdio_read_cccr(struct rt_mmcsd_card *card) 417 { 418 rt_int32_t ret; 419 rt_int32_t cccr_version; 420 rt_uint8_t data; 421 422 rt_memset(&card->cccr, 0, sizeof(struct rt_sdio_cccr)); 423 424 data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_CCCR_REV, &ret); 425 if (ret) 426 goto out; 427 428 cccr_version = data & 0x0f; 429 430 if (cccr_version > SDIO_CCCR_REV_3_00) 431 { 432 LOG_E("unrecognised CCCR structure version %d", cccr_version); 433 434 return -RT_ERROR; 435 } 436 437 card->cccr.sdio_version = (data & 0xf0) >> 4; 438 439 data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_CARD_CAPS, &ret); 440 if (ret) 441 goto out; 442 443 if (data & SDIO_CCCR_CAP_SMB) 444 card->cccr.multi_block = 1; 445 if (data & SDIO_CCCR_CAP_LSC) 446 card->cccr.low_speed = 1; 447 if (data & SDIO_CCCR_CAP_4BLS) 448 card->cccr.low_speed_4 = 1; 449 if (data & SDIO_CCCR_CAP_4BLS) 450 card->cccr.bus_width = 1; 451 452 if (cccr_version >= SDIO_CCCR_REV_1_10) 453 { 454 data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_POWER_CTRL, &ret); 455 if (ret) 456 goto out; 457 458 if (data & SDIO_POWER_SMPC) 459 card->cccr.power_ctrl = 1; 460 } 461 462 if (cccr_version >= SDIO_CCCR_REV_1_20) 463 { 464 data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_SPEED, &ret); 465 if (ret) 466 goto out; 467 468 if (data & SDIO_SPEED_SHS) 469 card->cccr.high_speed = 1; 470 } 471 472 out: 473 return ret; 474 } 475 476 static rt_int32_t cistpl_funce_func0(struct rt_mmcsd_card *card, 477 const rt_uint8_t *buf, 478 rt_uint32_t size) 479 { 480 if (size < 0x04 || buf[0] != 0) 481 return -RT_ERROR; 482 483 /* TPLFE_FN0_BLK_SIZE */ 484 card->cis.func0_blk_size = buf[1] | (buf[2] << 8); 485 486 /* TPLFE_MAX_TRAN_SPEED */ 487 card->cis.max_tran_speed = speed_value[(buf[3] >> 3) & 15] * 488 speed_unit[buf[3] & 7]; 489 490 return 0; 491 } 492 493 static rt_int32_t cistpl_funce_func(struct rt_sdio_function *func, 494 const rt_uint8_t *buf, 495 rt_uint32_t size) 496 { 497 rt_uint32_t version; 498 rt_uint32_t min_size; 499 500 version = func->card->cccr.sdio_version; 501 min_size = (version == SDIO_SDIO_REV_1_00) ? 28 : 42; 502 503 if (size < min_size || buf[0] != 1) 504 return -RT_ERROR; 505 506 /* TPLFE_MAX_BLK_SIZE */ 507 func->max_blk_size = buf[12] | (buf[13] << 8); 508 509 /* TPLFE_ENABLE_TIMEOUT_VAL, present in ver 1.1 and above */ 510 if (version > SDIO_SDIO_REV_1_00) 511 func->enable_timeout_val = (buf[28] | (buf[29] << 8)) * 10; 512 else 513 func->enable_timeout_val = 1000; /* 1000ms */ 514 515 return 0; 516 } 517 518 static rt_int32_t sdio_read_cis(struct rt_sdio_function *func) 519 { 520 rt_int32_t ret; 521 struct rt_sdio_function_tuple *curr, **prev; 522 rt_uint32_t i, cisptr = 0; 523 rt_uint8_t data; 524 rt_uint8_t tpl_code, tpl_link; 525 526 struct rt_mmcsd_card *card = func->card; 527 struct rt_sdio_function *func0 = card->sdio_function[0]; 528 529 RT_ASSERT(func0 != RT_NULL); 530 531 for (i = 0; i < 3; i++) 532 { 533 data = sdio_io_readb(func0, 534 SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_CIS + i, &ret); 535 if (ret) 536 return ret; 537 cisptr |= data << (i * 8); 538 } 539 540 prev = &func->tuples; 541 542 do { 543 tpl_code = sdio_io_readb(func0, cisptr++, &ret); 544 if (ret) 545 break; 546 tpl_link = sdio_io_readb(func0, cisptr++, &ret); 547 if (ret) 548 break; 549 550 if ((tpl_code == CISTPL_END) || (tpl_link == 0xff)) 551 break; 552 553 if (tpl_code == CISTPL_NULL) 554 continue; 555 556 557 curr = rt_malloc(sizeof(struct rt_sdio_function_tuple) + tpl_link); 558 if (!curr) 559 return -RT_ENOMEM; 560 curr->data = (rt_uint8_t *)curr + sizeof(struct rt_sdio_function_tuple); 561 562 for (i = 0; i < tpl_link; i++) 563 { 564 curr->data[i] = sdio_io_readb(func0, cisptr + i, &ret); 565 if (ret) 566 break; 567 } 568 if (ret) 569 { 570 rt_free(curr); 571 break; 572 } 573 574 switch (tpl_code) 575 { 576 case CISTPL_MANFID: 577 if (tpl_link < 4) 578 { 579 LOG_D("bad CISTPL_MANFID length"); 580 break; 581 } 582 if (func->num != 0) 583 { 584 func->manufacturer = curr->data[0]; 585 func->manufacturer |= curr->data[1] << 8; 586 func->product = curr->data[2]; 587 func->product |= curr->data[3] << 8; 588 } 589 else 590 { 591 card->cis.manufacturer = curr->data[0]; 592 card->cis.manufacturer |= curr->data[1] << 8; 593 card->cis.product = curr->data[2]; 594 card->cis.product |= curr->data[3] << 8; 595 } 596 break; 597 case CISTPL_FUNCE: 598 if (func->num != 0) 599 ret = cistpl_funce_func(func, curr->data, tpl_link); 600 else 601 ret = cistpl_funce_func0(card, curr->data, tpl_link); 602 603 if (ret) 604 { 605 LOG_D("bad CISTPL_FUNCE size %u " 606 "type %u", tpl_link, curr->data[0]); 607 } 608 609 break; 610 case CISTPL_VERS_1: 611 if (tpl_link < 2) 612 { 613 LOG_D("CISTPL_VERS_1 too short"); 614 } 615 break; 616 default: 617 /* this tuple is unknown to the core */ 618 curr->next = RT_NULL; 619 curr->code = tpl_code; 620 curr->size = tpl_link; 621 *prev = curr; 622 prev = &curr->next; 623 LOG_D( "function %d, CIS tuple code %#x, length %d", 624 func->num, tpl_code, tpl_link); 625 break; 626 } 627 628 cisptr += tpl_link; 629 } while (1); 630 631 /* 632 * Link in all unknown tuples found in the common CIS so that 633 * drivers don't have to go digging in two places. 634 */ 635 if (func->num != 0) 636 *prev = func0->tuples; 637 638 return ret; 639 } 640 641 642 void sdio_free_cis(struct rt_sdio_function *func) 643 { 644 struct rt_sdio_function_tuple *tuple, *tmp; 645 struct rt_mmcsd_card *card = func->card; 646 647 tuple = func->tuples; 648 649 while (tuple && ((tuple != card->sdio_function[0]->tuples) || (!func->num))) 650 { 651 tmp = tuple; 652 tuple = tuple->next; 653 rt_free(tmp); 654 } 655 656 func->tuples = RT_NULL; 657 } 658 659 static rt_int32_t sdio_read_fbr(struct rt_sdio_function *func) 660 { 661 rt_int32_t ret; 662 rt_uint8_t data; 663 struct rt_sdio_function *func0 = func->card->sdio_function[0]; 664 665 data = sdio_io_readb(func0, 666 SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_STD_FUNC_IF, &ret); 667 if (ret) 668 goto err; 669 670 data &= 0x0f; 671 672 if (data == 0x0f) 673 { 674 data = sdio_io_readb(func0, 675 SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_STD_IF_EXT, &ret); 676 if (ret) 677 goto err; 678 } 679 680 func->func_code = data; 681 682 err: 683 return ret; 684 } 685 686 static rt_int32_t sdio_initialize_function(struct rt_mmcsd_card *card, 687 rt_uint32_t func_num) 688 { 689 rt_int32_t ret; 690 struct rt_sdio_function *func; 691 692 RT_ASSERT(func_num <= SDIO_MAX_FUNCTIONS); 693 694 func = rt_malloc(sizeof(struct rt_sdio_function)); 695 if (!func) 696 { 697 LOG_E("malloc rt_sdio_function failed"); 698 ret = -RT_ENOMEM; 699 goto err; 700 } 701 rt_memset(func, 0, sizeof(struct rt_sdio_function)); 702 703 func->card = card; 704 func->num = func_num; 705 706 ret = sdio_read_fbr(func); 707 if (ret) 708 goto err1; 709 710 ret = sdio_read_cis(func); 711 if (ret) 712 goto err1; 713 714 card->sdio_function[func_num] = func; 715 716 return 0; 717 718 err1: 719 sdio_free_cis(func); 720 rt_free(func); 721 card->sdio_function[func_num] = RT_NULL; 722 err: 723 return ret; 724 } 725 726 static rt_int32_t sdio_set_highspeed(struct rt_mmcsd_card *card) 727 { 728 rt_int32_t ret; 729 rt_uint8_t speed; 730 731 if (!(card->host->flags & MMCSD_SUP_HIGHSPEED)) 732 return 0; 733 734 if (!card->cccr.high_speed) 735 return 0; 736 737 speed = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_SPEED, &ret); 738 if (ret) 739 return ret; 740 741 speed |= SDIO_SPEED_EHS; 742 743 ret = sdio_io_writeb(card->sdio_function[0], SDIO_REG_CCCR_SPEED, speed); 744 if (ret) 745 return ret; 746 747 card->flags |= CARD_FLAG_HIGHSPEED; 748 749 return 0; 750 } 751 752 static rt_int32_t sdio_set_bus_wide(struct rt_mmcsd_card *card) 753 { 754 rt_int32_t ret; 755 rt_uint8_t busif; 756 757 if (!(card->host->flags & MMCSD_BUSWIDTH_4)) 758 return 0; 759 760 if (card->cccr.low_speed && !card->cccr.bus_width) 761 return 0; 762 763 busif = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_BUS_IF, &ret); 764 if (ret) 765 return ret; 766 767 busif |= SDIO_BUS_WIDTH_4BIT; 768 769 ret = sdio_io_writeb(card->sdio_function[0], SDIO_REG_CCCR_BUS_IF, busif); 770 if (ret) 771 return ret; 772 773 mmcsd_set_bus_width(card->host, MMCSD_BUS_WIDTH_4); 774 775 return 0; 776 } 777 778 static rt_int32_t sdio_register_card(struct rt_mmcsd_card *card) 779 { 780 struct sdio_card *sc; 781 struct sdio_driver *sd; 782 rt_list_t *l; 783 784 sc = rt_malloc(sizeof(struct sdio_card)); 785 if (sc == RT_NULL) 786 { 787 LOG_E("malloc sdio card failed"); 788 return -RT_ENOMEM; 789 } 790 791 sc->card = card; 792 rt_list_insert_after(&sdio_cards, &sc->list); 793 794 if (rt_list_isempty(&sdio_drivers)) 795 { 796 goto out; 797 } 798 799 for (l = (&sdio_drivers)->next; l != &sdio_drivers; l = l->next) 800 { 801 sd = (struct sdio_driver *)rt_list_entry(l, struct sdio_driver, list); 802 if (sdio_match_card(card, sd->drv->id)) 803 { 804 sd->drv->probe(card); 805 } 806 } 807 808 out: 809 return 0; 810 } 811 812 static rt_int32_t sdio_init_card(struct rt_mmcsd_host *host, rt_uint32_t ocr) 813 { 814 rt_int32_t err = 0; 815 rt_int32_t i, function_num; 816 rt_uint32_t cmd5_resp; 817 struct rt_mmcsd_card *card; 818 819 err = sdio_io_send_op_cond(host, ocr, &cmd5_resp); 820 if (err) 821 goto err; 822 823 if (controller_is_spi(host)) 824 { 825 err = mmcsd_spi_use_crc(host, host->spi_use_crc); 826 if (err) 827 goto err; 828 } 829 830 function_num = (cmd5_resp & 0x70000000) >> 28; 831 832 card = rt_malloc(sizeof(struct rt_mmcsd_card)); 833 if (!card) 834 { 835 LOG_E("malloc card failed"); 836 err = -RT_ENOMEM; 837 goto err; 838 } 839 rt_memset(card, 0, sizeof(struct rt_mmcsd_card)); 840 841 card->card_type = CARD_TYPE_SDIO; 842 card->sdio_function_num = function_num; 843 card->host = host; 844 host->card = card; 845 846 card->sdio_function[0] = rt_malloc(sizeof(struct rt_sdio_function)); 847 if (!card->sdio_function[0]) 848 { 849 LOG_E("malloc sdio_func0 failed"); 850 err = -RT_ENOMEM; 851 goto err1; 852 } 853 rt_memset(card->sdio_function[0], 0, sizeof(struct rt_sdio_function)); 854 card->sdio_function[0]->card = card; 855 card->sdio_function[0]->num = 0; 856 857 if (!controller_is_spi(host)) 858 { 859 err = mmcsd_get_card_addr(host, &card->rca); 860 if (err) 861 goto err2; 862 863 mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL); 864 } 865 866 if (!controller_is_spi(host)) 867 { 868 err = mmcsd_select_card(card); 869 if (err) 870 goto err2; 871 } 872 873 err = sdio_read_cccr(card); 874 if (err) 875 goto err2; 876 877 err = sdio_read_cis(card->sdio_function[0]); 878 if (err) 879 goto err2; 880 881 err = sdio_set_highspeed(card); 882 if (err) 883 goto err2; 884 885 if (card->flags & CARD_FLAG_HIGHSPEED) 886 { 887 mmcsd_set_clock(host, 50000000); 888 } 889 else 890 { 891 mmcsd_set_clock(host, card->cis.max_tran_speed); 892 } 893 894 err = sdio_set_bus_wide(card); 895 if (err) 896 goto err2; 897 898 for (i = 1; i < function_num + 1; i++) 899 { 900 err = sdio_initialize_function(card, i); 901 if (err) 902 goto err3; 903 } 904 905 906 /* register sdio card */ 907 err = sdio_register_card(card); 908 if (err) 909 { 910 goto err3; 911 } 912 913 return 0; 914 915 err3: 916 if (host->card) 917 { 918 for (i = 1; i < host->card->sdio_function_num + 1; i++) 919 { 920 if (host->card->sdio_function[i]) 921 { 922 sdio_free_cis(host->card->sdio_function[i]); 923 rt_free(host->card->sdio_function[i]); 924 host->card->sdio_function[i] = RT_NULL; 925 rt_free(host->card); 926 host->card = RT_NULL; 927 break; 928 } 929 } 930 } 931 err2: 932 if (host->card && host->card->sdio_function[0]) 933 { 934 sdio_free_cis(host->card->sdio_function[0]); 935 rt_free(host->card->sdio_function[0]); 936 host->card->sdio_function[0] = RT_NULL; 937 } 938 err1: 939 if (host->card) 940 { 941 rt_free(host->card); 942 } 943 err: 944 LOG_E("error %d while initialising SDIO card", err); 945 946 return err; 947 } 948 949 rt_int32_t init_sdio(struct rt_mmcsd_host *host, rt_uint32_t ocr) 950 { 951 rt_int32_t err; 952 rt_uint32_t current_ocr; 953 954 RT_ASSERT(host != RT_NULL); 955 956 if (ocr & 0x7F) 957 { 958 LOG_W("Card ocr below the defined voltage rang."); 959 ocr &= ~0x7F; 960 } 961 962 if (ocr & VDD_165_195) 963 { 964 LOG_W("Can't support the low voltage SDIO card."); 965 ocr &= ~VDD_165_195; 966 } 967 968 current_ocr = mmcsd_select_voltage(host, ocr); 969 970 if (!current_ocr) 971 { 972 err = -RT_ERROR; 973 goto err; 974 } 975 976 err = sdio_init_card(host, current_ocr); 977 if (err) 978 goto remove_card; 979 980 return 0; 981 982 remove_card: 983 rt_free(host->card); 984 host->card = RT_NULL; 985 err: 986 987 LOG_E("init SDIO card failed"); 988 989 return err; 990 } 991 992 static void sdio_irq_thread(void *param) 993 { 994 rt_int32_t i, ret; 995 rt_uint8_t pending; 996 struct rt_mmcsd_card *card; 997 struct rt_mmcsd_host *host = (struct rt_mmcsd_host *)param; 998 RT_ASSERT(host != RT_NULL); 999 card = host->card; 1000 RT_ASSERT(card != RT_NULL); 1001 1002 while (1) 1003 { 1004 if (rt_sem_take(host->sdio_irq_sem, RT_WAITING_FOREVER) == RT_EOK) 1005 { 1006 mmcsd_host_lock(host); 1007 pending = sdio_io_readb(host->card->sdio_function[0], 1008 SDIO_REG_CCCR_INT_PEND, &ret); 1009 if (ret) 1010 { 1011 mmcsd_dbg("error %d reading SDIO_REG_CCCR_INT_PEND\n", ret); 1012 goto out; 1013 } 1014 1015 for (i = 1; i <= 7; i++) 1016 { 1017 if (pending & (1 << i)) 1018 { 1019 struct rt_sdio_function *func = card->sdio_function[i]; 1020 if (!func) 1021 { 1022 mmcsd_dbg("pending IRQ for " 1023 "non-existant function %d\n", func->num); 1024 goto out; 1025 } 1026 else if (func->irq_handler) 1027 { 1028 func->irq_handler(func); 1029 } 1030 else 1031 { 1032 mmcsd_dbg("pending IRQ with no register handler\n"); 1033 goto out; 1034 } 1035 } 1036 } 1037 1038 out: 1039 mmcsd_host_unlock(host); 1040 if (host->flags & MMCSD_SUP_SDIO_IRQ) 1041 host->ops->enable_sdio_irq(host, 1); 1042 continue; 1043 } 1044 } 1045 } 1046 1047 static rt_int32_t sdio_irq_thread_create(struct rt_mmcsd_card *card) 1048 { 1049 struct rt_mmcsd_host *host = card->host; 1050 1051 /* init semaphore and create sdio irq processing thread */ 1052 if (!host->sdio_irq_num) 1053 { 1054 host->sdio_irq_num++; 1055 host->sdio_irq_sem = rt_sem_create("sdio_irq", 0, RT_IPC_FLAG_FIFO); 1056 RT_ASSERT(host->sdio_irq_sem != RT_NULL); 1057 1058 host->sdio_irq_thread = rt_thread_create("sdio_irq", sdio_irq_thread, host, 1059 RT_SDIO_STACK_SIZE, RT_SDIO_THREAD_PRIORITY, 20); 1060 if (host->sdio_irq_thread != RT_NULL) 1061 { 1062 rt_thread_startup(host->sdio_irq_thread); 1063 } 1064 } 1065 1066 return 0; 1067 } 1068 1069 static rt_int32_t sdio_irq_thread_delete(struct rt_mmcsd_card *card) 1070 { 1071 struct rt_mmcsd_host *host = card->host; 1072 1073 RT_ASSERT(host->sdio_irq_num > 0); 1074 1075 host->sdio_irq_num--; 1076 if (!host->sdio_irq_num) 1077 { 1078 if (host->flags & MMCSD_SUP_SDIO_IRQ) 1079 host->ops->enable_sdio_irq(host, 0); 1080 rt_sem_delete(host->sdio_irq_sem); 1081 host->sdio_irq_sem = RT_NULL; 1082 rt_thread_delete(host->sdio_irq_thread); 1083 host->sdio_irq_thread = RT_NULL; 1084 } 1085 1086 return 0; 1087 } 1088 1089 rt_int32_t sdio_attach_irq(struct rt_sdio_function *func, 1090 rt_sdio_irq_handler_t *handler) 1091 { 1092 rt_int32_t ret; 1093 rt_uint8_t reg; 1094 struct rt_sdio_function *func0; 1095 1096 RT_ASSERT(func != RT_NULL); 1097 RT_ASSERT(func->card != RT_NULL); 1098 1099 func0 = func->card->sdio_function[0]; 1100 1101 mmcsd_dbg("SDIO: enabling IRQ for function %d\n", func->num); 1102 1103 if (func->irq_handler) 1104 { 1105 mmcsd_dbg("SDIO: IRQ for already in use.\n"); 1106 1107 return -RT_EBUSY; 1108 } 1109 1110 reg = sdio_io_readb(func0, SDIO_REG_CCCR_INT_EN, &ret); 1111 if (ret) 1112 return ret; 1113 1114 reg |= 1 << func->num; 1115 1116 reg |= 1; /* Master interrupt enable */ 1117 1118 ret = sdio_io_writeb(func0, SDIO_REG_CCCR_INT_EN, reg); 1119 if (ret) 1120 return ret; 1121 1122 func->irq_handler = handler; 1123 1124 ret = sdio_irq_thread_create(func->card); 1125 if (ret) 1126 func->irq_handler = RT_NULL; 1127 1128 return ret; 1129 } 1130 1131 rt_int32_t sdio_detach_irq(struct rt_sdio_function *func) 1132 { 1133 rt_int32_t ret; 1134 rt_uint8_t reg; 1135 struct rt_sdio_function *func0; 1136 1137 RT_ASSERT(func != RT_NULL); 1138 RT_ASSERT(func->card != RT_NULL); 1139 1140 func0 = func->card->sdio_function[0]; 1141 1142 mmcsd_dbg("SDIO: disabling IRQ for function %d\n", func->num); 1143 1144 if (func->irq_handler) 1145 { 1146 func->irq_handler = RT_NULL; 1147 sdio_irq_thread_delete(func->card); 1148 } 1149 1150 reg = sdio_io_readb(func0, SDIO_REG_CCCR_INT_EN, &ret); 1151 if (ret) 1152 return ret; 1153 1154 reg &= ~(1 << func->num); 1155 1156 /* Disable master interrupt with the last function interrupt */ 1157 if (!(reg & 0xFE)) 1158 reg = 0; 1159 1160 ret = sdio_io_writeb(func0, SDIO_REG_CCCR_INT_EN, reg); 1161 if (ret) 1162 return ret; 1163 1164 return 0; 1165 } 1166 1167 void sdio_irq_wakeup(struct rt_mmcsd_host *host) 1168 { 1169 if (host->flags & MMCSD_SUP_SDIO_IRQ) 1170 host->ops->enable_sdio_irq(host, 0); 1171 if (host->sdio_irq_sem) 1172 rt_sem_release(host->sdio_irq_sem); 1173 } 1174 1175 rt_int32_t sdio_enable_func(struct rt_sdio_function *func) 1176 { 1177 rt_int32_t ret; 1178 rt_uint8_t reg; 1179 rt_uint32_t timeout; 1180 struct rt_sdio_function *func0; 1181 1182 RT_ASSERT(func != RT_NULL); 1183 RT_ASSERT(func->card != RT_NULL); 1184 1185 func0 = func->card->sdio_function[0]; 1186 1187 mmcsd_dbg("SDIO: enabling function %d\n", func->num); 1188 1189 reg = sdio_io_readb(func0, SDIO_REG_CCCR_IO_EN, &ret); 1190 if (ret) 1191 goto err; 1192 1193 reg |= 1 << func->num; 1194 1195 ret = sdio_io_writeb(func0, SDIO_REG_CCCR_IO_EN, reg); 1196 if (ret) 1197 goto err; 1198 1199 timeout = rt_tick_get() + func->enable_timeout_val * RT_TICK_PER_SECOND / 1000; 1200 1201 while (1) 1202 { 1203 reg = sdio_io_readb(func0, SDIO_REG_CCCR_IO_RDY, &ret); 1204 if (ret) 1205 goto err; 1206 if (reg & (1 << func->num)) 1207 break; 1208 ret = -RT_ETIMEOUT; 1209 if (rt_tick_get() > timeout) 1210 goto err; 1211 } 1212 1213 mmcsd_dbg("SDIO: enabled function successfull\n"); 1214 1215 return 0; 1216 1217 err: 1218 mmcsd_dbg("SDIO: failed to enable function %d\n", func->num); 1219 return ret; 1220 } 1221 1222 rt_int32_t sdio_disable_func(struct rt_sdio_function *func) 1223 { 1224 rt_int32_t ret; 1225 rt_uint8_t reg; 1226 struct rt_sdio_function *func0; 1227 1228 RT_ASSERT(func != RT_NULL); 1229 RT_ASSERT(func->card != RT_NULL); 1230 1231 func0 = func->card->sdio_function[0]; 1232 1233 mmcsd_dbg("SDIO: disabling function %d\n", func->num); 1234 1235 reg = sdio_io_readb(func0, SDIO_REG_CCCR_IO_EN, &ret); 1236 if (ret) 1237 goto err; 1238 1239 reg &= ~(1 << func->num); 1240 1241 ret = sdio_io_writeb(func0, SDIO_REG_CCCR_IO_EN, reg); 1242 if (ret) 1243 goto err; 1244 1245 mmcsd_dbg("SDIO: disabled function successfull\n"); 1246 1247 return 0; 1248 1249 err: 1250 mmcsd_dbg("SDIO: failed to disable function %d\n", func->num); 1251 return -RT_EIO; 1252 } 1253 1254 void sdio_set_drvdata(struct rt_sdio_function *func, void *data) 1255 { 1256 func->priv = data; 1257 } 1258 1259 void* sdio_get_drvdata(struct rt_sdio_function *func) 1260 { 1261 return func->priv; 1262 } 1263 1264 rt_int32_t sdio_set_block_size(struct rt_sdio_function *func, 1265 rt_uint32_t blksize) 1266 { 1267 rt_int32_t ret; 1268 struct rt_sdio_function *func0 = func->card->sdio_function[0]; 1269 1270 if (blksize > func->card->host->max_blk_size) 1271 return -RT_ERROR; 1272 1273 if (blksize == 0) 1274 { 1275 blksize = MIN(func->max_blk_size, func->card->host->max_blk_size); 1276 blksize = MIN(blksize, 512u); 1277 } 1278 1279 ret = sdio_io_writeb(func0, SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_BLKSIZE, 1280 blksize & 0xff); 1281 if (ret) 1282 return ret; 1283 ret = sdio_io_writeb(func0, SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_BLKSIZE + 1, 1284 (blksize >> 8) & 0xff); 1285 if (ret) 1286 return ret; 1287 func->cur_blk_size = blksize; 1288 1289 return 0; 1290 } 1291 1292 rt_inline rt_int32_t sdio_match_card(struct rt_mmcsd_card *card, 1293 const struct rt_sdio_device_id *id) 1294 { 1295 rt_uint8_t num = 1; 1296 1297 if ((id->manufacturer != SDIO_ANY_MAN_ID) && 1298 (id->manufacturer != card->cis.manufacturer)) 1299 return 0; 1300 1301 while (num <= card->sdio_function_num) 1302 { 1303 if ((id->product != SDIO_ANY_PROD_ID) && 1304 (id->product == card->sdio_function[num]->product)) 1305 return 1; 1306 num++; 1307 } 1308 1309 return 0; 1310 } 1311 1312 1313 static struct rt_mmcsd_card *sdio_match_driver(struct rt_sdio_device_id *id) 1314 { 1315 rt_list_t *l; 1316 struct sdio_card *sc; 1317 struct rt_mmcsd_card *card; 1318 1319 for (l = (&sdio_cards)->next; l != &sdio_cards; l = l->next) 1320 { 1321 sc = (struct sdio_card *)rt_list_entry(l, struct sdio_card, list); 1322 card = sc->card; 1323 1324 if (sdio_match_card(card, id)) 1325 { 1326 return card; 1327 } 1328 } 1329 1330 return RT_NULL; 1331 } 1332 1333 rt_int32_t sdio_register_driver(struct rt_sdio_driver *driver) 1334 { 1335 struct sdio_driver *sd; 1336 struct rt_mmcsd_card *card; 1337 1338 sd = rt_malloc(sizeof(struct sdio_driver)); 1339 if (sd == RT_NULL) 1340 { 1341 LOG_E("malloc sdio driver failed"); 1342 1343 return -RT_ENOMEM; 1344 } 1345 1346 sd->drv = driver; 1347 rt_list_insert_after(&sdio_drivers, &sd->list); 1348 1349 if (!rt_list_isempty(&sdio_cards)) 1350 { 1351 card = sdio_match_driver(driver->id); 1352 if (card != RT_NULL) 1353 { 1354 return driver->probe(card); 1355 } 1356 } 1357 1358 return -RT_EEMPTY; 1359 } 1360 1361 rt_int32_t sdio_unregister_driver(struct rt_sdio_driver *driver) 1362 { 1363 rt_list_t *l; 1364 struct sdio_driver *sd = RT_NULL; 1365 struct rt_mmcsd_card *card; 1366 1367 for (l = (&sdio_drivers)->next; l != &sdio_drivers; l = l->next) 1368 { 1369 sd = (struct sdio_driver *)rt_list_entry(l, struct sdio_driver, list); 1370 if (sd->drv != driver) 1371 { 1372 sd = RT_NULL; 1373 } 1374 } 1375 1376 if (sd == RT_NULL) 1377 { 1378 LOG_E("SDIO driver %s not register", driver->name); 1379 return -RT_ERROR; 1380 } 1381 1382 if (!rt_list_isempty(&sdio_cards)) 1383 { 1384 card = sdio_match_driver(driver->id); 1385 if (card != RT_NULL) 1386 { 1387 driver->remove(card); 1388 rt_list_remove(&sd->list); 1389 rt_free(sd); 1390 } 1391 } 1392 1393 return 0; 1394 } 1395 1396 void rt_sdio_init(void) 1397 { 1398 1399 } 1400 1401