1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver for Realtek PCI-Express card reader 4 * 5 * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved. 6 * 7 * Author: 8 * Wei WANG (wei_wang@realsil.com.cn) 9 * Micky Ching (micky_ching@realsil.com.cn) 10 */ 11 12 #include <linux/blkdev.h> 13 #include <linux/kthread.h> 14 #include <linux/sched.h> 15 #include <linux/vmalloc.h> 16 17 #include "rtsx.h" 18 #include "ms.h" 19 20 static inline void ms_set_err_code(struct rtsx_chip *chip, u8 err_code) 21 { 22 struct ms_info *ms_card = &chip->ms_card; 23 24 ms_card->err_code = err_code; 25 } 26 27 static inline int ms_check_err_code(struct rtsx_chip *chip, u8 err_code) 28 { 29 struct ms_info *ms_card = &chip->ms_card; 30 31 return (ms_card->err_code == err_code); 32 } 33 34 static int ms_parse_err_code(struct rtsx_chip *chip) 35 { 36 return STATUS_FAIL; 37 } 38 39 static int ms_transfer_tpc(struct rtsx_chip *chip, u8 trans_mode, 40 u8 tpc, u8 cnt, u8 cfg) 41 { 42 struct ms_info *ms_card = &chip->ms_card; 43 int retval; 44 u8 *ptr; 45 46 dev_dbg(rtsx_dev(chip), "%s: tpc = 0x%x\n", __func__, tpc); 47 48 rtsx_init_cmd(chip); 49 50 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, tpc); 51 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt); 52 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg); 53 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 54 0x01, PINGPONG_BUFFER); 55 56 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 57 0xFF, MS_TRANSFER_START | trans_mode); 58 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER, 59 MS_TRANSFER_END, MS_TRANSFER_END); 60 61 rtsx_add_cmd(chip, READ_REG_CMD, MS_TRANS_CFG, 0, 0); 62 63 retval = rtsx_send_cmd(chip, MS_CARD, 5000); 64 if (retval < 0) { 65 rtsx_clear_ms_error(chip); 66 ms_set_err_code(chip, MS_TO_ERROR); 67 return ms_parse_err_code(chip); 68 } 69 70 ptr = rtsx_get_cmd_data(chip) + 1; 71 72 if (!(tpc & 0x08)) { /* Read Packet */ 73 if (*ptr & MS_CRC16_ERR) { 74 ms_set_err_code(chip, MS_CRC16_ERROR); 75 return ms_parse_err_code(chip); 76 } 77 } else { /* Write Packet */ 78 if (CHK_MSPRO(ms_card) && !(*ptr & 0x80)) { 79 if (*ptr & (MS_INT_ERR | MS_INT_CMDNK)) { 80 ms_set_err_code(chip, MS_CMD_NK); 81 return ms_parse_err_code(chip); 82 } 83 } 84 } 85 86 if (*ptr & MS_RDY_TIMEOUT) { 87 rtsx_clear_ms_error(chip); 88 ms_set_err_code(chip, MS_TO_ERROR); 89 return ms_parse_err_code(chip); 90 } 91 92 return STATUS_SUCCESS; 93 } 94 95 static int ms_transfer_data(struct rtsx_chip *chip, u8 trans_mode, 96 u8 tpc, u16 sec_cnt, u8 cfg, bool mode_2k, 97 int use_sg, void *buf, int buf_len) 98 { 99 int retval; 100 u8 val, err_code = 0; 101 enum dma_data_direction dir; 102 103 if (!buf || !buf_len) 104 return STATUS_FAIL; 105 106 if (trans_mode == MS_TM_AUTO_READ) { 107 dir = DMA_FROM_DEVICE; 108 err_code = MS_FLASH_READ_ERROR; 109 } else if (trans_mode == MS_TM_AUTO_WRITE) { 110 dir = DMA_TO_DEVICE; 111 err_code = MS_FLASH_WRITE_ERROR; 112 } else { 113 return STATUS_FAIL; 114 } 115 116 rtsx_init_cmd(chip); 117 118 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, tpc); 119 rtsx_add_cmd(chip, WRITE_REG_CMD, 120 MS_SECTOR_CNT_H, 0xFF, (u8)(sec_cnt >> 8)); 121 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_SECTOR_CNT_L, 0xFF, (u8)sec_cnt); 122 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg); 123 124 if (mode_2k) { 125 rtsx_add_cmd(chip, WRITE_REG_CMD, 126 MS_CFG, MS_2K_SECTOR_MODE, MS_2K_SECTOR_MODE); 127 } else { 128 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_CFG, MS_2K_SECTOR_MODE, 0); 129 } 130 131 trans_dma_enable(dir, chip, sec_cnt * 512, DMA_512); 132 133 rtsx_add_cmd(chip, WRITE_REG_CMD, 134 MS_TRANSFER, 0xFF, MS_TRANSFER_START | trans_mode); 135 rtsx_add_cmd(chip, CHECK_REG_CMD, 136 MS_TRANSFER, MS_TRANSFER_END, MS_TRANSFER_END); 137 138 rtsx_send_cmd_no_wait(chip); 139 140 retval = rtsx_transfer_data(chip, MS_CARD, buf, buf_len, 141 use_sg, dir, chip->mspro_timeout); 142 if (retval < 0) { 143 ms_set_err_code(chip, err_code); 144 if (retval == -ETIMEDOUT) 145 retval = STATUS_TIMEDOUT; 146 else 147 retval = STATUS_FAIL; 148 149 return retval; 150 } 151 152 retval = rtsx_read_register(chip, MS_TRANS_CFG, &val); 153 if (retval) 154 return retval; 155 156 if (val & (MS_INT_CMDNK | MS_INT_ERR | MS_CRC16_ERR | MS_RDY_TIMEOUT)) 157 return STATUS_FAIL; 158 159 return STATUS_SUCCESS; 160 } 161 162 static int ms_write_bytes(struct rtsx_chip *chip, 163 u8 tpc, u8 cnt, u8 cfg, u8 *data, int data_len) 164 { 165 struct ms_info *ms_card = &chip->ms_card; 166 int retval, i; 167 168 if (!data || (data_len < cnt)) 169 return STATUS_ERROR; 170 171 rtsx_init_cmd(chip); 172 173 for (i = 0; i < cnt; i++) { 174 rtsx_add_cmd(chip, WRITE_REG_CMD, 175 PPBUF_BASE2 + i, 0xFF, data[i]); 176 } 177 if (cnt % 2) 178 rtsx_add_cmd(chip, WRITE_REG_CMD, PPBUF_BASE2 + i, 0xFF, 0xFF); 179 180 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, tpc); 181 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt); 182 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg); 183 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 184 0x01, PINGPONG_BUFFER); 185 186 rtsx_add_cmd(chip, WRITE_REG_CMD, 187 MS_TRANSFER, 0xFF, MS_TRANSFER_START | MS_TM_WRITE_BYTES); 188 rtsx_add_cmd(chip, CHECK_REG_CMD, 189 MS_TRANSFER, MS_TRANSFER_END, MS_TRANSFER_END); 190 191 retval = rtsx_send_cmd(chip, MS_CARD, 5000); 192 if (retval < 0) { 193 u8 val = 0; 194 195 rtsx_read_register(chip, MS_TRANS_CFG, &val); 196 dev_dbg(rtsx_dev(chip), "MS_TRANS_CFG: 0x%02x\n", val); 197 198 rtsx_clear_ms_error(chip); 199 200 if (!(tpc & 0x08)) { 201 if (val & MS_CRC16_ERR) { 202 ms_set_err_code(chip, MS_CRC16_ERROR); 203 return ms_parse_err_code(chip); 204 } 205 } else { 206 if (CHK_MSPRO(ms_card) && !(val & 0x80)) { 207 if (val & (MS_INT_ERR | MS_INT_CMDNK)) { 208 ms_set_err_code(chip, MS_CMD_NK); 209 return ms_parse_err_code(chip); 210 } 211 } 212 } 213 214 if (val & MS_RDY_TIMEOUT) { 215 ms_set_err_code(chip, MS_TO_ERROR); 216 return ms_parse_err_code(chip); 217 } 218 219 ms_set_err_code(chip, MS_TO_ERROR); 220 return ms_parse_err_code(chip); 221 } 222 223 return STATUS_SUCCESS; 224 } 225 226 static int ms_read_bytes(struct rtsx_chip *chip, 227 u8 tpc, u8 cnt, u8 cfg, u8 *data, int data_len) 228 { 229 struct ms_info *ms_card = &chip->ms_card; 230 int retval, i; 231 u8 *ptr; 232 233 if (!data) 234 return STATUS_ERROR; 235 236 rtsx_init_cmd(chip); 237 238 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, tpc); 239 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt); 240 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg); 241 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 242 0x01, PINGPONG_BUFFER); 243 244 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 0xFF, 245 MS_TRANSFER_START | MS_TM_READ_BYTES); 246 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER, 247 MS_TRANSFER_END, MS_TRANSFER_END); 248 249 for (i = 0; i < data_len - 1; i++) 250 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + i, 0, 0); 251 252 if (data_len % 2) 253 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + data_len, 0, 0); 254 else 255 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + data_len - 1, 256 0, 0); 257 258 retval = rtsx_send_cmd(chip, MS_CARD, 5000); 259 if (retval < 0) { 260 u8 val = 0; 261 262 rtsx_read_register(chip, MS_TRANS_CFG, &val); 263 rtsx_clear_ms_error(chip); 264 265 if (!(tpc & 0x08)) { 266 if (val & MS_CRC16_ERR) { 267 ms_set_err_code(chip, MS_CRC16_ERROR); 268 return ms_parse_err_code(chip); 269 } 270 } else { 271 if (CHK_MSPRO(ms_card) && !(val & 0x80)) { 272 if (val & (MS_INT_ERR | MS_INT_CMDNK)) { 273 ms_set_err_code(chip, MS_CMD_NK); 274 return ms_parse_err_code(chip); 275 } 276 } 277 } 278 279 if (val & MS_RDY_TIMEOUT) { 280 ms_set_err_code(chip, MS_TO_ERROR); 281 return ms_parse_err_code(chip); 282 } 283 284 ms_set_err_code(chip, MS_TO_ERROR); 285 return ms_parse_err_code(chip); 286 } 287 288 ptr = rtsx_get_cmd_data(chip) + 1; 289 290 for (i = 0; i < data_len; i++) 291 data[i] = ptr[i]; 292 293 if ((tpc == PRO_READ_SHORT_DATA) && (data_len == 8)) { 294 dev_dbg(rtsx_dev(chip), "Read format progress:\n"); 295 print_hex_dump_bytes(KBUILD_MODNAME ": ", DUMP_PREFIX_NONE, ptr, 296 cnt); 297 } 298 299 return STATUS_SUCCESS; 300 } 301 302 static int ms_set_rw_reg_addr(struct rtsx_chip *chip, u8 read_start, 303 u8 read_cnt, u8 write_start, u8 write_cnt) 304 { 305 int retval, i; 306 u8 data[4]; 307 308 data[0] = read_start; 309 data[1] = read_cnt; 310 data[2] = write_start; 311 data[3] = write_cnt; 312 313 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 314 retval = ms_write_bytes(chip, SET_RW_REG_ADRS, 4, 315 NO_WAIT_INT, data, 4); 316 if (retval == STATUS_SUCCESS) 317 return STATUS_SUCCESS; 318 rtsx_clear_ms_error(chip); 319 } 320 321 return STATUS_FAIL; 322 } 323 324 static int ms_send_cmd(struct rtsx_chip *chip, u8 cmd, u8 cfg) 325 { 326 u8 data[2]; 327 328 data[0] = cmd; 329 data[1] = 0; 330 331 return ms_write_bytes(chip, PRO_SET_CMD, 1, cfg, data, 1); 332 } 333 334 static int ms_set_init_para(struct rtsx_chip *chip) 335 { 336 struct ms_info *ms_card = &chip->ms_card; 337 int retval; 338 339 if (CHK_HG8BIT(ms_card)) { 340 if (chip->asic_code) 341 ms_card->ms_clock = chip->asic_ms_hg_clk; 342 else 343 ms_card->ms_clock = chip->fpga_ms_hg_clk; 344 345 } else if (CHK_MSPRO(ms_card) || CHK_MS4BIT(ms_card)) { 346 if (chip->asic_code) 347 ms_card->ms_clock = chip->asic_ms_4bit_clk; 348 else 349 ms_card->ms_clock = chip->fpga_ms_4bit_clk; 350 351 } else { 352 if (chip->asic_code) 353 ms_card->ms_clock = chip->asic_ms_1bit_clk; 354 else 355 ms_card->ms_clock = chip->fpga_ms_1bit_clk; 356 } 357 358 retval = switch_clock(chip, ms_card->ms_clock); 359 if (retval != STATUS_SUCCESS) 360 return STATUS_FAIL; 361 362 retval = select_card(chip, MS_CARD); 363 if (retval != STATUS_SUCCESS) 364 return STATUS_FAIL; 365 366 return STATUS_SUCCESS; 367 } 368 369 static int ms_switch_clock(struct rtsx_chip *chip) 370 { 371 struct ms_info *ms_card = &chip->ms_card; 372 int retval; 373 374 retval = select_card(chip, MS_CARD); 375 if (retval != STATUS_SUCCESS) 376 return STATUS_FAIL; 377 378 retval = switch_clock(chip, ms_card->ms_clock); 379 if (retval != STATUS_SUCCESS) 380 return STATUS_FAIL; 381 382 return STATUS_SUCCESS; 383 } 384 385 static int ms_pull_ctl_disable(struct rtsx_chip *chip) 386 { 387 int retval; 388 389 if (CHECK_PID(chip, 0x5208)) { 390 retval = rtsx_write_register(chip, CARD_PULL_CTL1, 0xFF, 391 MS_D1_PD | MS_D2_PD | MS_CLK_PD | 392 MS_D6_PD); 393 if (retval) 394 return retval; 395 396 retval = rtsx_write_register(chip, CARD_PULL_CTL2, 0xFF, 397 MS_D3_PD | MS_D0_PD | MS_BS_PD | 398 XD_D4_PD); 399 if (retval) 400 return retval; 401 402 retval = rtsx_write_register(chip, CARD_PULL_CTL3, 0xFF, 403 MS_D7_PD | XD_CE_PD | XD_CLE_PD | 404 XD_CD_PU); 405 if (retval) 406 return retval; 407 408 retval = rtsx_write_register(chip, CARD_PULL_CTL4, 0xFF, 409 XD_RDY_PD | SD_D3_PD | SD_D2_PD | 410 XD_ALE_PD); 411 if (retval) 412 return retval; 413 414 retval = rtsx_write_register(chip, CARD_PULL_CTL5, 0xFF, 415 MS_INS_PU | SD_WP_PD | SD_CD_PU | 416 SD_CMD_PD); 417 if (retval) 418 return retval; 419 420 retval = rtsx_write_register(chip, CARD_PULL_CTL6, 0xFF, 421 MS_D5_PD | MS_D4_PD); 422 if (retval) 423 return retval; 424 425 } else if (CHECK_PID(chip, 0x5288)) { 426 if (CHECK_BARO_PKG(chip, QFN)) { 427 retval = rtsx_write_register(chip, CARD_PULL_CTL1, 428 0xFF, 0x55); 429 if (retval) 430 return retval; 431 432 retval = rtsx_write_register(chip, CARD_PULL_CTL2, 433 0xFF, 0x55); 434 if (retval) 435 return retval; 436 437 retval = rtsx_write_register(chip, CARD_PULL_CTL3, 438 0xFF, 0x4B); 439 if (retval) 440 return retval; 441 442 retval = rtsx_write_register(chip, CARD_PULL_CTL4, 443 0xFF, 0x69); 444 if (retval) 445 return retval; 446 } 447 } 448 449 return STATUS_SUCCESS; 450 } 451 452 static int ms_pull_ctl_enable(struct rtsx_chip *chip) 453 { 454 int retval; 455 456 rtsx_init_cmd(chip); 457 458 if (CHECK_PID(chip, 0x5208)) { 459 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 460 MS_D1_PD | MS_D2_PD | MS_CLK_NP | MS_D6_PD); 461 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 462 MS_D3_PD | MS_D0_PD | MS_BS_NP | XD_D4_PD); 463 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 464 MS_D7_PD | XD_CE_PD | XD_CLE_PD | XD_CD_PU); 465 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 466 XD_RDY_PD | SD_D3_PD | SD_D2_PD | XD_ALE_PD); 467 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 468 MS_INS_PU | SD_WP_PD | SD_CD_PU | SD_CMD_PD); 469 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 470 MS_D5_PD | MS_D4_PD); 471 } else if (CHECK_PID(chip, 0x5288)) { 472 if (CHECK_BARO_PKG(chip, QFN)) { 473 rtsx_add_cmd(chip, WRITE_REG_CMD, 474 CARD_PULL_CTL1, 0xFF, 0x55); 475 rtsx_add_cmd(chip, WRITE_REG_CMD, 476 CARD_PULL_CTL2, 0xFF, 0x45); 477 rtsx_add_cmd(chip, WRITE_REG_CMD, 478 CARD_PULL_CTL3, 0xFF, 0x4B); 479 rtsx_add_cmd(chip, WRITE_REG_CMD, 480 CARD_PULL_CTL4, 0xFF, 0x29); 481 } 482 } 483 484 retval = rtsx_send_cmd(chip, MS_CARD, 100); 485 if (retval < 0) 486 return STATUS_FAIL; 487 488 return STATUS_SUCCESS; 489 } 490 491 static int ms_prepare_reset(struct rtsx_chip *chip) 492 { 493 struct ms_info *ms_card = &chip->ms_card; 494 int retval; 495 u8 oc_mask = 0; 496 497 ms_card->ms_type = 0; 498 ms_card->check_ms_flow = 0; 499 ms_card->switch_8bit_fail = 0; 500 ms_card->delay_write.delay_write_flag = 0; 501 502 ms_card->pro_under_formatting = 0; 503 504 retval = ms_power_off_card3v3(chip); 505 if (retval != STATUS_SUCCESS) 506 return STATUS_FAIL; 507 508 if (!chip->ft2_fast_mode) 509 wait_timeout(250); 510 511 retval = enable_card_clock(chip, MS_CARD); 512 if (retval != STATUS_SUCCESS) 513 return STATUS_FAIL; 514 515 if (chip->asic_code) { 516 retval = ms_pull_ctl_enable(chip); 517 if (retval != STATUS_SUCCESS) 518 return STATUS_FAIL; 519 } else { 520 retval = rtsx_write_register(chip, FPGA_PULL_CTL, 521 FPGA_MS_PULL_CTL_BIT | 0x20, 0); 522 if (retval) 523 return retval; 524 } 525 526 if (!chip->ft2_fast_mode) { 527 retval = card_power_on(chip, MS_CARD); 528 if (retval != STATUS_SUCCESS) 529 return STATUS_FAIL; 530 531 wait_timeout(150); 532 533 #ifdef SUPPORT_OCP 534 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) 535 oc_mask = MS_OC_NOW | MS_OC_EVER; 536 else 537 oc_mask = SD_OC_NOW | SD_OC_EVER; 538 539 if (chip->ocp_stat & oc_mask) { 540 dev_dbg(rtsx_dev(chip), "Over current, OCPSTAT is 0x%x\n", 541 chip->ocp_stat); 542 return STATUS_FAIL; 543 } 544 #endif 545 } 546 547 retval = rtsx_write_register(chip, CARD_OE, MS_OUTPUT_EN, 548 MS_OUTPUT_EN); 549 if (retval) 550 return retval; 551 552 if (chip->asic_code) { 553 retval = rtsx_write_register(chip, MS_CFG, 0xFF, 554 SAMPLE_TIME_RISING | 555 PUSH_TIME_DEFAULT | 556 NO_EXTEND_TOGGLE | 557 MS_BUS_WIDTH_1); 558 if (retval) 559 return retval; 560 561 } else { 562 retval = rtsx_write_register(chip, MS_CFG, 0xFF, 563 SAMPLE_TIME_FALLING | 564 PUSH_TIME_DEFAULT | 565 NO_EXTEND_TOGGLE | 566 MS_BUS_WIDTH_1); 567 if (retval) 568 return retval; 569 } 570 retval = rtsx_write_register(chip, MS_TRANS_CFG, 0xFF, 571 NO_WAIT_INT | NO_AUTO_READ_INT_REG); 572 if (retval) 573 return retval; 574 575 retval = rtsx_write_register(chip, CARD_STOP, MS_STOP | MS_CLR_ERR, 576 MS_STOP | MS_CLR_ERR); 577 if (retval) 578 return retval; 579 580 retval = ms_set_init_para(chip); 581 if (retval != STATUS_SUCCESS) 582 return STATUS_FAIL; 583 584 return STATUS_SUCCESS; 585 } 586 587 static int ms_identify_media_type(struct rtsx_chip *chip, int switch_8bit_bus) 588 { 589 struct ms_info *ms_card = &chip->ms_card; 590 int retval, i; 591 u8 val; 592 593 retval = ms_set_rw_reg_addr(chip, PRO_STATUS_REG, 6, SYSTEM_PARAM, 1); 594 if (retval != STATUS_SUCCESS) 595 return STATUS_FAIL; 596 597 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 598 retval = ms_transfer_tpc(chip, MS_TM_READ_BYTES, READ_REG, 599 6, NO_WAIT_INT); 600 if (retval == STATUS_SUCCESS) 601 break; 602 } 603 if (i == MS_MAX_RETRY_COUNT) 604 return STATUS_FAIL; 605 606 retval = rtsx_read_register(chip, PPBUF_BASE2 + 2, &val); 607 if (retval) 608 return retval; 609 610 dev_dbg(rtsx_dev(chip), "Type register: 0x%x\n", val); 611 if (val != 0x01) { 612 if (val != 0x02) 613 ms_card->check_ms_flow = 1; 614 615 return STATUS_FAIL; 616 } 617 618 retval = rtsx_read_register(chip, PPBUF_BASE2 + 4, &val); 619 if (retval) 620 return retval; 621 622 dev_dbg(rtsx_dev(chip), "Category register: 0x%x\n", val); 623 if (val != 0) { 624 ms_card->check_ms_flow = 1; 625 return STATUS_FAIL; 626 } 627 628 retval = rtsx_read_register(chip, PPBUF_BASE2 + 5, &val); 629 if (retval) 630 return retval; 631 632 dev_dbg(rtsx_dev(chip), "Class register: 0x%x\n", val); 633 if (val == 0) { 634 retval = rtsx_read_register(chip, PPBUF_BASE2, &val); 635 if (retval) 636 return retval; 637 638 if (val & WRT_PRTCT) 639 chip->card_wp |= MS_CARD; 640 else 641 chip->card_wp &= ~MS_CARD; 642 643 } else if ((val == 0x01) || (val == 0x02) || (val == 0x03)) { 644 chip->card_wp |= MS_CARD; 645 } else { 646 ms_card->check_ms_flow = 1; 647 return STATUS_FAIL; 648 } 649 650 ms_card->ms_type |= TYPE_MSPRO; 651 652 retval = rtsx_read_register(chip, PPBUF_BASE2 + 3, &val); 653 if (retval) 654 return retval; 655 656 dev_dbg(rtsx_dev(chip), "IF Mode register: 0x%x\n", val); 657 if (val == 0) { 658 ms_card->ms_type &= 0x0F; 659 } else if (val == 7) { 660 if (switch_8bit_bus) 661 ms_card->ms_type |= MS_HG; 662 else 663 ms_card->ms_type &= 0x0F; 664 665 } else { 666 return STATUS_FAIL; 667 } 668 669 return STATUS_SUCCESS; 670 } 671 672 static int ms_confirm_cpu_startup(struct rtsx_chip *chip) 673 { 674 int retval, i, k; 675 u8 val; 676 677 /* Confirm CPU StartUp */ 678 k = 0; 679 do { 680 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 681 ms_set_err_code(chip, MS_NO_CARD); 682 return STATUS_FAIL; 683 } 684 685 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 686 retval = ms_read_bytes(chip, GET_INT, 1, 687 NO_WAIT_INT, &val, 1); 688 if (retval == STATUS_SUCCESS) 689 break; 690 } 691 if (i == MS_MAX_RETRY_COUNT) 692 return STATUS_FAIL; 693 694 if (k > 100) 695 return STATUS_FAIL; 696 697 k++; 698 wait_timeout(100); 699 } while (!(val & INT_REG_CED)); 700 701 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 702 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 703 if (retval == STATUS_SUCCESS) 704 break; 705 } 706 if (i == MS_MAX_RETRY_COUNT) 707 return STATUS_FAIL; 708 709 if (val & INT_REG_ERR) { 710 if (val & INT_REG_CMDNK) 711 chip->card_wp |= (MS_CARD); 712 else 713 return STATUS_FAIL; 714 } 715 /* -- end confirm CPU startup */ 716 717 return STATUS_SUCCESS; 718 } 719 720 static int ms_switch_parallel_bus(struct rtsx_chip *chip) 721 { 722 int retval, i; 723 u8 data[2]; 724 725 data[0] = PARALLEL_4BIT_IF; 726 data[1] = 0; 727 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 728 retval = ms_write_bytes(chip, WRITE_REG, 1, NO_WAIT_INT, 729 data, 2); 730 if (retval == STATUS_SUCCESS) 731 break; 732 } 733 if (retval != STATUS_SUCCESS) 734 return STATUS_FAIL; 735 736 return STATUS_SUCCESS; 737 } 738 739 static int ms_switch_8bit_bus(struct rtsx_chip *chip) 740 { 741 struct ms_info *ms_card = &chip->ms_card; 742 int retval, i; 743 u8 data[2]; 744 745 data[0] = PARALLEL_8BIT_IF; 746 data[1] = 0; 747 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 748 retval = ms_write_bytes(chip, WRITE_REG, 1, 749 NO_WAIT_INT, data, 2); 750 if (retval == STATUS_SUCCESS) 751 break; 752 } 753 if (retval != STATUS_SUCCESS) 754 return STATUS_FAIL; 755 756 retval = rtsx_write_register(chip, MS_CFG, 0x98, 757 MS_BUS_WIDTH_8 | SAMPLE_TIME_FALLING); 758 if (retval) 759 return retval; 760 761 ms_card->ms_type |= MS_8BIT; 762 retval = ms_set_init_para(chip); 763 if (retval != STATUS_SUCCESS) 764 return STATUS_FAIL; 765 766 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 767 retval = ms_transfer_tpc(chip, MS_TM_READ_BYTES, GET_INT, 768 1, NO_WAIT_INT); 769 if (retval != STATUS_SUCCESS) 770 return STATUS_FAIL; 771 } 772 773 return STATUS_SUCCESS; 774 } 775 776 static int ms_pro_reset_flow(struct rtsx_chip *chip, int switch_8bit_bus) 777 { 778 struct ms_info *ms_card = &chip->ms_card; 779 int retval, i; 780 781 for (i = 0; i < 3; i++) { 782 retval = ms_prepare_reset(chip); 783 if (retval != STATUS_SUCCESS) 784 return STATUS_FAIL; 785 786 retval = ms_identify_media_type(chip, switch_8bit_bus); 787 if (retval != STATUS_SUCCESS) 788 return STATUS_FAIL; 789 790 retval = ms_confirm_cpu_startup(chip); 791 if (retval != STATUS_SUCCESS) 792 return STATUS_FAIL; 793 794 retval = ms_switch_parallel_bus(chip); 795 if (retval != STATUS_SUCCESS) { 796 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 797 ms_set_err_code(chip, MS_NO_CARD); 798 return STATUS_FAIL; 799 } 800 continue; 801 } else { 802 break; 803 } 804 } 805 806 if (retval != STATUS_SUCCESS) 807 return STATUS_FAIL; 808 809 /* Switch MS-PRO into Parallel mode */ 810 retval = rtsx_write_register(chip, MS_CFG, 0x18, MS_BUS_WIDTH_4); 811 if (retval) 812 return retval; 813 814 retval = rtsx_write_register(chip, MS_CFG, PUSH_TIME_ODD, 815 PUSH_TIME_ODD); 816 if (retval) 817 return retval; 818 819 retval = ms_set_init_para(chip); 820 if (retval != STATUS_SUCCESS) 821 return STATUS_FAIL; 822 823 /* If MSPro HG Card, We shall try to switch to 8-bit bus */ 824 if (CHK_MSHG(ms_card) && chip->support_ms_8bit && switch_8bit_bus) { 825 retval = ms_switch_8bit_bus(chip); 826 if (retval != STATUS_SUCCESS) { 827 ms_card->switch_8bit_fail = 1; 828 return STATUS_FAIL; 829 } 830 } 831 832 return STATUS_SUCCESS; 833 } 834 835 #ifdef XC_POWERCLASS 836 static int msxc_change_power(struct rtsx_chip *chip, u8 mode) 837 { 838 int retval; 839 u8 buf[6]; 840 841 ms_cleanup_work(chip); 842 843 retval = ms_set_rw_reg_addr(chip, 0, 0, PRO_DATA_COUNT1, 6); 844 if (retval != STATUS_SUCCESS) 845 return STATUS_FAIL; 846 847 buf[0] = 0; 848 buf[1] = mode; 849 buf[2] = 0; 850 buf[3] = 0; 851 buf[4] = 0; 852 buf[5] = 0; 853 854 retval = ms_write_bytes(chip, PRO_WRITE_REG, 6, NO_WAIT_INT, buf, 6); 855 if (retval != STATUS_SUCCESS) 856 return STATUS_FAIL; 857 858 retval = ms_send_cmd(chip, XC_CHG_POWER, WAIT_INT); 859 if (retval != STATUS_SUCCESS) 860 return STATUS_FAIL; 861 862 retval = rtsx_read_register(chip, MS_TRANS_CFG, buf); 863 if (retval) 864 return retval; 865 866 if (buf[0] & (MS_INT_CMDNK | MS_INT_ERR)) 867 return STATUS_FAIL; 868 869 return STATUS_SUCCESS; 870 } 871 #endif 872 873 static int ms_read_attribute_info(struct rtsx_chip *chip) 874 { 875 struct ms_info *ms_card = &chip->ms_card; 876 int retval, i; 877 u8 val, *buf, class_code, device_type, sub_class, data[16]; 878 u16 total_blk = 0, blk_size = 0; 879 #ifdef SUPPORT_MSXC 880 u32 xc_total_blk = 0, xc_blk_size = 0; 881 #endif 882 u32 sys_info_addr = 0, sys_info_size; 883 #ifdef SUPPORT_PCGL_1P18 884 u32 model_name_addr = 0, model_name_size; 885 int found_sys_info = 0, found_model_name = 0; 886 #endif 887 888 retval = ms_set_rw_reg_addr(chip, PRO_INT_REG, 2, PRO_SYSTEM_PARAM, 7); 889 if (retval != STATUS_SUCCESS) 890 return STATUS_FAIL; 891 892 if (CHK_MS8BIT(ms_card)) 893 data[0] = PARALLEL_8BIT_IF; 894 else 895 data[0] = PARALLEL_4BIT_IF; 896 897 data[1] = 0; 898 899 data[2] = 0x40; 900 data[3] = 0; 901 data[4] = 0; 902 data[5] = 0; 903 data[6] = 0; 904 data[7] = 0; 905 906 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 907 retval = ms_write_bytes(chip, PRO_WRITE_REG, 7, NO_WAIT_INT, 908 data, 8); 909 if (retval == STATUS_SUCCESS) 910 break; 911 } 912 if (retval != STATUS_SUCCESS) 913 return STATUS_FAIL; 914 915 buf = kmalloc(64 * 512, GFP_KERNEL); 916 if (!buf) 917 return STATUS_ERROR; 918 919 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 920 retval = ms_send_cmd(chip, PRO_READ_ATRB, WAIT_INT); 921 if (retval != STATUS_SUCCESS) 922 continue; 923 924 retval = rtsx_read_register(chip, MS_TRANS_CFG, &val); 925 if (retval != STATUS_SUCCESS) { 926 kfree(buf); 927 return STATUS_FAIL; 928 } 929 if (!(val & MS_INT_BREQ)) { 930 kfree(buf); 931 return STATUS_FAIL; 932 } 933 retval = ms_transfer_data(chip, MS_TM_AUTO_READ, 934 PRO_READ_LONG_DATA, 0x40, WAIT_INT, 935 0, 0, buf, 64 * 512); 936 if (retval == STATUS_SUCCESS) 937 break; 938 939 rtsx_clear_ms_error(chip); 940 } 941 if (retval != STATUS_SUCCESS) { 942 kfree(buf); 943 return STATUS_FAIL; 944 } 945 946 i = 0; 947 do { 948 retval = rtsx_read_register(chip, MS_TRANS_CFG, &val); 949 if (retval != STATUS_SUCCESS) { 950 kfree(buf); 951 return STATUS_FAIL; 952 } 953 954 if ((val & MS_INT_CED) || !(val & MS_INT_BREQ)) 955 break; 956 957 retval = ms_transfer_tpc(chip, MS_TM_NORMAL_READ, 958 PRO_READ_LONG_DATA, 0, WAIT_INT); 959 if (retval != STATUS_SUCCESS) { 960 kfree(buf); 961 return STATUS_FAIL; 962 } 963 964 i++; 965 } while (i < 1024); 966 967 if ((buf[0] != 0xa5) && (buf[1] != 0xc3)) { 968 /* Signature code is wrong */ 969 kfree(buf); 970 return STATUS_FAIL; 971 } 972 973 if ((buf[4] < 1) || (buf[4] > 12)) { 974 kfree(buf); 975 return STATUS_FAIL; 976 } 977 978 for (i = 0; i < buf[4]; i++) { 979 int cur_addr_off = 16 + i * 12; 980 981 #ifdef SUPPORT_MSXC 982 if ((buf[cur_addr_off + 8] == 0x10) || 983 (buf[cur_addr_off + 8] == 0x13)) { 984 #else 985 if (buf[cur_addr_off + 8] == 0x10) { 986 #endif 987 sys_info_addr = ((u32)buf[cur_addr_off + 0] << 24) | 988 ((u32)buf[cur_addr_off + 1] << 16) | 989 ((u32)buf[cur_addr_off + 2] << 8) | 990 buf[cur_addr_off + 3]; 991 sys_info_size = ((u32)buf[cur_addr_off + 4] << 24) | 992 ((u32)buf[cur_addr_off + 5] << 16) | 993 ((u32)buf[cur_addr_off + 6] << 8) | 994 buf[cur_addr_off + 7]; 995 dev_dbg(rtsx_dev(chip), "sys_info_addr = 0x%x, sys_info_size = 0x%x\n", 996 sys_info_addr, sys_info_size); 997 if (sys_info_size != 96) { 998 kfree(buf); 999 return STATUS_FAIL; 1000 } 1001 if (sys_info_addr < 0x1A0) { 1002 kfree(buf); 1003 return STATUS_FAIL; 1004 } 1005 if ((sys_info_size + sys_info_addr) > 0x8000) { 1006 kfree(buf); 1007 return STATUS_FAIL; 1008 } 1009 1010 #ifdef SUPPORT_MSXC 1011 if (buf[cur_addr_off + 8] == 0x13) 1012 ms_card->ms_type |= MS_XC; 1013 #endif 1014 #ifdef SUPPORT_PCGL_1P18 1015 found_sys_info = 1; 1016 #else 1017 break; 1018 #endif 1019 } 1020 #ifdef SUPPORT_PCGL_1P18 1021 if (buf[cur_addr_off + 8] == 0x15) { 1022 model_name_addr = ((u32)buf[cur_addr_off + 0] << 24) | 1023 ((u32)buf[cur_addr_off + 1] << 16) | 1024 ((u32)buf[cur_addr_off + 2] << 8) | 1025 buf[cur_addr_off + 3]; 1026 model_name_size = ((u32)buf[cur_addr_off + 4] << 24) | 1027 ((u32)buf[cur_addr_off + 5] << 16) | 1028 ((u32)buf[cur_addr_off + 6] << 8) | 1029 buf[cur_addr_off + 7]; 1030 dev_dbg(rtsx_dev(chip), "model_name_addr = 0x%x, model_name_size = 0x%x\n", 1031 model_name_addr, model_name_size); 1032 if (model_name_size != 48) { 1033 kfree(buf); 1034 return STATUS_FAIL; 1035 } 1036 if (model_name_addr < 0x1A0) { 1037 kfree(buf); 1038 return STATUS_FAIL; 1039 } 1040 if ((model_name_size + model_name_addr) > 0x8000) { 1041 kfree(buf); 1042 return STATUS_FAIL; 1043 } 1044 1045 found_model_name = 1; 1046 } 1047 1048 if (found_sys_info && found_model_name) 1049 break; 1050 #endif 1051 } 1052 1053 if (i == buf[4]) { 1054 kfree(buf); 1055 return STATUS_FAIL; 1056 } 1057 1058 class_code = buf[sys_info_addr + 0]; 1059 device_type = buf[sys_info_addr + 56]; 1060 sub_class = buf[sys_info_addr + 46]; 1061 #ifdef SUPPORT_MSXC 1062 if (CHK_MSXC(ms_card)) { 1063 xc_total_blk = ((u32)buf[sys_info_addr + 6] << 24) | 1064 ((u32)buf[sys_info_addr + 7] << 16) | 1065 ((u32)buf[sys_info_addr + 8] << 8) | 1066 buf[sys_info_addr + 9]; 1067 xc_blk_size = ((u32)buf[sys_info_addr + 32] << 24) | 1068 ((u32)buf[sys_info_addr + 33] << 16) | 1069 ((u32)buf[sys_info_addr + 34] << 8) | 1070 buf[sys_info_addr + 35]; 1071 dev_dbg(rtsx_dev(chip), "xc_total_blk = 0x%x, xc_blk_size = 0x%x\n", 1072 xc_total_blk, xc_blk_size); 1073 } else { 1074 total_blk = ((u16)buf[sys_info_addr + 6] << 8) | 1075 buf[sys_info_addr + 7]; 1076 blk_size = ((u16)buf[sys_info_addr + 2] << 8) | 1077 buf[sys_info_addr + 3]; 1078 dev_dbg(rtsx_dev(chip), "total_blk = 0x%x, blk_size = 0x%x\n", 1079 total_blk, blk_size); 1080 } 1081 #else 1082 total_blk = ((u16)buf[sys_info_addr + 6] << 8) | buf[sys_info_addr + 7]; 1083 blk_size = ((u16)buf[sys_info_addr + 2] << 8) | buf[sys_info_addr + 3]; 1084 dev_dbg(rtsx_dev(chip), "total_blk = 0x%x, blk_size = 0x%x\n", 1085 total_blk, blk_size); 1086 #endif 1087 1088 dev_dbg(rtsx_dev(chip), "class_code = 0x%x, device_type = 0x%x, sub_class = 0x%x\n", 1089 class_code, device_type, sub_class); 1090 1091 memcpy(ms_card->raw_sys_info, buf + sys_info_addr, 96); 1092 #ifdef SUPPORT_PCGL_1P18 1093 memcpy(ms_card->raw_model_name, buf + model_name_addr, 48); 1094 #endif 1095 1096 kfree(buf); 1097 1098 #ifdef SUPPORT_MSXC 1099 if (CHK_MSXC(ms_card)) { 1100 if (class_code != 0x03) 1101 return STATUS_FAIL; 1102 } else { 1103 if (class_code != 0x02) 1104 return STATUS_FAIL; 1105 } 1106 #else 1107 if (class_code != 0x02) 1108 return STATUS_FAIL; 1109 #endif 1110 1111 if (device_type != 0x00) { 1112 if ((device_type == 0x01) || (device_type == 0x02) || 1113 (device_type == 0x03)) { 1114 chip->card_wp |= MS_CARD; 1115 } else { 1116 return STATUS_FAIL; 1117 } 1118 } 1119 1120 if (sub_class & 0xC0) 1121 return STATUS_FAIL; 1122 1123 dev_dbg(rtsx_dev(chip), "class_code: 0x%x, device_type: 0x%x, sub_class: 0x%x\n", 1124 class_code, device_type, sub_class); 1125 1126 #ifdef SUPPORT_MSXC 1127 if (CHK_MSXC(ms_card)) { 1128 chip->capacity[chip->card2lun[MS_CARD]] = 1129 ms_card->capacity = xc_total_blk * xc_blk_size; 1130 } else { 1131 chip->capacity[chip->card2lun[MS_CARD]] = 1132 ms_card->capacity = total_blk * blk_size; 1133 } 1134 #else 1135 ms_card->capacity = total_blk * blk_size; 1136 chip->capacity[chip->card2lun[MS_CARD]] = ms_card->capacity; 1137 #endif 1138 1139 return STATUS_SUCCESS; 1140 } 1141 1142 #ifdef SUPPORT_MAGIC_GATE 1143 static int mg_set_tpc_para_sub(struct rtsx_chip *chip, 1144 int type, u8 mg_entry_num); 1145 #endif 1146 1147 static int reset_ms_pro(struct rtsx_chip *chip) 1148 { 1149 struct ms_info *ms_card = &chip->ms_card; 1150 int retval; 1151 #ifdef XC_POWERCLASS 1152 u8 change_power_class; 1153 1154 if (chip->ms_power_class_en & 0x02) 1155 change_power_class = 2; 1156 else if (chip->ms_power_class_en & 0x01) 1157 change_power_class = 1; 1158 else 1159 change_power_class = 0; 1160 #endif 1161 1162 #ifdef XC_POWERCLASS 1163 retry: 1164 #endif 1165 retval = ms_pro_reset_flow(chip, 1); 1166 if (retval != STATUS_SUCCESS) { 1167 if (ms_card->switch_8bit_fail) { 1168 retval = ms_pro_reset_flow(chip, 0); 1169 if (retval != STATUS_SUCCESS) 1170 return STATUS_FAIL; 1171 } else { 1172 return STATUS_FAIL; 1173 } 1174 } 1175 1176 retval = ms_read_attribute_info(chip); 1177 if (retval != STATUS_SUCCESS) 1178 return STATUS_FAIL; 1179 1180 #ifdef XC_POWERCLASS 1181 if (CHK_HG8BIT(ms_card)) 1182 change_power_class = 0; 1183 1184 if (change_power_class && CHK_MSXC(ms_card)) { 1185 u8 power_class_en = chip->ms_power_class_en; 1186 1187 dev_dbg(rtsx_dev(chip), "power_class_en = 0x%x\n", 1188 power_class_en); 1189 dev_dbg(rtsx_dev(chip), "change_power_class = %d\n", 1190 change_power_class); 1191 1192 if (change_power_class) 1193 power_class_en &= (1 << (change_power_class - 1)); 1194 else 1195 power_class_en = 0; 1196 1197 if (power_class_en) { 1198 u8 power_class_mode = 1199 (ms_card->raw_sys_info[46] & 0x18) >> 3; 1200 dev_dbg(rtsx_dev(chip), "power_class_mode = 0x%x", 1201 power_class_mode); 1202 if (change_power_class > power_class_mode) 1203 change_power_class = power_class_mode; 1204 if (change_power_class) { 1205 retval = msxc_change_power(chip, 1206 change_power_class); 1207 if (retval != STATUS_SUCCESS) { 1208 change_power_class--; 1209 goto retry; 1210 } 1211 } 1212 } 1213 } 1214 #endif 1215 1216 #ifdef SUPPORT_MAGIC_GATE 1217 retval = mg_set_tpc_para_sub(chip, 0, 0); 1218 if (retval != STATUS_SUCCESS) 1219 return STATUS_FAIL; 1220 #endif 1221 1222 if (CHK_HG8BIT(ms_card)) 1223 chip->card_bus_width[chip->card2lun[MS_CARD]] = 8; 1224 else 1225 chip->card_bus_width[chip->card2lun[MS_CARD]] = 4; 1226 1227 return STATUS_SUCCESS; 1228 } 1229 1230 static int ms_read_status_reg(struct rtsx_chip *chip) 1231 { 1232 int retval; 1233 u8 val[2]; 1234 1235 retval = ms_set_rw_reg_addr(chip, STATUS_REG0, 2, 0, 0); 1236 if (retval != STATUS_SUCCESS) 1237 return STATUS_FAIL; 1238 1239 retval = ms_read_bytes(chip, READ_REG, 2, NO_WAIT_INT, val, 2); 1240 if (retval != STATUS_SUCCESS) 1241 return STATUS_FAIL; 1242 1243 if (val[1] & (STS_UCDT | STS_UCEX | STS_UCFG)) { 1244 ms_set_err_code(chip, MS_FLASH_READ_ERROR); 1245 return STATUS_FAIL; 1246 } 1247 1248 return STATUS_SUCCESS; 1249 } 1250 1251 static int ms_read_extra_data(struct rtsx_chip *chip, 1252 u16 block_addr, u8 page_num, u8 *buf, int buf_len) 1253 { 1254 struct ms_info *ms_card = &chip->ms_card; 1255 int retval, i; 1256 u8 val, data[10]; 1257 1258 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 1259 SYSTEM_PARAM, 6); 1260 if (retval != STATUS_SUCCESS) 1261 return STATUS_FAIL; 1262 1263 if (CHK_MS4BIT(ms_card)) { 1264 /* Parallel interface */ 1265 data[0] = 0x88; 1266 } else { 1267 /* Serial interface */ 1268 data[0] = 0x80; 1269 } 1270 data[1] = 0; 1271 data[2] = (u8)(block_addr >> 8); 1272 data[3] = (u8)block_addr; 1273 data[4] = 0x40; 1274 data[5] = page_num; 1275 1276 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 1277 retval = ms_write_bytes(chip, WRITE_REG, 6, NO_WAIT_INT, 1278 data, 6); 1279 if (retval == STATUS_SUCCESS) 1280 break; 1281 } 1282 if (i == MS_MAX_RETRY_COUNT) 1283 return STATUS_FAIL; 1284 1285 ms_set_err_code(chip, MS_NO_ERROR); 1286 1287 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 1288 retval = ms_send_cmd(chip, BLOCK_READ, WAIT_INT); 1289 if (retval == STATUS_SUCCESS) 1290 break; 1291 } 1292 if (i == MS_MAX_RETRY_COUNT) 1293 return STATUS_FAIL; 1294 1295 ms_set_err_code(chip, MS_NO_ERROR); 1296 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 1297 if (retval != STATUS_SUCCESS) 1298 return STATUS_FAIL; 1299 1300 if (val & INT_REG_CMDNK) { 1301 ms_set_err_code(chip, MS_CMD_NK); 1302 return STATUS_FAIL; 1303 } 1304 if (val & INT_REG_CED) { 1305 if (val & INT_REG_ERR) { 1306 retval = ms_read_status_reg(chip); 1307 if (retval != STATUS_SUCCESS) 1308 return STATUS_FAIL; 1309 1310 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, 1311 MS_EXTRA_SIZE, SYSTEM_PARAM, 1312 6); 1313 if (retval != STATUS_SUCCESS) 1314 return STATUS_FAIL; 1315 } 1316 } 1317 1318 retval = ms_read_bytes(chip, READ_REG, MS_EXTRA_SIZE, NO_WAIT_INT, 1319 data, MS_EXTRA_SIZE); 1320 if (retval != STATUS_SUCCESS) 1321 return STATUS_FAIL; 1322 1323 if (buf && buf_len) { 1324 if (buf_len > MS_EXTRA_SIZE) 1325 buf_len = MS_EXTRA_SIZE; 1326 memcpy(buf, data, buf_len); 1327 } 1328 1329 return STATUS_SUCCESS; 1330 } 1331 1332 static int ms_write_extra_data(struct rtsx_chip *chip, u16 block_addr, 1333 u8 page_num, u8 *buf, int buf_len) 1334 { 1335 struct ms_info *ms_card = &chip->ms_card; 1336 int retval, i; 1337 u8 val, data[16]; 1338 1339 if (!buf || (buf_len < MS_EXTRA_SIZE)) 1340 return STATUS_FAIL; 1341 1342 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 1343 SYSTEM_PARAM, 6 + MS_EXTRA_SIZE); 1344 if (retval != STATUS_SUCCESS) 1345 return STATUS_FAIL; 1346 1347 if (CHK_MS4BIT(ms_card)) 1348 data[0] = 0x88; 1349 else 1350 data[0] = 0x80; 1351 1352 data[1] = 0; 1353 data[2] = (u8)(block_addr >> 8); 1354 data[3] = (u8)block_addr; 1355 data[4] = 0x40; 1356 data[5] = page_num; 1357 1358 for (i = 6; i < MS_EXTRA_SIZE + 6; i++) 1359 data[i] = buf[i - 6]; 1360 1361 retval = ms_write_bytes(chip, WRITE_REG, (6 + MS_EXTRA_SIZE), 1362 NO_WAIT_INT, data, 16); 1363 if (retval != STATUS_SUCCESS) 1364 return STATUS_FAIL; 1365 1366 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT); 1367 if (retval != STATUS_SUCCESS) 1368 return STATUS_FAIL; 1369 1370 ms_set_err_code(chip, MS_NO_ERROR); 1371 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 1372 if (retval != STATUS_SUCCESS) 1373 return STATUS_FAIL; 1374 1375 if (val & INT_REG_CMDNK) { 1376 ms_set_err_code(chip, MS_CMD_NK); 1377 return STATUS_FAIL; 1378 } 1379 if (val & INT_REG_CED) { 1380 if (val & INT_REG_ERR) { 1381 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR); 1382 return STATUS_FAIL; 1383 } 1384 } 1385 1386 return STATUS_SUCCESS; 1387 } 1388 1389 static int ms_read_page(struct rtsx_chip *chip, u16 block_addr, u8 page_num) 1390 { 1391 struct ms_info *ms_card = &chip->ms_card; 1392 int retval; 1393 u8 val, data[6]; 1394 1395 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 1396 SYSTEM_PARAM, 6); 1397 if (retval != STATUS_SUCCESS) 1398 return STATUS_FAIL; 1399 1400 if (CHK_MS4BIT(ms_card)) 1401 data[0] = 0x88; 1402 else 1403 data[0] = 0x80; 1404 1405 data[1] = 0; 1406 data[2] = (u8)(block_addr >> 8); 1407 data[3] = (u8)block_addr; 1408 data[4] = 0x20; 1409 data[5] = page_num; 1410 1411 retval = ms_write_bytes(chip, WRITE_REG, 6, NO_WAIT_INT, data, 6); 1412 if (retval != STATUS_SUCCESS) 1413 return STATUS_FAIL; 1414 1415 retval = ms_send_cmd(chip, BLOCK_READ, WAIT_INT); 1416 if (retval != STATUS_SUCCESS) 1417 return STATUS_FAIL; 1418 1419 ms_set_err_code(chip, MS_NO_ERROR); 1420 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 1421 if (retval != STATUS_SUCCESS) 1422 return STATUS_FAIL; 1423 1424 if (val & INT_REG_CMDNK) { 1425 ms_set_err_code(chip, MS_CMD_NK); 1426 return STATUS_FAIL; 1427 } 1428 1429 if (val & INT_REG_CED) { 1430 if (val & INT_REG_ERR) { 1431 if (!(val & INT_REG_BREQ)) { 1432 ms_set_err_code(chip, MS_FLASH_READ_ERROR); 1433 return STATUS_FAIL; 1434 } 1435 retval = ms_read_status_reg(chip); 1436 if (retval != STATUS_SUCCESS) 1437 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR); 1438 1439 } else { 1440 if (!(val & INT_REG_BREQ)) { 1441 ms_set_err_code(chip, MS_BREQ_ERROR); 1442 return STATUS_FAIL; 1443 } 1444 } 1445 } 1446 1447 retval = ms_transfer_tpc(chip, MS_TM_NORMAL_READ, READ_PAGE_DATA, 1448 0, NO_WAIT_INT); 1449 if (retval != STATUS_SUCCESS) 1450 return STATUS_FAIL; 1451 1452 if (ms_check_err_code(chip, MS_FLASH_WRITE_ERROR)) 1453 return STATUS_FAIL; 1454 1455 return STATUS_SUCCESS; 1456 } 1457 1458 static int ms_set_bad_block(struct rtsx_chip *chip, u16 phy_blk) 1459 { 1460 struct ms_info *ms_card = &chip->ms_card; 1461 int retval; 1462 u8 val, data[8], extra[MS_EXTRA_SIZE]; 1463 1464 retval = ms_read_extra_data(chip, phy_blk, 0, extra, MS_EXTRA_SIZE); 1465 if (retval != STATUS_SUCCESS) 1466 return STATUS_FAIL; 1467 1468 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 1469 SYSTEM_PARAM, 7); 1470 if (retval != STATUS_SUCCESS) 1471 return STATUS_FAIL; 1472 1473 ms_set_err_code(chip, MS_NO_ERROR); 1474 1475 if (CHK_MS4BIT(ms_card)) 1476 data[0] = 0x88; 1477 else 1478 data[0] = 0x80; 1479 1480 data[1] = 0; 1481 data[2] = (u8)(phy_blk >> 8); 1482 data[3] = (u8)phy_blk; 1483 data[4] = 0x80; 1484 data[5] = 0; 1485 data[6] = extra[0] & 0x7F; 1486 data[7] = 0xFF; 1487 1488 retval = ms_write_bytes(chip, WRITE_REG, 7, NO_WAIT_INT, data, 7); 1489 if (retval != STATUS_SUCCESS) 1490 return STATUS_FAIL; 1491 1492 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT); 1493 if (retval != STATUS_SUCCESS) 1494 return STATUS_FAIL; 1495 1496 ms_set_err_code(chip, MS_NO_ERROR); 1497 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 1498 if (retval != STATUS_SUCCESS) 1499 return STATUS_FAIL; 1500 1501 if (val & INT_REG_CMDNK) { 1502 ms_set_err_code(chip, MS_CMD_NK); 1503 return STATUS_FAIL; 1504 } 1505 1506 if (val & INT_REG_CED) { 1507 if (val & INT_REG_ERR) { 1508 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR); 1509 return STATUS_FAIL; 1510 } 1511 } 1512 1513 return STATUS_SUCCESS; 1514 } 1515 1516 static int ms_erase_block(struct rtsx_chip *chip, u16 phy_blk) 1517 { 1518 struct ms_info *ms_card = &chip->ms_card; 1519 int retval, i = 0; 1520 u8 val, data[6]; 1521 1522 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 1523 SYSTEM_PARAM, 6); 1524 if (retval != STATUS_SUCCESS) 1525 return STATUS_FAIL; 1526 1527 ms_set_err_code(chip, MS_NO_ERROR); 1528 1529 if (CHK_MS4BIT(ms_card)) 1530 data[0] = 0x88; 1531 else 1532 data[0] = 0x80; 1533 1534 data[1] = 0; 1535 data[2] = (u8)(phy_blk >> 8); 1536 data[3] = (u8)phy_blk; 1537 data[4] = 0; 1538 data[5] = 0; 1539 1540 retval = ms_write_bytes(chip, WRITE_REG, 6, NO_WAIT_INT, data, 6); 1541 if (retval != STATUS_SUCCESS) 1542 return STATUS_FAIL; 1543 1544 ERASE_RTY: 1545 retval = ms_send_cmd(chip, BLOCK_ERASE, WAIT_INT); 1546 if (retval != STATUS_SUCCESS) 1547 return STATUS_FAIL; 1548 1549 ms_set_err_code(chip, MS_NO_ERROR); 1550 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 1551 if (retval != STATUS_SUCCESS) 1552 return STATUS_FAIL; 1553 1554 if (val & INT_REG_CMDNK) { 1555 if (i < 3) { 1556 i++; 1557 goto ERASE_RTY; 1558 } 1559 1560 ms_set_err_code(chip, MS_CMD_NK); 1561 ms_set_bad_block(chip, phy_blk); 1562 return STATUS_FAIL; 1563 } 1564 1565 if (val & INT_REG_CED) { 1566 if (val & INT_REG_ERR) { 1567 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR); 1568 return STATUS_FAIL; 1569 } 1570 } 1571 1572 return STATUS_SUCCESS; 1573 } 1574 1575 static void ms_set_page_status(u16 log_blk, u8 type, u8 *extra, int extra_len) 1576 { 1577 if (!extra || (extra_len < MS_EXTRA_SIZE)) 1578 return; 1579 1580 memset(extra, 0xFF, MS_EXTRA_SIZE); 1581 1582 if (type == set_PS_NG) { 1583 /* set page status as 1:NG,and block status keep 1:OK */ 1584 extra[0] = 0xB8; 1585 } else { 1586 /* set page status as 0:Data Error,and block status keep 1:OK */ 1587 extra[0] = 0x98; 1588 } 1589 1590 extra[2] = (u8)(log_blk >> 8); 1591 extra[3] = (u8)log_blk; 1592 } 1593 1594 static int ms_init_page(struct rtsx_chip *chip, u16 phy_blk, u16 log_blk, 1595 u8 start_page, u8 end_page) 1596 { 1597 int retval; 1598 u8 extra[MS_EXTRA_SIZE], i; 1599 1600 memset(extra, 0xff, MS_EXTRA_SIZE); 1601 1602 extra[0] = 0xf8; /* Block, page OK, data erased */ 1603 extra[1] = 0xff; 1604 extra[2] = (u8)(log_blk >> 8); 1605 extra[3] = (u8)log_blk; 1606 1607 for (i = start_page; i < end_page; i++) { 1608 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 1609 ms_set_err_code(chip, MS_NO_CARD); 1610 return STATUS_FAIL; 1611 } 1612 1613 retval = ms_write_extra_data(chip, phy_blk, i, 1614 extra, MS_EXTRA_SIZE); 1615 if (retval != STATUS_SUCCESS) 1616 return STATUS_FAIL; 1617 } 1618 1619 return STATUS_SUCCESS; 1620 } 1621 1622 static int ms_copy_page(struct rtsx_chip *chip, u16 old_blk, u16 new_blk, 1623 u16 log_blk, u8 start_page, u8 end_page) 1624 { 1625 struct ms_info *ms_card = &chip->ms_card; 1626 bool uncorrect_flag = false; 1627 int retval, rty_cnt; 1628 u8 extra[MS_EXTRA_SIZE], val, i, j, data[16]; 1629 1630 dev_dbg(rtsx_dev(chip), "Copy page from 0x%x to 0x%x, logical block is 0x%x\n", 1631 old_blk, new_blk, log_blk); 1632 dev_dbg(rtsx_dev(chip), "start_page = %d, end_page = %d\n", 1633 start_page, end_page); 1634 1635 retval = ms_read_extra_data(chip, new_blk, 0, extra, MS_EXTRA_SIZE); 1636 if (retval != STATUS_SUCCESS) 1637 return STATUS_FAIL; 1638 1639 retval = ms_read_status_reg(chip); 1640 if (retval != STATUS_SUCCESS) 1641 return STATUS_FAIL; 1642 1643 retval = rtsx_read_register(chip, PPBUF_BASE2, &val); 1644 if (retval) 1645 return retval; 1646 1647 if (val & BUF_FULL) { 1648 retval = ms_send_cmd(chip, CLEAR_BUF, WAIT_INT); 1649 if (retval != STATUS_SUCCESS) 1650 return STATUS_FAIL; 1651 1652 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 1653 if (retval != STATUS_SUCCESS) 1654 return STATUS_FAIL; 1655 1656 if (!(val & INT_REG_CED)) { 1657 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR); 1658 return STATUS_FAIL; 1659 } 1660 } 1661 1662 for (i = start_page; i < end_page; i++) { 1663 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 1664 ms_set_err_code(chip, MS_NO_CARD); 1665 return STATUS_FAIL; 1666 } 1667 1668 retval = ms_read_extra_data(chip, old_blk, i, extra, 1669 MS_EXTRA_SIZE); 1670 if (retval != STATUS_SUCCESS) 1671 return STATUS_FAIL; 1672 1673 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, 1674 MS_EXTRA_SIZE, SYSTEM_PARAM, 6); 1675 if (retval != STATUS_SUCCESS) 1676 return STATUS_FAIL; 1677 1678 ms_set_err_code(chip, MS_NO_ERROR); 1679 1680 if (CHK_MS4BIT(ms_card)) 1681 data[0] = 0x88; 1682 else 1683 data[0] = 0x80; 1684 1685 data[1] = 0; 1686 data[2] = (u8)(old_blk >> 8); 1687 data[3] = (u8)old_blk; 1688 data[4] = 0x20; 1689 data[5] = i; 1690 1691 retval = ms_write_bytes(chip, WRITE_REG, 6, NO_WAIT_INT, 1692 data, 6); 1693 if (retval != STATUS_SUCCESS) 1694 return STATUS_FAIL; 1695 1696 retval = ms_send_cmd(chip, BLOCK_READ, WAIT_INT); 1697 if (retval != STATUS_SUCCESS) 1698 return STATUS_FAIL; 1699 1700 ms_set_err_code(chip, MS_NO_ERROR); 1701 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 1702 if (retval != STATUS_SUCCESS) 1703 return STATUS_FAIL; 1704 1705 if (val & INT_REG_CMDNK) { 1706 ms_set_err_code(chip, MS_CMD_NK); 1707 return STATUS_FAIL; 1708 } 1709 1710 if (val & INT_REG_CED) { 1711 if (val & INT_REG_ERR) { 1712 retval = ms_read_status_reg(chip); 1713 if (retval != STATUS_SUCCESS) { 1714 uncorrect_flag = true; 1715 dev_dbg(rtsx_dev(chip), "Uncorrectable error\n"); 1716 } else { 1717 uncorrect_flag = false; 1718 } 1719 1720 retval = ms_transfer_tpc(chip, 1721 MS_TM_NORMAL_READ, 1722 READ_PAGE_DATA, 1723 0, NO_WAIT_INT); 1724 if (retval != STATUS_SUCCESS) 1725 return STATUS_FAIL; 1726 1727 if (uncorrect_flag) { 1728 ms_set_page_status(log_blk, set_PS_NG, 1729 extra, 1730 MS_EXTRA_SIZE); 1731 if (i == 0) 1732 extra[0] &= 0xEF; 1733 1734 ms_write_extra_data(chip, old_blk, i, 1735 extra, 1736 MS_EXTRA_SIZE); 1737 dev_dbg(rtsx_dev(chip), "page %d : extra[0] = 0x%x\n", 1738 i, extra[0]); 1739 MS_SET_BAD_BLOCK_FLG(ms_card); 1740 1741 ms_set_page_status(log_blk, 1742 set_PS_error, extra, 1743 MS_EXTRA_SIZE); 1744 ms_write_extra_data(chip, new_blk, i, 1745 extra, 1746 MS_EXTRA_SIZE); 1747 continue; 1748 } 1749 1750 for (rty_cnt = 0; rty_cnt < MS_MAX_RETRY_COUNT; 1751 rty_cnt++) { 1752 retval = ms_transfer_tpc( 1753 chip, 1754 MS_TM_NORMAL_WRITE, 1755 WRITE_PAGE_DATA, 1756 0, NO_WAIT_INT); 1757 if (retval == STATUS_SUCCESS) 1758 break; 1759 } 1760 if (rty_cnt == MS_MAX_RETRY_COUNT) 1761 return STATUS_FAIL; 1762 } 1763 1764 if (!(val & INT_REG_BREQ)) { 1765 ms_set_err_code(chip, MS_BREQ_ERROR); 1766 return STATUS_FAIL; 1767 } 1768 } 1769 1770 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 1771 SYSTEM_PARAM, (6 + MS_EXTRA_SIZE)); 1772 1773 ms_set_err_code(chip, MS_NO_ERROR); 1774 1775 if (CHK_MS4BIT(ms_card)) 1776 data[0] = 0x88; 1777 else 1778 data[0] = 0x80; 1779 1780 data[1] = 0; 1781 data[2] = (u8)(new_blk >> 8); 1782 data[3] = (u8)new_blk; 1783 data[4] = 0x20; 1784 data[5] = i; 1785 1786 if ((extra[0] & 0x60) != 0x60) 1787 data[6] = extra[0]; 1788 else 1789 data[6] = 0xF8; 1790 1791 data[6 + 1] = 0xFF; 1792 data[6 + 2] = (u8)(log_blk >> 8); 1793 data[6 + 3] = (u8)log_blk; 1794 1795 for (j = 4; j <= MS_EXTRA_SIZE; j++) 1796 data[6 + j] = 0xFF; 1797 1798 retval = ms_write_bytes(chip, WRITE_REG, (6 + MS_EXTRA_SIZE), 1799 NO_WAIT_INT, data, 16); 1800 if (retval != STATUS_SUCCESS) 1801 return STATUS_FAIL; 1802 1803 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT); 1804 if (retval != STATUS_SUCCESS) 1805 return STATUS_FAIL; 1806 1807 ms_set_err_code(chip, MS_NO_ERROR); 1808 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 1809 if (retval != STATUS_SUCCESS) 1810 return STATUS_FAIL; 1811 1812 if (val & INT_REG_CMDNK) { 1813 ms_set_err_code(chip, MS_CMD_NK); 1814 return STATUS_FAIL; 1815 } 1816 1817 if (val & INT_REG_CED) { 1818 if (val & INT_REG_ERR) { 1819 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR); 1820 return STATUS_FAIL; 1821 } 1822 } 1823 1824 if (i == 0) { 1825 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, 1826 MS_EXTRA_SIZE, SYSTEM_PARAM, 1827 7); 1828 if (retval != STATUS_SUCCESS) 1829 return STATUS_FAIL; 1830 1831 ms_set_err_code(chip, MS_NO_ERROR); 1832 1833 if (CHK_MS4BIT(ms_card)) 1834 data[0] = 0x88; 1835 else 1836 data[0] = 0x80; 1837 1838 data[1] = 0; 1839 data[2] = (u8)(old_blk >> 8); 1840 data[3] = (u8)old_blk; 1841 data[4] = 0x80; 1842 data[5] = 0; 1843 data[6] = 0xEF; 1844 data[7] = 0xFF; 1845 1846 retval = ms_write_bytes(chip, WRITE_REG, 7, 1847 NO_WAIT_INT, data, 8); 1848 if (retval != STATUS_SUCCESS) 1849 return STATUS_FAIL; 1850 1851 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT); 1852 if (retval != STATUS_SUCCESS) 1853 return STATUS_FAIL; 1854 1855 ms_set_err_code(chip, MS_NO_ERROR); 1856 retval = ms_read_bytes(chip, GET_INT, 1, 1857 NO_WAIT_INT, &val, 1); 1858 if (retval != STATUS_SUCCESS) 1859 return STATUS_FAIL; 1860 1861 if (val & INT_REG_CMDNK) { 1862 ms_set_err_code(chip, MS_CMD_NK); 1863 return STATUS_FAIL; 1864 } 1865 1866 if (val & INT_REG_CED) { 1867 if (val & INT_REG_ERR) { 1868 ms_set_err_code(chip, 1869 MS_FLASH_WRITE_ERROR); 1870 return STATUS_FAIL; 1871 } 1872 } 1873 } 1874 } 1875 1876 return STATUS_SUCCESS; 1877 } 1878 1879 static int reset_ms(struct rtsx_chip *chip) 1880 { 1881 struct ms_info *ms_card = &chip->ms_card; 1882 int retval; 1883 u16 i, reg_addr, block_size; 1884 u8 val, extra[MS_EXTRA_SIZE], j, *ptr; 1885 #ifndef SUPPORT_MAGIC_GATE 1886 u16 eblock_cnt; 1887 #endif 1888 1889 retval = ms_prepare_reset(chip); 1890 if (retval != STATUS_SUCCESS) 1891 return STATUS_FAIL; 1892 1893 ms_card->ms_type |= TYPE_MS; 1894 1895 retval = ms_send_cmd(chip, MS_RESET, NO_WAIT_INT); 1896 if (retval != STATUS_SUCCESS) 1897 return STATUS_FAIL; 1898 1899 retval = ms_read_status_reg(chip); 1900 if (retval != STATUS_SUCCESS) 1901 return STATUS_FAIL; 1902 1903 retval = rtsx_read_register(chip, PPBUF_BASE2, &val); 1904 if (retval) 1905 return retval; 1906 1907 if (val & WRT_PRTCT) 1908 chip->card_wp |= MS_CARD; 1909 else 1910 chip->card_wp &= ~MS_CARD; 1911 1912 i = 0; 1913 1914 RE_SEARCH: 1915 /* Search Boot Block */ 1916 while (i < (MAX_DEFECTIVE_BLOCK + 2)) { 1917 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 1918 ms_set_err_code(chip, MS_NO_CARD); 1919 return STATUS_FAIL; 1920 } 1921 1922 retval = ms_read_extra_data(chip, i, 0, extra, MS_EXTRA_SIZE); 1923 if (retval != STATUS_SUCCESS) { 1924 i++; 1925 continue; 1926 } 1927 1928 if (extra[0] & BLOCK_OK) { 1929 if (!(extra[1] & NOT_BOOT_BLOCK)) { 1930 ms_card->boot_block = i; 1931 break; 1932 } 1933 } 1934 i++; 1935 } 1936 1937 if (i == (MAX_DEFECTIVE_BLOCK + 2)) { 1938 dev_dbg(rtsx_dev(chip), "No boot block found!"); 1939 return STATUS_FAIL; 1940 } 1941 1942 for (j = 0; j < 3; j++) { 1943 retval = ms_read_page(chip, ms_card->boot_block, j); 1944 if (retval != STATUS_SUCCESS) { 1945 if (ms_check_err_code(chip, MS_FLASH_WRITE_ERROR)) { 1946 i = ms_card->boot_block + 1; 1947 ms_set_err_code(chip, MS_NO_ERROR); 1948 goto RE_SEARCH; 1949 } 1950 } 1951 } 1952 1953 retval = ms_read_page(chip, ms_card->boot_block, 0); 1954 if (retval != STATUS_SUCCESS) 1955 return STATUS_FAIL; 1956 1957 /* Read MS system information as sys_info */ 1958 rtsx_init_cmd(chip); 1959 1960 for (i = 0; i < 96; i++) 1961 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 0x1A0 + i, 0, 0); 1962 1963 retval = rtsx_send_cmd(chip, MS_CARD, 100); 1964 if (retval < 0) 1965 return STATUS_FAIL; 1966 1967 ptr = rtsx_get_cmd_data(chip); 1968 memcpy(ms_card->raw_sys_info, ptr, 96); 1969 1970 /* Read useful block contents */ 1971 rtsx_init_cmd(chip); 1972 1973 rtsx_add_cmd(chip, READ_REG_CMD, HEADER_ID0, 0, 0); 1974 rtsx_add_cmd(chip, READ_REG_CMD, HEADER_ID1, 0, 0); 1975 1976 for (reg_addr = DISABLED_BLOCK0; reg_addr <= DISABLED_BLOCK3; 1977 reg_addr++) 1978 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0); 1979 1980 for (reg_addr = BLOCK_SIZE_0; reg_addr <= PAGE_SIZE_1; reg_addr++) 1981 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0); 1982 1983 rtsx_add_cmd(chip, READ_REG_CMD, MS_device_type, 0, 0); 1984 rtsx_add_cmd(chip, READ_REG_CMD, MS_4bit_support, 0, 0); 1985 1986 retval = rtsx_send_cmd(chip, MS_CARD, 100); 1987 if (retval < 0) 1988 return STATUS_FAIL; 1989 1990 ptr = rtsx_get_cmd_data(chip); 1991 1992 dev_dbg(rtsx_dev(chip), "Boot block data:\n"); 1993 dev_dbg(rtsx_dev(chip), "%*ph\n", 16, ptr); 1994 1995 /* Block ID error 1996 * HEADER_ID0, HEADER_ID1 1997 */ 1998 if (ptr[0] != 0x00 || ptr[1] != 0x01) { 1999 i = ms_card->boot_block + 1; 2000 goto RE_SEARCH; 2001 } 2002 2003 /* Page size error 2004 * PAGE_SIZE_0, PAGE_SIZE_1 2005 */ 2006 if (ptr[12] != 0x02 || ptr[13] != 0x00) { 2007 i = ms_card->boot_block + 1; 2008 goto RE_SEARCH; 2009 } 2010 2011 if ((ptr[14] == 1) || (ptr[14] == 3)) 2012 chip->card_wp |= MS_CARD; 2013 2014 /* BLOCK_SIZE_0, BLOCK_SIZE_1 */ 2015 block_size = ((u16)ptr[6] << 8) | ptr[7]; 2016 if (block_size == 0x0010) { 2017 /* Block size 16KB */ 2018 ms_card->block_shift = 5; 2019 ms_card->page_off = 0x1F; 2020 } else if (block_size == 0x0008) { 2021 /* Block size 8KB */ 2022 ms_card->block_shift = 4; 2023 ms_card->page_off = 0x0F; 2024 } 2025 2026 /* BLOCK_COUNT_0, BLOCK_COUNT_1 */ 2027 ms_card->total_block = ((u16)ptr[8] << 8) | ptr[9]; 2028 2029 #ifdef SUPPORT_MAGIC_GATE 2030 j = ptr[10]; 2031 2032 if (ms_card->block_shift == 4) { /* 4MB or 8MB */ 2033 if (j < 2) { /* Effective block for 4MB: 0x1F0 */ 2034 ms_card->capacity = 0x1EE0; 2035 } else { /* Effective block for 8MB: 0x3E0 */ 2036 ms_card->capacity = 0x3DE0; 2037 } 2038 } else { /* 16MB, 32MB, 64MB or 128MB */ 2039 if (j < 5) { /* Effective block for 16MB: 0x3E0 */ 2040 ms_card->capacity = 0x7BC0; 2041 } else if (j < 0xA) { /* Effective block for 32MB: 0x7C0 */ 2042 ms_card->capacity = 0xF7C0; 2043 } else if (j < 0x11) { /* Effective block for 64MB: 0xF80 */ 2044 ms_card->capacity = 0x1EF80; 2045 } else { /* Effective block for 128MB: 0x1F00 */ 2046 ms_card->capacity = 0x3DF00; 2047 } 2048 } 2049 #else 2050 /* EBLOCK_COUNT_0, EBLOCK_COUNT_1 */ 2051 eblock_cnt = ((u16)ptr[10] << 8) | ptr[11]; 2052 2053 ms_card->capacity = ((u32)eblock_cnt - 2) << ms_card->block_shift; 2054 #endif 2055 2056 chip->capacity[chip->card2lun[MS_CARD]] = ms_card->capacity; 2057 2058 /* Switch I/F Mode */ 2059 if (ptr[15]) { 2060 retval = ms_set_rw_reg_addr(chip, 0, 0, SYSTEM_PARAM, 1); 2061 if (retval != STATUS_SUCCESS) 2062 return STATUS_FAIL; 2063 2064 retval = rtsx_write_register(chip, PPBUF_BASE2, 0xFF, 0x88); 2065 if (retval) 2066 return retval; 2067 2068 retval = rtsx_write_register(chip, PPBUF_BASE2 + 1, 0xFF, 0); 2069 if (retval) 2070 return retval; 2071 2072 retval = ms_transfer_tpc(chip, MS_TM_WRITE_BYTES, WRITE_REG, 1, 2073 NO_WAIT_INT); 2074 if (retval != STATUS_SUCCESS) 2075 return STATUS_FAIL; 2076 2077 retval = rtsx_write_register(chip, MS_CFG, 2078 0x58 | MS_NO_CHECK_INT, 2079 MS_BUS_WIDTH_4 | 2080 PUSH_TIME_ODD | 2081 MS_NO_CHECK_INT); 2082 if (retval) 2083 return retval; 2084 2085 ms_card->ms_type |= MS_4BIT; 2086 } 2087 2088 if (CHK_MS4BIT(ms_card)) 2089 chip->card_bus_width[chip->card2lun[MS_CARD]] = 4; 2090 else 2091 chip->card_bus_width[chip->card2lun[MS_CARD]] = 1; 2092 2093 return STATUS_SUCCESS; 2094 } 2095 2096 static int ms_init_l2p_tbl(struct rtsx_chip *chip) 2097 { 2098 struct ms_info *ms_card = &chip->ms_card; 2099 int size, i, seg_no, retval; 2100 u16 defect_block, reg_addr; 2101 u8 val1, val2; 2102 2103 ms_card->segment_cnt = ms_card->total_block >> 9; 2104 dev_dbg(rtsx_dev(chip), "ms_card->segment_cnt = %d\n", 2105 ms_card->segment_cnt); 2106 2107 size = ms_card->segment_cnt * sizeof(struct zone_entry); 2108 ms_card->segment = vzalloc(size); 2109 if (!ms_card->segment) 2110 return STATUS_FAIL; 2111 2112 retval = ms_read_page(chip, ms_card->boot_block, 1); 2113 if (retval != STATUS_SUCCESS) 2114 goto INIT_FAIL; 2115 2116 reg_addr = PPBUF_BASE2; 2117 for (i = 0; i < (((ms_card->total_block >> 9) * 10) + 1); i++) { 2118 int block_no; 2119 2120 retval = rtsx_read_register(chip, reg_addr++, &val1); 2121 if (retval != STATUS_SUCCESS) 2122 goto INIT_FAIL; 2123 2124 retval = rtsx_read_register(chip, reg_addr++, &val2); 2125 if (retval != STATUS_SUCCESS) 2126 goto INIT_FAIL; 2127 2128 defect_block = ((u16)val1 << 8) | val2; 2129 if (defect_block == 0xFFFF) 2130 break; 2131 2132 seg_no = defect_block / 512; 2133 2134 block_no = ms_card->segment[seg_no].disable_count++; 2135 ms_card->segment[seg_no].defect_list[block_no] = defect_block; 2136 } 2137 2138 for (i = 0; i < ms_card->segment_cnt; i++) { 2139 ms_card->segment[i].build_flag = 0; 2140 ms_card->segment[i].l2p_table = NULL; 2141 ms_card->segment[i].free_table = NULL; 2142 ms_card->segment[i].get_index = 0; 2143 ms_card->segment[i].set_index = 0; 2144 ms_card->segment[i].unused_blk_cnt = 0; 2145 2146 dev_dbg(rtsx_dev(chip), "defective block count of segment %d is %d\n", 2147 i, ms_card->segment[i].disable_count); 2148 } 2149 2150 return STATUS_SUCCESS; 2151 2152 INIT_FAIL: 2153 vfree(ms_card->segment); 2154 ms_card->segment = NULL; 2155 2156 return STATUS_FAIL; 2157 } 2158 2159 static u16 ms_get_l2p_tbl(struct rtsx_chip *chip, int seg_no, u16 log_off) 2160 { 2161 struct ms_info *ms_card = &chip->ms_card; 2162 struct zone_entry *segment; 2163 2164 if (!ms_card->segment) 2165 return 0xFFFF; 2166 2167 segment = &ms_card->segment[seg_no]; 2168 2169 if (segment->l2p_table) 2170 return segment->l2p_table[log_off]; 2171 2172 return 0xFFFF; 2173 } 2174 2175 static void ms_set_l2p_tbl(struct rtsx_chip *chip, 2176 int seg_no, u16 log_off, u16 phy_blk) 2177 { 2178 struct ms_info *ms_card = &chip->ms_card; 2179 struct zone_entry *segment; 2180 2181 if (!ms_card->segment) 2182 return; 2183 2184 segment = &ms_card->segment[seg_no]; 2185 if (segment->l2p_table) 2186 segment->l2p_table[log_off] = phy_blk; 2187 } 2188 2189 static void ms_set_unused_block(struct rtsx_chip *chip, u16 phy_blk) 2190 { 2191 struct ms_info *ms_card = &chip->ms_card; 2192 struct zone_entry *segment; 2193 int seg_no; 2194 2195 seg_no = (int)phy_blk >> 9; 2196 segment = &ms_card->segment[seg_no]; 2197 2198 segment->free_table[segment->set_index++] = phy_blk; 2199 if (segment->set_index >= MS_FREE_TABLE_CNT) 2200 segment->set_index = 0; 2201 2202 segment->unused_blk_cnt++; 2203 } 2204 2205 static u16 ms_get_unused_block(struct rtsx_chip *chip, int seg_no) 2206 { 2207 struct ms_info *ms_card = &chip->ms_card; 2208 struct zone_entry *segment; 2209 u16 phy_blk; 2210 2211 segment = &ms_card->segment[seg_no]; 2212 2213 if (segment->unused_blk_cnt <= 0) 2214 return 0xFFFF; 2215 2216 phy_blk = segment->free_table[segment->get_index]; 2217 segment->free_table[segment->get_index++] = 0xFFFF; 2218 if (segment->get_index >= MS_FREE_TABLE_CNT) 2219 segment->get_index = 0; 2220 2221 segment->unused_blk_cnt--; 2222 2223 return phy_blk; 2224 } 2225 2226 static const unsigned short ms_start_idx[] = {0, 494, 990, 1486, 1982, 2478, 2227 2974, 3470, 3966, 4462, 4958, 2228 5454, 5950, 6446, 6942, 7438, 2229 7934}; 2230 2231 static int ms_arbitrate_l2p(struct rtsx_chip *chip, u16 phy_blk, 2232 u16 log_off, u8 us1, u8 us2) 2233 { 2234 struct ms_info *ms_card = &chip->ms_card; 2235 struct zone_entry *segment; 2236 int seg_no; 2237 u16 tmp_blk; 2238 2239 seg_no = (int)phy_blk >> 9; 2240 segment = &ms_card->segment[seg_no]; 2241 tmp_blk = segment->l2p_table[log_off]; 2242 2243 if (us1 != us2) { 2244 if (us1 == 0) { 2245 if (!(chip->card_wp & MS_CARD)) 2246 ms_erase_block(chip, tmp_blk); 2247 2248 ms_set_unused_block(chip, tmp_blk); 2249 segment->l2p_table[log_off] = phy_blk; 2250 } else { 2251 if (!(chip->card_wp & MS_CARD)) 2252 ms_erase_block(chip, phy_blk); 2253 2254 ms_set_unused_block(chip, phy_blk); 2255 } 2256 } else { 2257 if (phy_blk < tmp_blk) { 2258 if (!(chip->card_wp & MS_CARD)) 2259 ms_erase_block(chip, phy_blk); 2260 2261 ms_set_unused_block(chip, phy_blk); 2262 } else { 2263 if (!(chip->card_wp & MS_CARD)) 2264 ms_erase_block(chip, tmp_blk); 2265 2266 ms_set_unused_block(chip, tmp_blk); 2267 segment->l2p_table[log_off] = phy_blk; 2268 } 2269 } 2270 2271 return STATUS_SUCCESS; 2272 } 2273 2274 static int ms_build_l2p_tbl(struct rtsx_chip *chip, int seg_no) 2275 { 2276 struct ms_info *ms_card = &chip->ms_card; 2277 struct zone_entry *segment; 2278 bool defect_flag; 2279 int retval, table_size, disable_cnt, i; 2280 u16 start, end, phy_blk, log_blk, tmp_blk, idx; 2281 u8 extra[MS_EXTRA_SIZE], us1, us2; 2282 2283 dev_dbg(rtsx_dev(chip), "%s: %d\n", __func__, seg_no); 2284 2285 if (!ms_card->segment) { 2286 retval = ms_init_l2p_tbl(chip); 2287 if (retval != STATUS_SUCCESS) 2288 return retval; 2289 } 2290 2291 if (ms_card->segment[seg_no].build_flag) { 2292 dev_dbg(rtsx_dev(chip), "l2p table of segment %d has been built\n", 2293 seg_no); 2294 return STATUS_SUCCESS; 2295 } 2296 2297 if (seg_no == 0) 2298 table_size = 494; 2299 else 2300 table_size = 496; 2301 2302 segment = &ms_card->segment[seg_no]; 2303 2304 if (!segment->l2p_table) { 2305 segment->l2p_table = vmalloc(array_size(table_size, 2)); 2306 if (!segment->l2p_table) 2307 goto BUILD_FAIL; 2308 } 2309 memset((u8 *)(segment->l2p_table), 0xff, array_size(table_size, 2)); 2310 2311 if (!segment->free_table) { 2312 segment->free_table = vmalloc(array_size(MS_FREE_TABLE_CNT, 2)); 2313 if (!segment->free_table) 2314 goto BUILD_FAIL; 2315 } 2316 memset((u8 *)(segment->free_table), 0xff, array_size(MS_FREE_TABLE_CNT, 2)); 2317 2318 start = (u16)seg_no << 9; 2319 end = (u16)(seg_no + 1) << 9; 2320 2321 disable_cnt = segment->disable_count; 2322 2323 segment->get_index = 0; 2324 segment->set_index = 0; 2325 segment->unused_blk_cnt = 0; 2326 2327 for (phy_blk = start; phy_blk < end; phy_blk++) { 2328 if (disable_cnt) { 2329 defect_flag = false; 2330 for (i = 0; i < segment->disable_count; i++) { 2331 if (phy_blk == segment->defect_list[i]) { 2332 defect_flag = true; 2333 break; 2334 } 2335 } 2336 if (defect_flag) { 2337 disable_cnt--; 2338 continue; 2339 } 2340 } 2341 2342 retval = ms_read_extra_data(chip, phy_blk, 0, 2343 extra, MS_EXTRA_SIZE); 2344 if (retval != STATUS_SUCCESS) { 2345 dev_dbg(rtsx_dev(chip), "read extra data fail\n"); 2346 ms_set_bad_block(chip, phy_blk); 2347 continue; 2348 } 2349 2350 if (seg_no == ms_card->segment_cnt - 1) { 2351 if (!(extra[1] & NOT_TRANSLATION_TABLE)) { 2352 if (!(chip->card_wp & MS_CARD)) { 2353 retval = ms_erase_block(chip, phy_blk); 2354 if (retval != STATUS_SUCCESS) 2355 continue; 2356 extra[2] = 0xff; 2357 extra[3] = 0xff; 2358 } 2359 } 2360 } 2361 2362 if (!(extra[0] & BLOCK_OK)) 2363 continue; 2364 if (!(extra[1] & NOT_BOOT_BLOCK)) 2365 continue; 2366 if ((extra[0] & PAGE_OK) != PAGE_OK) 2367 continue; 2368 2369 log_blk = ((u16)extra[2] << 8) | extra[3]; 2370 2371 if (log_blk == 0xFFFF) { 2372 if (!(chip->card_wp & MS_CARD)) { 2373 retval = ms_erase_block(chip, phy_blk); 2374 if (retval != STATUS_SUCCESS) 2375 continue; 2376 } 2377 ms_set_unused_block(chip, phy_blk); 2378 continue; 2379 } 2380 2381 if ((log_blk < ms_start_idx[seg_no]) || 2382 (log_blk >= ms_start_idx[seg_no + 1])) { 2383 if (!(chip->card_wp & MS_CARD)) { 2384 retval = ms_erase_block(chip, phy_blk); 2385 if (retval != STATUS_SUCCESS) 2386 continue; 2387 } 2388 ms_set_unused_block(chip, phy_blk); 2389 continue; 2390 } 2391 2392 idx = log_blk - ms_start_idx[seg_no]; 2393 2394 if (segment->l2p_table[idx] == 0xFFFF) { 2395 segment->l2p_table[idx] = phy_blk; 2396 continue; 2397 } 2398 2399 us1 = extra[0] & 0x10; 2400 tmp_blk = segment->l2p_table[idx]; 2401 retval = ms_read_extra_data(chip, tmp_blk, 0, 2402 extra, MS_EXTRA_SIZE); 2403 if (retval != STATUS_SUCCESS) 2404 continue; 2405 us2 = extra[0] & 0x10; 2406 2407 (void)ms_arbitrate_l2p(chip, phy_blk, 2408 log_blk - ms_start_idx[seg_no], us1, us2); 2409 } 2410 2411 segment->build_flag = 1; 2412 2413 dev_dbg(rtsx_dev(chip), "unused block count: %d\n", 2414 segment->unused_blk_cnt); 2415 2416 /* Logical Address Confirmation Process */ 2417 if (seg_no == ms_card->segment_cnt - 1) { 2418 if (segment->unused_blk_cnt < 2) 2419 chip->card_wp |= MS_CARD; 2420 } else { 2421 if (segment->unused_blk_cnt < 1) 2422 chip->card_wp |= MS_CARD; 2423 } 2424 2425 if (chip->card_wp & MS_CARD) 2426 return STATUS_SUCCESS; 2427 2428 for (log_blk = ms_start_idx[seg_no]; 2429 log_blk < ms_start_idx[seg_no + 1]; log_blk++) { 2430 idx = log_blk - ms_start_idx[seg_no]; 2431 if (segment->l2p_table[idx] == 0xFFFF) { 2432 phy_blk = ms_get_unused_block(chip, seg_no); 2433 if (phy_blk == 0xFFFF) { 2434 chip->card_wp |= MS_CARD; 2435 return STATUS_SUCCESS; 2436 } 2437 retval = ms_init_page(chip, phy_blk, log_blk, 0, 1); 2438 if (retval != STATUS_SUCCESS) 2439 goto BUILD_FAIL; 2440 2441 segment->l2p_table[idx] = phy_blk; 2442 if (seg_no == ms_card->segment_cnt - 1) { 2443 if (segment->unused_blk_cnt < 2) { 2444 chip->card_wp |= MS_CARD; 2445 return STATUS_SUCCESS; 2446 } 2447 } else { 2448 if (segment->unused_blk_cnt < 1) { 2449 chip->card_wp |= MS_CARD; 2450 return STATUS_SUCCESS; 2451 } 2452 } 2453 } 2454 } 2455 2456 /* Make boot block be the first normal block */ 2457 if (seg_no == 0) { 2458 for (log_blk = 0; log_blk < 494; log_blk++) { 2459 tmp_blk = segment->l2p_table[log_blk]; 2460 if (tmp_blk < ms_card->boot_block) { 2461 dev_dbg(rtsx_dev(chip), "Boot block is not the first normal block.\n"); 2462 2463 if (chip->card_wp & MS_CARD) 2464 break; 2465 2466 phy_blk = ms_get_unused_block(chip, 0); 2467 retval = ms_copy_page(chip, tmp_blk, phy_blk, 2468 log_blk, 0, 2469 ms_card->page_off + 1); 2470 if (retval != STATUS_SUCCESS) 2471 return STATUS_FAIL; 2472 2473 segment->l2p_table[log_blk] = phy_blk; 2474 2475 retval = ms_set_bad_block(chip, tmp_blk); 2476 if (retval != STATUS_SUCCESS) 2477 return STATUS_FAIL; 2478 } 2479 } 2480 } 2481 2482 return STATUS_SUCCESS; 2483 2484 BUILD_FAIL: 2485 segment->build_flag = 0; 2486 vfree(segment->l2p_table); 2487 segment->l2p_table = NULL; 2488 vfree(segment->free_table); 2489 segment->free_table = NULL; 2490 2491 return STATUS_FAIL; 2492 } 2493 2494 int reset_ms_card(struct rtsx_chip *chip) 2495 { 2496 struct ms_info *ms_card = &chip->ms_card; 2497 int seg_no = ms_card->total_block / 512 - 1; 2498 int retval; 2499 2500 memset(ms_card, 0, sizeof(struct ms_info)); 2501 2502 retval = enable_card_clock(chip, MS_CARD); 2503 if (retval != STATUS_SUCCESS) 2504 return STATUS_FAIL; 2505 2506 retval = select_card(chip, MS_CARD); 2507 if (retval != STATUS_SUCCESS) 2508 return STATUS_FAIL; 2509 2510 ms_card->ms_type = 0; 2511 2512 retval = reset_ms_pro(chip); 2513 if (retval != STATUS_SUCCESS) { 2514 if (ms_card->check_ms_flow) { 2515 retval = reset_ms(chip); 2516 if (retval != STATUS_SUCCESS) 2517 return STATUS_FAIL; 2518 } else { 2519 return STATUS_FAIL; 2520 } 2521 } 2522 2523 retval = ms_set_init_para(chip); 2524 if (retval != STATUS_SUCCESS) 2525 return STATUS_FAIL; 2526 2527 if (!CHK_MSPRO(ms_card)) { 2528 /* Build table for the last segment, 2529 * to check if L2P table block exists, erasing it 2530 */ 2531 retval = ms_build_l2p_tbl(chip, seg_no); 2532 if (retval != STATUS_SUCCESS) 2533 return STATUS_FAIL; 2534 } 2535 2536 dev_dbg(rtsx_dev(chip), "ms_card->ms_type = 0x%x\n", ms_card->ms_type); 2537 2538 return STATUS_SUCCESS; 2539 } 2540 2541 static int mspro_set_rw_cmd(struct rtsx_chip *chip, 2542 u32 start_sec, u16 sec_cnt, u8 cmd) 2543 { 2544 int retval, i; 2545 u8 data[8]; 2546 2547 data[0] = cmd; 2548 data[1] = (u8)(sec_cnt >> 8); 2549 data[2] = (u8)sec_cnt; 2550 data[3] = (u8)(start_sec >> 24); 2551 data[4] = (u8)(start_sec >> 16); 2552 data[5] = (u8)(start_sec >> 8); 2553 data[6] = (u8)start_sec; 2554 data[7] = 0; 2555 2556 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 2557 retval = ms_write_bytes(chip, PRO_EX_SET_CMD, 7, 2558 WAIT_INT, data, 8); 2559 if (retval == STATUS_SUCCESS) 2560 break; 2561 } 2562 if (i == MS_MAX_RETRY_COUNT) 2563 return STATUS_FAIL; 2564 2565 return STATUS_SUCCESS; 2566 } 2567 2568 void mspro_stop_seq_mode(struct rtsx_chip *chip) 2569 { 2570 struct ms_info *ms_card = &chip->ms_card; 2571 int retval; 2572 2573 if (ms_card->seq_mode) { 2574 retval = ms_switch_clock(chip); 2575 if (retval != STATUS_SUCCESS) 2576 return; 2577 2578 ms_card->seq_mode = 0; 2579 ms_card->total_sec_cnt = 0; 2580 ms_send_cmd(chip, PRO_STOP, WAIT_INT); 2581 2582 rtsx_write_register(chip, RBCTL, RB_FLUSH, RB_FLUSH); 2583 } 2584 } 2585 2586 static inline int ms_auto_tune_clock(struct rtsx_chip *chip) 2587 { 2588 struct ms_info *ms_card = &chip->ms_card; 2589 int retval; 2590 2591 if (chip->asic_code) { 2592 if (ms_card->ms_clock > 30) 2593 ms_card->ms_clock -= 20; 2594 } else { 2595 if (ms_card->ms_clock == CLK_80) 2596 ms_card->ms_clock = CLK_60; 2597 else if (ms_card->ms_clock == CLK_60) 2598 ms_card->ms_clock = CLK_40; 2599 } 2600 2601 retval = ms_switch_clock(chip); 2602 if (retval != STATUS_SUCCESS) 2603 return STATUS_FAIL; 2604 2605 return STATUS_SUCCESS; 2606 } 2607 2608 static int mspro_rw_multi_sector(struct scsi_cmnd *srb, 2609 struct rtsx_chip *chip, u32 start_sector, 2610 u16 sector_cnt) 2611 { 2612 struct ms_info *ms_card = &chip->ms_card; 2613 bool mode_2k = false; 2614 int retval; 2615 u16 count; 2616 u8 val, trans_mode, rw_tpc, rw_cmd; 2617 2618 ms_set_err_code(chip, MS_NO_ERROR); 2619 2620 ms_card->cleanup_counter = 0; 2621 2622 if (CHK_MSHG(ms_card)) { 2623 if ((start_sector % 4) || (sector_cnt % 4)) { 2624 if (srb->sc_data_direction == DMA_FROM_DEVICE) { 2625 rw_tpc = PRO_READ_LONG_DATA; 2626 rw_cmd = PRO_READ_DATA; 2627 } else { 2628 rw_tpc = PRO_WRITE_LONG_DATA; 2629 rw_cmd = PRO_WRITE_DATA; 2630 } 2631 } else { 2632 if (srb->sc_data_direction == DMA_FROM_DEVICE) { 2633 rw_tpc = PRO_READ_QUAD_DATA; 2634 rw_cmd = PRO_READ_2K_DATA; 2635 } else { 2636 rw_tpc = PRO_WRITE_QUAD_DATA; 2637 rw_cmd = PRO_WRITE_2K_DATA; 2638 } 2639 mode_2k = true; 2640 } 2641 } else { 2642 if (srb->sc_data_direction == DMA_FROM_DEVICE) { 2643 rw_tpc = PRO_READ_LONG_DATA; 2644 rw_cmd = PRO_READ_DATA; 2645 } else { 2646 rw_tpc = PRO_WRITE_LONG_DATA; 2647 rw_cmd = PRO_WRITE_DATA; 2648 } 2649 } 2650 2651 retval = ms_switch_clock(chip); 2652 if (retval != STATUS_SUCCESS) 2653 return STATUS_FAIL; 2654 2655 if (srb->sc_data_direction == DMA_FROM_DEVICE) 2656 trans_mode = MS_TM_AUTO_READ; 2657 else 2658 trans_mode = MS_TM_AUTO_WRITE; 2659 2660 retval = rtsx_read_register(chip, MS_TRANS_CFG, &val); 2661 if (retval) 2662 return retval; 2663 2664 if (ms_card->seq_mode) { 2665 if ((ms_card->pre_dir != srb->sc_data_direction) || 2666 ((ms_card->pre_sec_addr + ms_card->pre_sec_cnt) != 2667 start_sector) || 2668 (mode_2k && (ms_card->seq_mode & MODE_512_SEQ)) || 2669 (!mode_2k && (ms_card->seq_mode & MODE_2K_SEQ)) || 2670 !(val & MS_INT_BREQ) || 2671 ((ms_card->total_sec_cnt + sector_cnt) > 0xFE00)) { 2672 ms_card->seq_mode = 0; 2673 ms_card->total_sec_cnt = 0; 2674 if (val & MS_INT_BREQ) { 2675 retval = ms_send_cmd(chip, PRO_STOP, WAIT_INT); 2676 if (retval != STATUS_SUCCESS) 2677 return STATUS_FAIL; 2678 2679 rtsx_write_register(chip, RBCTL, RB_FLUSH, 2680 RB_FLUSH); 2681 } 2682 } 2683 } 2684 2685 if (!ms_card->seq_mode) { 2686 ms_card->total_sec_cnt = 0; 2687 if (sector_cnt >= SEQ_START_CRITERIA) { 2688 if ((ms_card->capacity - start_sector) > 0xFE00) 2689 count = 0xFE00; 2690 else 2691 count = (u16)(ms_card->capacity - start_sector); 2692 2693 if (count > sector_cnt) { 2694 if (mode_2k) 2695 ms_card->seq_mode = MODE_2K_SEQ; 2696 else 2697 ms_card->seq_mode = MODE_512_SEQ; 2698 } 2699 } else { 2700 count = sector_cnt; 2701 } 2702 retval = mspro_set_rw_cmd(chip, start_sector, count, rw_cmd); 2703 if (retval != STATUS_SUCCESS) { 2704 ms_card->seq_mode = 0; 2705 return STATUS_FAIL; 2706 } 2707 } 2708 2709 retval = ms_transfer_data(chip, trans_mode, rw_tpc, sector_cnt, 2710 WAIT_INT, mode_2k, scsi_sg_count(srb), 2711 scsi_sglist(srb), scsi_bufflen(srb)); 2712 if (retval != STATUS_SUCCESS) { 2713 ms_card->seq_mode = 0; 2714 rtsx_read_register(chip, MS_TRANS_CFG, &val); 2715 rtsx_clear_ms_error(chip); 2716 2717 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 2718 chip->rw_need_retry = 0; 2719 dev_dbg(rtsx_dev(chip), "No card exist, exit %s\n", 2720 __func__); 2721 return STATUS_FAIL; 2722 } 2723 2724 if (val & MS_INT_BREQ) 2725 ms_send_cmd(chip, PRO_STOP, WAIT_INT); 2726 2727 if (val & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) { 2728 dev_dbg(rtsx_dev(chip), "MSPro CRC error, tune clock!\n"); 2729 chip->rw_need_retry = 1; 2730 ms_auto_tune_clock(chip); 2731 } 2732 2733 return retval; 2734 } 2735 2736 if (ms_card->seq_mode) { 2737 ms_card->pre_sec_addr = start_sector; 2738 ms_card->pre_sec_cnt = sector_cnt; 2739 ms_card->pre_dir = srb->sc_data_direction; 2740 ms_card->total_sec_cnt += sector_cnt; 2741 } 2742 2743 return STATUS_SUCCESS; 2744 } 2745 2746 static int mspro_read_format_progress(struct rtsx_chip *chip, 2747 const int short_data_len) 2748 { 2749 struct ms_info *ms_card = &chip->ms_card; 2750 int retval, i; 2751 u32 total_progress, cur_progress; 2752 u8 cnt, tmp; 2753 u8 data[8]; 2754 2755 dev_dbg(rtsx_dev(chip), "%s, short_data_len = %d\n", __func__, 2756 short_data_len); 2757 2758 retval = ms_switch_clock(chip); 2759 if (retval != STATUS_SUCCESS) { 2760 ms_card->format_status = FORMAT_FAIL; 2761 return STATUS_FAIL; 2762 } 2763 2764 retval = rtsx_read_register(chip, MS_TRANS_CFG, &tmp); 2765 if (retval != STATUS_SUCCESS) { 2766 ms_card->format_status = FORMAT_FAIL; 2767 return STATUS_FAIL; 2768 } 2769 2770 if (!(tmp & MS_INT_BREQ)) { 2771 if ((tmp & (MS_INT_CED | MS_INT_BREQ | MS_INT_CMDNK | 2772 MS_INT_ERR)) == MS_INT_CED) { 2773 ms_card->format_status = FORMAT_SUCCESS; 2774 return STATUS_SUCCESS; 2775 } 2776 ms_card->format_status = FORMAT_FAIL; 2777 return STATUS_FAIL; 2778 } 2779 2780 if (short_data_len >= 256) 2781 cnt = 0; 2782 else 2783 cnt = (u8)short_data_len; 2784 2785 retval = rtsx_write_register(chip, MS_CFG, MS_NO_CHECK_INT, 2786 MS_NO_CHECK_INT); 2787 if (retval != STATUS_SUCCESS) { 2788 ms_card->format_status = FORMAT_FAIL; 2789 return STATUS_FAIL; 2790 } 2791 2792 retval = ms_read_bytes(chip, PRO_READ_SHORT_DATA, cnt, WAIT_INT, 2793 data, 8); 2794 if (retval != STATUS_SUCCESS) { 2795 ms_card->format_status = FORMAT_FAIL; 2796 return STATUS_FAIL; 2797 } 2798 2799 total_progress = (data[0] << 24) | (data[1] << 16) | 2800 (data[2] << 8) | data[3]; 2801 cur_progress = (data[4] << 24) | (data[5] << 16) | 2802 (data[6] << 8) | data[7]; 2803 2804 dev_dbg(rtsx_dev(chip), "total_progress = %d, cur_progress = %d\n", 2805 total_progress, cur_progress); 2806 2807 if (total_progress == 0) { 2808 ms_card->progress = 0; 2809 } else { 2810 u64 ulltmp = (u64)cur_progress * (u64)65535; 2811 2812 do_div(ulltmp, total_progress); 2813 ms_card->progress = (u16)ulltmp; 2814 } 2815 dev_dbg(rtsx_dev(chip), "progress = %d\n", ms_card->progress); 2816 2817 for (i = 0; i < 5000; i++) { 2818 retval = rtsx_read_register(chip, MS_TRANS_CFG, &tmp); 2819 if (retval != STATUS_SUCCESS) { 2820 ms_card->format_status = FORMAT_FAIL; 2821 return STATUS_FAIL; 2822 } 2823 if (tmp & (MS_INT_CED | MS_INT_CMDNK | 2824 MS_INT_BREQ | MS_INT_ERR)) 2825 break; 2826 2827 wait_timeout(1); 2828 } 2829 2830 retval = rtsx_write_register(chip, MS_CFG, MS_NO_CHECK_INT, 0); 2831 if (retval != STATUS_SUCCESS) { 2832 ms_card->format_status = FORMAT_FAIL; 2833 return STATUS_FAIL; 2834 } 2835 2836 if (i == 5000) { 2837 ms_card->format_status = FORMAT_FAIL; 2838 return STATUS_FAIL; 2839 } 2840 2841 if (tmp & (MS_INT_CMDNK | MS_INT_ERR)) { 2842 ms_card->format_status = FORMAT_FAIL; 2843 return STATUS_FAIL; 2844 } 2845 2846 if (tmp & MS_INT_CED) { 2847 ms_card->format_status = FORMAT_SUCCESS; 2848 ms_card->pro_under_formatting = 0; 2849 } else if (tmp & MS_INT_BREQ) { 2850 ms_card->format_status = FORMAT_IN_PROGRESS; 2851 } else { 2852 ms_card->format_status = FORMAT_FAIL; 2853 ms_card->pro_under_formatting = 0; 2854 return STATUS_FAIL; 2855 } 2856 2857 return STATUS_SUCCESS; 2858 } 2859 2860 void mspro_polling_format_status(struct rtsx_chip *chip) 2861 { 2862 struct ms_info *ms_card = &chip->ms_card; 2863 int i; 2864 2865 if (ms_card->pro_under_formatting && 2866 (rtsx_get_stat(chip) != RTSX_STAT_SS)) { 2867 rtsx_set_stat(chip, RTSX_STAT_RUN); 2868 2869 for (i = 0; i < 65535; i++) { 2870 mspro_read_format_progress(chip, MS_SHORT_DATA_LEN); 2871 if (ms_card->format_status != FORMAT_IN_PROGRESS) 2872 break; 2873 } 2874 } 2875 } 2876 2877 int mspro_format(struct scsi_cmnd *srb, struct rtsx_chip *chip, 2878 int short_data_len, bool quick_format) 2879 { 2880 struct ms_info *ms_card = &chip->ms_card; 2881 int retval, i; 2882 u8 buf[8], tmp; 2883 u16 para; 2884 2885 retval = ms_switch_clock(chip); 2886 if (retval != STATUS_SUCCESS) 2887 return STATUS_FAIL; 2888 2889 retval = ms_set_rw_reg_addr(chip, 0x00, 0x00, PRO_TPC_PARM, 0x01); 2890 if (retval != STATUS_SUCCESS) 2891 return STATUS_FAIL; 2892 2893 memset(buf, 0, 2); 2894 switch (short_data_len) { 2895 case 32: 2896 buf[0] = 0; 2897 break; 2898 case 64: 2899 buf[0] = 1; 2900 break; 2901 case 128: 2902 buf[0] = 2; 2903 break; 2904 case 256: 2905 default: 2906 buf[0] = 3; 2907 break; 2908 } 2909 2910 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 2911 retval = ms_write_bytes(chip, PRO_WRITE_REG, 1, 2912 NO_WAIT_INT, buf, 2); 2913 if (retval == STATUS_SUCCESS) 2914 break; 2915 } 2916 if (i == MS_MAX_RETRY_COUNT) 2917 return STATUS_FAIL; 2918 2919 if (quick_format) 2920 para = 0x0000; 2921 else 2922 para = 0x0001; 2923 2924 retval = mspro_set_rw_cmd(chip, 0, para, PRO_FORMAT); 2925 if (retval != STATUS_SUCCESS) 2926 return STATUS_FAIL; 2927 2928 retval = rtsx_read_register(chip, MS_TRANS_CFG, &tmp); 2929 if (retval) 2930 return retval; 2931 2932 if (tmp & (MS_INT_CMDNK | MS_INT_ERR)) 2933 return STATUS_FAIL; 2934 2935 if ((tmp & (MS_INT_BREQ | MS_INT_CED)) == MS_INT_BREQ) { 2936 ms_card->pro_under_formatting = 1; 2937 ms_card->progress = 0; 2938 ms_card->format_status = FORMAT_IN_PROGRESS; 2939 return STATUS_SUCCESS; 2940 } 2941 2942 if (tmp & MS_INT_CED) { 2943 ms_card->pro_under_formatting = 0; 2944 ms_card->progress = 0; 2945 ms_card->format_status = FORMAT_SUCCESS; 2946 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_NO_SENSE); 2947 return STATUS_SUCCESS; 2948 } 2949 2950 return STATUS_FAIL; 2951 } 2952 2953 static int ms_read_multiple_pages(struct rtsx_chip *chip, u16 phy_blk, 2954 u16 log_blk, u8 start_page, u8 end_page, 2955 u8 *buf, unsigned int *index, 2956 unsigned int *offset) 2957 { 2958 struct ms_info *ms_card = &chip->ms_card; 2959 int retval, i; 2960 u8 extra[MS_EXTRA_SIZE], page_addr, val, trans_cfg, data[6]; 2961 u8 *ptr; 2962 2963 retval = ms_read_extra_data(chip, phy_blk, start_page, 2964 extra, MS_EXTRA_SIZE); 2965 if (retval == STATUS_SUCCESS) { 2966 if ((extra[1] & 0x30) != 0x30) { 2967 ms_set_err_code(chip, MS_FLASH_READ_ERROR); 2968 return STATUS_FAIL; 2969 } 2970 } 2971 2972 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 2973 SYSTEM_PARAM, 6); 2974 if (retval != STATUS_SUCCESS) 2975 return STATUS_FAIL; 2976 2977 if (CHK_MS4BIT(ms_card)) 2978 data[0] = 0x88; 2979 else 2980 data[0] = 0x80; 2981 2982 data[1] = 0; 2983 data[2] = (u8)(phy_blk >> 8); 2984 data[3] = (u8)phy_blk; 2985 data[4] = 0; 2986 data[5] = start_page; 2987 2988 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 2989 retval = ms_write_bytes(chip, WRITE_REG, 6, NO_WAIT_INT, 2990 data, 6); 2991 if (retval == STATUS_SUCCESS) 2992 break; 2993 } 2994 if (i == MS_MAX_RETRY_COUNT) 2995 return STATUS_FAIL; 2996 2997 ms_set_err_code(chip, MS_NO_ERROR); 2998 2999 retval = ms_send_cmd(chip, BLOCK_READ, WAIT_INT); 3000 if (retval != STATUS_SUCCESS) 3001 return STATUS_FAIL; 3002 3003 ptr = buf; 3004 3005 for (page_addr = start_page; page_addr < end_page; page_addr++) { 3006 ms_set_err_code(chip, MS_NO_ERROR); 3007 3008 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 3009 ms_set_err_code(chip, MS_NO_CARD); 3010 return STATUS_FAIL; 3011 } 3012 3013 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 3014 if (retval != STATUS_SUCCESS) 3015 return STATUS_FAIL; 3016 3017 if (val & INT_REG_CMDNK) { 3018 ms_set_err_code(chip, MS_CMD_NK); 3019 return STATUS_FAIL; 3020 } 3021 if (val & INT_REG_ERR) { 3022 if (val & INT_REG_BREQ) { 3023 retval = ms_read_status_reg(chip); 3024 if (retval != STATUS_SUCCESS) { 3025 if (!(chip->card_wp & MS_CARD)) { 3026 reset_ms(chip); 3027 ms_set_page_status 3028 (log_blk, set_PS_NG, 3029 extra, 3030 MS_EXTRA_SIZE); 3031 ms_write_extra_data 3032 (chip, phy_blk, 3033 page_addr, extra, 3034 MS_EXTRA_SIZE); 3035 } 3036 ms_set_err_code(chip, 3037 MS_FLASH_READ_ERROR); 3038 return STATUS_FAIL; 3039 } 3040 } else { 3041 ms_set_err_code(chip, MS_FLASH_READ_ERROR); 3042 return STATUS_FAIL; 3043 } 3044 } else { 3045 if (!(val & INT_REG_BREQ)) { 3046 ms_set_err_code(chip, MS_BREQ_ERROR); 3047 return STATUS_FAIL; 3048 } 3049 } 3050 3051 if (page_addr == (end_page - 1)) { 3052 if (!(val & INT_REG_CED)) { 3053 retval = ms_send_cmd(chip, BLOCK_END, WAIT_INT); 3054 if (retval != STATUS_SUCCESS) 3055 return STATUS_FAIL; 3056 } 3057 3058 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, 3059 &val, 1); 3060 if (retval != STATUS_SUCCESS) 3061 return STATUS_FAIL; 3062 3063 if (!(val & INT_REG_CED)) { 3064 ms_set_err_code(chip, MS_FLASH_READ_ERROR); 3065 return STATUS_FAIL; 3066 } 3067 3068 trans_cfg = NO_WAIT_INT; 3069 } else { 3070 trans_cfg = WAIT_INT; 3071 } 3072 3073 rtsx_init_cmd(chip); 3074 3075 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, READ_PAGE_DATA); 3076 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 3077 0xFF, trans_cfg); 3078 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 3079 0x01, RING_BUFFER); 3080 3081 trans_dma_enable(DMA_FROM_DEVICE, chip, 512, DMA_512); 3082 3083 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 0xFF, 3084 MS_TRANSFER_START | MS_TM_NORMAL_READ); 3085 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER, 3086 MS_TRANSFER_END, MS_TRANSFER_END); 3087 3088 rtsx_send_cmd_no_wait(chip); 3089 3090 retval = rtsx_transfer_data_partial(chip, MS_CARD, ptr, 512, 3091 scsi_sg_count(chip->srb), 3092 index, offset, 3093 DMA_FROM_DEVICE, 3094 chip->ms_timeout); 3095 if (retval < 0) { 3096 if (retval == -ETIMEDOUT) { 3097 ms_set_err_code(chip, MS_TO_ERROR); 3098 rtsx_clear_ms_error(chip); 3099 return STATUS_TIMEDOUT; 3100 } 3101 3102 retval = rtsx_read_register(chip, MS_TRANS_CFG, &val); 3103 if (retval != STATUS_SUCCESS) { 3104 ms_set_err_code(chip, MS_TO_ERROR); 3105 rtsx_clear_ms_error(chip); 3106 return STATUS_TIMEDOUT; 3107 } 3108 if (val & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) { 3109 ms_set_err_code(chip, MS_CRC16_ERROR); 3110 rtsx_clear_ms_error(chip); 3111 return STATUS_FAIL; 3112 } 3113 } 3114 3115 if (scsi_sg_count(chip->srb) == 0) 3116 ptr += 512; 3117 } 3118 3119 return STATUS_SUCCESS; 3120 } 3121 3122 static int ms_write_multiple_pages(struct rtsx_chip *chip, u16 old_blk, 3123 u16 new_blk, u16 log_blk, u8 start_page, 3124 u8 end_page, u8 *buf, unsigned int *index, 3125 unsigned int *offset) 3126 { 3127 struct ms_info *ms_card = &chip->ms_card; 3128 int retval, i; 3129 u8 page_addr, val, data[16]; 3130 u8 *ptr; 3131 3132 if (!start_page) { 3133 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 3134 SYSTEM_PARAM, 7); 3135 if (retval != STATUS_SUCCESS) 3136 return STATUS_FAIL; 3137 3138 if (CHK_MS4BIT(ms_card)) 3139 data[0] = 0x88; 3140 else 3141 data[0] = 0x80; 3142 3143 data[1] = 0; 3144 data[2] = (u8)(old_blk >> 8); 3145 data[3] = (u8)old_blk; 3146 data[4] = 0x80; 3147 data[5] = 0; 3148 data[6] = 0xEF; 3149 data[7] = 0xFF; 3150 3151 retval = ms_write_bytes(chip, WRITE_REG, 7, NO_WAIT_INT, 3152 data, 8); 3153 if (retval != STATUS_SUCCESS) 3154 return STATUS_FAIL; 3155 3156 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT); 3157 if (retval != STATUS_SUCCESS) 3158 return STATUS_FAIL; 3159 3160 ms_set_err_code(chip, MS_NO_ERROR); 3161 retval = ms_transfer_tpc(chip, MS_TM_READ_BYTES, GET_INT, 1, 3162 NO_WAIT_INT); 3163 if (retval != STATUS_SUCCESS) 3164 return STATUS_FAIL; 3165 } 3166 3167 retval = ms_set_rw_reg_addr(chip, OVERWRITE_FLAG, MS_EXTRA_SIZE, 3168 SYSTEM_PARAM, (6 + MS_EXTRA_SIZE)); 3169 if (retval != STATUS_SUCCESS) 3170 return STATUS_FAIL; 3171 3172 ms_set_err_code(chip, MS_NO_ERROR); 3173 3174 if (CHK_MS4BIT(ms_card)) 3175 data[0] = 0x88; 3176 else 3177 data[0] = 0x80; 3178 3179 data[1] = 0; 3180 data[2] = (u8)(new_blk >> 8); 3181 data[3] = (u8)new_blk; 3182 if ((end_page - start_page) == 1) 3183 data[4] = 0x20; 3184 else 3185 data[4] = 0; 3186 3187 data[5] = start_page; 3188 data[6] = 0xF8; 3189 data[7] = 0xFF; 3190 data[8] = (u8)(log_blk >> 8); 3191 data[9] = (u8)log_blk; 3192 3193 for (i = 0x0A; i < 0x10; i++) 3194 data[i] = 0xFF; 3195 3196 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 3197 retval = ms_write_bytes(chip, WRITE_REG, 6 + MS_EXTRA_SIZE, 3198 NO_WAIT_INT, data, 16); 3199 if (retval == STATUS_SUCCESS) 3200 break; 3201 } 3202 if (i == MS_MAX_RETRY_COUNT) 3203 return STATUS_FAIL; 3204 3205 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 3206 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT); 3207 if (retval == STATUS_SUCCESS) 3208 break; 3209 } 3210 if (i == MS_MAX_RETRY_COUNT) 3211 return STATUS_FAIL; 3212 3213 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 3214 if (retval != STATUS_SUCCESS) 3215 return STATUS_FAIL; 3216 3217 ptr = buf; 3218 for (page_addr = start_page; page_addr < end_page; page_addr++) { 3219 ms_set_err_code(chip, MS_NO_ERROR); 3220 3221 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 3222 ms_set_err_code(chip, MS_NO_CARD); 3223 return STATUS_FAIL; 3224 } 3225 3226 if (val & INT_REG_CMDNK) { 3227 ms_set_err_code(chip, MS_CMD_NK); 3228 return STATUS_FAIL; 3229 } 3230 if (val & INT_REG_ERR) { 3231 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR); 3232 return STATUS_FAIL; 3233 } 3234 if (!(val & INT_REG_BREQ)) { 3235 ms_set_err_code(chip, MS_BREQ_ERROR); 3236 return STATUS_FAIL; 3237 } 3238 3239 udelay(30); 3240 3241 rtsx_init_cmd(chip); 3242 3243 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 3244 0xFF, WRITE_PAGE_DATA); 3245 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 3246 0xFF, WAIT_INT); 3247 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 3248 0x01, RING_BUFFER); 3249 3250 trans_dma_enable(DMA_TO_DEVICE, chip, 512, DMA_512); 3251 3252 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 0xFF, 3253 MS_TRANSFER_START | MS_TM_NORMAL_WRITE); 3254 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER, 3255 MS_TRANSFER_END, MS_TRANSFER_END); 3256 3257 rtsx_send_cmd_no_wait(chip); 3258 3259 retval = rtsx_transfer_data_partial(chip, MS_CARD, ptr, 512, 3260 scsi_sg_count(chip->srb), 3261 index, offset, 3262 DMA_TO_DEVICE, 3263 chip->ms_timeout); 3264 if (retval < 0) { 3265 ms_set_err_code(chip, MS_TO_ERROR); 3266 rtsx_clear_ms_error(chip); 3267 3268 if (retval == -ETIMEDOUT) 3269 return STATUS_TIMEDOUT; 3270 return STATUS_FAIL; 3271 } 3272 3273 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1); 3274 if (retval != STATUS_SUCCESS) 3275 return STATUS_FAIL; 3276 3277 if ((end_page - start_page) == 1) { 3278 if (!(val & INT_REG_CED)) { 3279 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR); 3280 return STATUS_FAIL; 3281 } 3282 } else { 3283 if (page_addr == (end_page - 1)) { 3284 if (!(val & INT_REG_CED)) { 3285 retval = ms_send_cmd(chip, BLOCK_END, 3286 WAIT_INT); 3287 if (retval != STATUS_SUCCESS) 3288 return STATUS_FAIL; 3289 } 3290 3291 retval = ms_read_bytes(chip, GET_INT, 1, 3292 NO_WAIT_INT, &val, 1); 3293 if (retval != STATUS_SUCCESS) 3294 return STATUS_FAIL; 3295 } 3296 3297 if ((page_addr == (end_page - 1)) || 3298 (page_addr == ms_card->page_off)) { 3299 if (!(val & INT_REG_CED)) { 3300 ms_set_err_code(chip, 3301 MS_FLASH_WRITE_ERROR); 3302 return STATUS_FAIL; 3303 } 3304 } 3305 } 3306 3307 if (scsi_sg_count(chip->srb) == 0) 3308 ptr += 512; 3309 } 3310 3311 return STATUS_SUCCESS; 3312 } 3313 3314 static int ms_finish_write(struct rtsx_chip *chip, u16 old_blk, u16 new_blk, 3315 u16 log_blk, u8 page_off) 3316 { 3317 struct ms_info *ms_card = &chip->ms_card; 3318 int retval, seg_no; 3319 3320 retval = ms_copy_page(chip, old_blk, new_blk, log_blk, 3321 page_off, ms_card->page_off + 1); 3322 if (retval != STATUS_SUCCESS) 3323 return STATUS_FAIL; 3324 3325 seg_no = old_blk >> 9; 3326 3327 if (MS_TST_BAD_BLOCK_FLG(ms_card)) { 3328 MS_CLR_BAD_BLOCK_FLG(ms_card); 3329 ms_set_bad_block(chip, old_blk); 3330 } else { 3331 retval = ms_erase_block(chip, old_blk); 3332 if (retval == STATUS_SUCCESS) 3333 ms_set_unused_block(chip, old_blk); 3334 } 3335 3336 ms_set_l2p_tbl(chip, seg_no, log_blk - ms_start_idx[seg_no], new_blk); 3337 3338 return STATUS_SUCCESS; 3339 } 3340 3341 static int ms_prepare_write(struct rtsx_chip *chip, u16 old_blk, u16 new_blk, 3342 u16 log_blk, u8 start_page) 3343 { 3344 int retval; 3345 3346 if (start_page) { 3347 retval = ms_copy_page(chip, old_blk, new_blk, log_blk, 3348 0, start_page); 3349 if (retval != STATUS_SUCCESS) 3350 return STATUS_FAIL; 3351 } 3352 3353 return STATUS_SUCCESS; 3354 } 3355 3356 #ifdef MS_DELAY_WRITE 3357 int ms_delay_write(struct rtsx_chip *chip) 3358 { 3359 struct ms_info *ms_card = &chip->ms_card; 3360 struct ms_delay_write_tag *delay_write = &ms_card->delay_write; 3361 int retval; 3362 3363 if (delay_write->delay_write_flag) { 3364 retval = ms_set_init_para(chip); 3365 if (retval != STATUS_SUCCESS) 3366 return STATUS_FAIL; 3367 3368 delay_write->delay_write_flag = 0; 3369 retval = ms_finish_write(chip, 3370 delay_write->old_phyblock, 3371 delay_write->new_phyblock, 3372 delay_write->logblock, 3373 delay_write->pageoff); 3374 if (retval != STATUS_SUCCESS) 3375 return STATUS_FAIL; 3376 } 3377 3378 return STATUS_SUCCESS; 3379 } 3380 #endif 3381 3382 static inline void ms_rw_fail(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3383 { 3384 if (srb->sc_data_direction == DMA_FROM_DEVICE) 3385 set_sense_type(chip, SCSI_LUN(srb), 3386 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 3387 else 3388 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR); 3389 } 3390 3391 static int ms_rw_multi_sector(struct scsi_cmnd *srb, struct rtsx_chip *chip, 3392 u32 start_sector, u16 sector_cnt) 3393 { 3394 struct ms_info *ms_card = &chip->ms_card; 3395 unsigned int lun = SCSI_LUN(srb); 3396 int retval, seg_no; 3397 unsigned int index = 0, offset = 0; 3398 u16 old_blk = 0, new_blk = 0, log_blk, total_sec_cnt = sector_cnt; 3399 u8 start_page, end_page = 0, page_cnt; 3400 u8 *ptr; 3401 #ifdef MS_DELAY_WRITE 3402 struct ms_delay_write_tag *delay_write = &ms_card->delay_write; 3403 #endif 3404 3405 ms_set_err_code(chip, MS_NO_ERROR); 3406 3407 ms_card->cleanup_counter = 0; 3408 3409 ptr = (u8 *)scsi_sglist(srb); 3410 3411 retval = ms_switch_clock(chip); 3412 if (retval != STATUS_SUCCESS) { 3413 ms_rw_fail(srb, chip); 3414 return STATUS_FAIL; 3415 } 3416 3417 log_blk = (u16)(start_sector >> ms_card->block_shift); 3418 start_page = (u8)(start_sector & ms_card->page_off); 3419 3420 for (seg_no = 0; seg_no < ARRAY_SIZE(ms_start_idx) - 1; seg_no++) { 3421 if (log_blk < ms_start_idx[seg_no + 1]) 3422 break; 3423 } 3424 3425 if (ms_card->segment[seg_no].build_flag == 0) { 3426 retval = ms_build_l2p_tbl(chip, seg_no); 3427 if (retval != STATUS_SUCCESS) { 3428 chip->card_fail |= MS_CARD; 3429 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); 3430 return STATUS_FAIL; 3431 } 3432 } 3433 3434 if (srb->sc_data_direction == DMA_TO_DEVICE) { 3435 #ifdef MS_DELAY_WRITE 3436 if (delay_write->delay_write_flag && 3437 (delay_write->logblock == log_blk) && 3438 (start_page > delay_write->pageoff)) { 3439 delay_write->delay_write_flag = 0; 3440 retval = ms_copy_page(chip, 3441 delay_write->old_phyblock, 3442 delay_write->new_phyblock, 3443 log_blk, 3444 delay_write->pageoff, start_page); 3445 if (retval != STATUS_SUCCESS) { 3446 set_sense_type(chip, lun, 3447 SENSE_TYPE_MEDIA_WRITE_ERR); 3448 return STATUS_FAIL; 3449 } 3450 old_blk = delay_write->old_phyblock; 3451 new_blk = delay_write->new_phyblock; 3452 } else if (delay_write->delay_write_flag && 3453 (delay_write->logblock == log_blk) && 3454 (start_page == delay_write->pageoff)) { 3455 delay_write->delay_write_flag = 0; 3456 old_blk = delay_write->old_phyblock; 3457 new_blk = delay_write->new_phyblock; 3458 } else { 3459 retval = ms_delay_write(chip); 3460 if (retval != STATUS_SUCCESS) { 3461 set_sense_type(chip, lun, 3462 SENSE_TYPE_MEDIA_WRITE_ERR); 3463 return STATUS_FAIL; 3464 } 3465 #endif 3466 old_blk = ms_get_l2p_tbl 3467 (chip, seg_no, 3468 log_blk - ms_start_idx[seg_no]); 3469 new_blk = ms_get_unused_block(chip, seg_no); 3470 if ((old_blk == 0xFFFF) || (new_blk == 0xFFFF)) { 3471 set_sense_type(chip, lun, 3472 SENSE_TYPE_MEDIA_WRITE_ERR); 3473 return STATUS_FAIL; 3474 } 3475 3476 retval = ms_prepare_write(chip, old_blk, new_blk, 3477 log_blk, start_page); 3478 if (retval != STATUS_SUCCESS) { 3479 if (detect_card_cd(chip, MS_CARD) != 3480 STATUS_SUCCESS) { 3481 set_sense_type 3482 (chip, lun, 3483 SENSE_TYPE_MEDIA_NOT_PRESENT); 3484 return STATUS_FAIL; 3485 } 3486 set_sense_type(chip, lun, 3487 SENSE_TYPE_MEDIA_WRITE_ERR); 3488 return STATUS_FAIL; 3489 } 3490 #ifdef MS_DELAY_WRITE 3491 } 3492 #endif 3493 } else { 3494 #ifdef MS_DELAY_WRITE 3495 retval = ms_delay_write(chip); 3496 if (retval != STATUS_SUCCESS) { 3497 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 3498 set_sense_type(chip, lun, 3499 SENSE_TYPE_MEDIA_NOT_PRESENT); 3500 return STATUS_FAIL; 3501 } 3502 set_sense_type(chip, lun, 3503 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 3504 return STATUS_FAIL; 3505 } 3506 #endif 3507 old_blk = ms_get_l2p_tbl(chip, seg_no, 3508 log_blk - ms_start_idx[seg_no]); 3509 if (old_blk == 0xFFFF) { 3510 set_sense_type(chip, lun, 3511 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 3512 return STATUS_FAIL; 3513 } 3514 } 3515 3516 dev_dbg(rtsx_dev(chip), "seg_no = %d, old_blk = 0x%x, new_blk = 0x%x\n", 3517 seg_no, old_blk, new_blk); 3518 3519 while (total_sec_cnt) { 3520 if ((start_page + total_sec_cnt) > (ms_card->page_off + 1)) 3521 end_page = ms_card->page_off + 1; 3522 else 3523 end_page = start_page + (u8)total_sec_cnt; 3524 3525 page_cnt = end_page - start_page; 3526 3527 dev_dbg(rtsx_dev(chip), "start_page = %d, end_page = %d, page_cnt = %d\n", 3528 start_page, end_page, page_cnt); 3529 3530 if (srb->sc_data_direction == DMA_FROM_DEVICE) { 3531 retval = ms_read_multiple_pages(chip, 3532 old_blk, log_blk, 3533 start_page, end_page, 3534 ptr, &index, &offset); 3535 } else { 3536 retval = ms_write_multiple_pages(chip, old_blk, new_blk, 3537 log_blk, start_page, 3538 end_page, ptr, &index, 3539 &offset); 3540 } 3541 3542 if (retval != STATUS_SUCCESS) { 3543 toggle_gpio(chip, 1); 3544 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) { 3545 set_sense_type(chip, lun, 3546 SENSE_TYPE_MEDIA_NOT_PRESENT); 3547 return STATUS_FAIL; 3548 } 3549 ms_rw_fail(srb, chip); 3550 return STATUS_FAIL; 3551 } 3552 3553 if (srb->sc_data_direction == DMA_TO_DEVICE) { 3554 if (end_page == (ms_card->page_off + 1)) { 3555 retval = ms_erase_block(chip, old_blk); 3556 if (retval == STATUS_SUCCESS) 3557 ms_set_unused_block(chip, old_blk); 3558 3559 ms_set_l2p_tbl(chip, seg_no, 3560 log_blk - ms_start_idx[seg_no], 3561 new_blk); 3562 } 3563 } 3564 3565 total_sec_cnt -= page_cnt; 3566 if (scsi_sg_count(srb) == 0) 3567 ptr += page_cnt * 512; 3568 3569 if (total_sec_cnt == 0) 3570 break; 3571 3572 log_blk++; 3573 3574 for (seg_no = 0; seg_no < ARRAY_SIZE(ms_start_idx) - 1; 3575 seg_no++) { 3576 if (log_blk < ms_start_idx[seg_no + 1]) 3577 break; 3578 } 3579 3580 if (ms_card->segment[seg_no].build_flag == 0) { 3581 retval = ms_build_l2p_tbl(chip, seg_no); 3582 if (retval != STATUS_SUCCESS) { 3583 chip->card_fail |= MS_CARD; 3584 set_sense_type(chip, lun, 3585 SENSE_TYPE_MEDIA_NOT_PRESENT); 3586 return STATUS_FAIL; 3587 } 3588 } 3589 3590 old_blk = ms_get_l2p_tbl(chip, seg_no, 3591 log_blk - ms_start_idx[seg_no]); 3592 if (old_blk == 0xFFFF) { 3593 ms_rw_fail(srb, chip); 3594 return STATUS_FAIL; 3595 } 3596 3597 if (srb->sc_data_direction == DMA_TO_DEVICE) { 3598 new_blk = ms_get_unused_block(chip, seg_no); 3599 if (new_blk == 0xFFFF) { 3600 ms_rw_fail(srb, chip); 3601 return STATUS_FAIL; 3602 } 3603 } 3604 3605 dev_dbg(rtsx_dev(chip), "seg_no = %d, old_blk = 0x%x, new_blk = 0x%x\n", 3606 seg_no, old_blk, new_blk); 3607 3608 start_page = 0; 3609 } 3610 3611 if (srb->sc_data_direction == DMA_TO_DEVICE) { 3612 if (end_page < (ms_card->page_off + 1)) { 3613 #ifdef MS_DELAY_WRITE 3614 delay_write->delay_write_flag = 1; 3615 delay_write->old_phyblock = old_blk; 3616 delay_write->new_phyblock = new_blk; 3617 delay_write->logblock = log_blk; 3618 delay_write->pageoff = end_page; 3619 #else 3620 retval = ms_finish_write(chip, old_blk, new_blk, 3621 log_blk, end_page); 3622 if (retval != STATUS_SUCCESS) { 3623 if (detect_card_cd(chip, MS_CARD) != 3624 STATUS_SUCCESS) { 3625 set_sense_type 3626 (chip, lun, 3627 SENSE_TYPE_MEDIA_NOT_PRESENT); 3628 return STATUS_FAIL; 3629 } 3630 3631 ms_rw_fail(srb, chip); 3632 return STATUS_FAIL; 3633 } 3634 #endif 3635 } 3636 } 3637 3638 scsi_set_resid(srb, 0); 3639 3640 return STATUS_SUCCESS; 3641 } 3642 3643 int ms_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, 3644 u32 start_sector, u16 sector_cnt) 3645 { 3646 struct ms_info *ms_card = &chip->ms_card; 3647 int retval; 3648 3649 if (CHK_MSPRO(ms_card)) 3650 retval = mspro_rw_multi_sector(srb, chip, start_sector, 3651 sector_cnt); 3652 else 3653 retval = ms_rw_multi_sector(srb, chip, start_sector, 3654 sector_cnt); 3655 3656 return retval; 3657 } 3658 3659 void ms_free_l2p_tbl(struct rtsx_chip *chip) 3660 { 3661 struct ms_info *ms_card = &chip->ms_card; 3662 int i = 0; 3663 3664 if (ms_card->segment) { 3665 for (i = 0; i < ms_card->segment_cnt; i++) { 3666 vfree(ms_card->segment[i].l2p_table); 3667 ms_card->segment[i].l2p_table = NULL; 3668 vfree(ms_card->segment[i].free_table); 3669 ms_card->segment[i].free_table = NULL; 3670 } 3671 vfree(ms_card->segment); 3672 ms_card->segment = NULL; 3673 } 3674 } 3675 3676 #ifdef SUPPORT_MAGIC_GATE 3677 3678 #ifdef READ_BYTES_WAIT_INT 3679 static int ms_poll_int(struct rtsx_chip *chip) 3680 { 3681 int retval; 3682 u8 val; 3683 3684 rtsx_init_cmd(chip); 3685 3686 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANS_CFG, MS_INT_CED, MS_INT_CED); 3687 3688 retval = rtsx_send_cmd(chip, MS_CARD, 5000); 3689 if (retval != STATUS_SUCCESS) 3690 return STATUS_FAIL; 3691 3692 val = *rtsx_get_cmd_data(chip); 3693 if (val & MS_INT_ERR) 3694 return STATUS_FAIL; 3695 3696 return STATUS_SUCCESS; 3697 } 3698 #endif 3699 3700 #ifdef MS_SAMPLE_INT_ERR 3701 static int check_ms_err(struct rtsx_chip *chip) 3702 { 3703 int retval; 3704 u8 val; 3705 3706 retval = rtsx_read_register(chip, MS_TRANSFER, &val); 3707 if (retval != STATUS_SUCCESS) 3708 return 1; 3709 if (val & MS_TRANSFER_ERR) 3710 return 1; 3711 3712 retval = rtsx_read_register(chip, MS_TRANS_CFG, &val); 3713 if (retval != STATUS_SUCCESS) 3714 return 1; 3715 3716 if (val & (MS_INT_ERR | MS_INT_CMDNK)) 3717 return 1; 3718 3719 return 0; 3720 } 3721 #else 3722 static int check_ms_err(struct rtsx_chip *chip) 3723 { 3724 int retval; 3725 u8 val; 3726 3727 retval = rtsx_read_register(chip, MS_TRANSFER, &val); 3728 if (retval != STATUS_SUCCESS) 3729 return 1; 3730 if (val & MS_TRANSFER_ERR) 3731 return 1; 3732 3733 return 0; 3734 } 3735 #endif 3736 3737 static int mg_send_ex_cmd(struct rtsx_chip *chip, u8 cmd, u8 entry_num) 3738 { 3739 int retval, i; 3740 u8 data[8]; 3741 3742 data[0] = cmd; 3743 data[1] = 0; 3744 data[2] = 0; 3745 data[3] = 0; 3746 data[4] = 0; 3747 data[5] = 0; 3748 data[6] = entry_num; 3749 data[7] = 0; 3750 3751 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) { 3752 retval = ms_write_bytes(chip, PRO_EX_SET_CMD, 7, WAIT_INT, 3753 data, 8); 3754 if (retval == STATUS_SUCCESS) 3755 break; 3756 } 3757 if (i == MS_MAX_RETRY_COUNT) 3758 return STATUS_FAIL; 3759 3760 if (check_ms_err(chip)) { 3761 rtsx_clear_ms_error(chip); 3762 return STATUS_FAIL; 3763 } 3764 3765 return STATUS_SUCCESS; 3766 } 3767 3768 static int mg_set_tpc_para_sub(struct rtsx_chip *chip, int type, 3769 u8 mg_entry_num) 3770 { 3771 int retval; 3772 u8 buf[6]; 3773 3774 if (type == 0) 3775 retval = ms_set_rw_reg_addr(chip, 0, 0, PRO_TPC_PARM, 1); 3776 else 3777 retval = ms_set_rw_reg_addr(chip, 0, 0, PRO_DATA_COUNT1, 6); 3778 3779 if (retval != STATUS_SUCCESS) 3780 return STATUS_FAIL; 3781 3782 buf[0] = 0; 3783 buf[1] = 0; 3784 if (type == 1) { 3785 buf[2] = 0; 3786 buf[3] = 0; 3787 buf[4] = 0; 3788 buf[5] = mg_entry_num; 3789 } 3790 retval = ms_write_bytes(chip, PRO_WRITE_REG, (type == 0) ? 1 : 6, 3791 NO_WAIT_INT, buf, 6); 3792 if (retval != STATUS_SUCCESS) 3793 return STATUS_FAIL; 3794 3795 return STATUS_SUCCESS; 3796 } 3797 3798 int mg_set_leaf_id(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3799 { 3800 int retval; 3801 int i; 3802 unsigned int lun = SCSI_LUN(srb); 3803 u8 buf1[32], buf2[12]; 3804 3805 if (scsi_bufflen(srb) < 12) { 3806 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); 3807 return STATUS_FAIL; 3808 } 3809 3810 ms_cleanup_work(chip); 3811 3812 retval = ms_switch_clock(chip); 3813 if (retval != STATUS_SUCCESS) 3814 return STATUS_FAIL; 3815 3816 retval = mg_send_ex_cmd(chip, MG_SET_LID, 0); 3817 if (retval != STATUS_SUCCESS) { 3818 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB); 3819 return STATUS_FAIL; 3820 } 3821 3822 memset(buf1, 0, 32); 3823 rtsx_stor_get_xfer_buf(buf2, min_t(int, 12, scsi_bufflen(srb)), srb); 3824 for (i = 0; i < 8; i++) 3825 buf1[8 + i] = buf2[4 + i]; 3826 3827 retval = ms_write_bytes(chip, PRO_WRITE_SHORT_DATA, 32, WAIT_INT, 3828 buf1, 32); 3829 if (retval != STATUS_SUCCESS) { 3830 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB); 3831 return STATUS_FAIL; 3832 } 3833 if (check_ms_err(chip)) { 3834 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB); 3835 rtsx_clear_ms_error(chip); 3836 return STATUS_FAIL; 3837 } 3838 3839 return STATUS_SUCCESS; 3840 } 3841 3842 int mg_get_local_EKB(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3843 { 3844 int retval; 3845 int bufflen; 3846 unsigned int lun = SCSI_LUN(srb); 3847 u8 *buf = NULL; 3848 3849 ms_cleanup_work(chip); 3850 3851 retval = ms_switch_clock(chip); 3852 if (retval != STATUS_SUCCESS) 3853 return STATUS_FAIL; 3854 3855 buf = kmalloc(1540, GFP_KERNEL); 3856 if (!buf) 3857 return STATUS_ERROR; 3858 3859 buf[0] = 0x04; 3860 buf[1] = 0x1A; 3861 buf[2] = 0x00; 3862 buf[3] = 0x00; 3863 3864 retval = mg_send_ex_cmd(chip, MG_GET_LEKB, 0); 3865 if (retval != STATUS_SUCCESS) { 3866 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 3867 goto free_buffer; 3868 } 3869 3870 retval = ms_transfer_data(chip, MS_TM_AUTO_READ, PRO_READ_LONG_DATA, 3871 3, WAIT_INT, 0, 0, buf + 4, 1536); 3872 if (retval != STATUS_SUCCESS) { 3873 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 3874 rtsx_clear_ms_error(chip); 3875 goto free_buffer; 3876 } 3877 if (check_ms_err(chip)) { 3878 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 3879 rtsx_clear_ms_error(chip); 3880 retval = STATUS_FAIL; 3881 goto free_buffer; 3882 } 3883 3884 bufflen = min_t(int, 1052, scsi_bufflen(srb)); 3885 rtsx_stor_set_xfer_buf(buf, bufflen, srb); 3886 3887 free_buffer: 3888 kfree(buf); 3889 return retval; 3890 } 3891 3892 int mg_chg(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3893 { 3894 struct ms_info *ms_card = &chip->ms_card; 3895 int retval; 3896 int bufflen; 3897 int i; 3898 unsigned int lun = SCSI_LUN(srb); 3899 u8 buf[32]; 3900 3901 ms_cleanup_work(chip); 3902 3903 retval = ms_switch_clock(chip); 3904 if (retval != STATUS_SUCCESS) 3905 return STATUS_FAIL; 3906 3907 retval = mg_send_ex_cmd(chip, MG_GET_ID, 0); 3908 if (retval != STATUS_SUCCESS) { 3909 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3910 return STATUS_FAIL; 3911 } 3912 3913 retval = ms_read_bytes(chip, PRO_READ_SHORT_DATA, 32, WAIT_INT, 3914 buf, 32); 3915 if (retval != STATUS_SUCCESS) { 3916 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3917 return STATUS_FAIL; 3918 } 3919 if (check_ms_err(chip)) { 3920 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3921 rtsx_clear_ms_error(chip); 3922 return STATUS_FAIL; 3923 } 3924 3925 memcpy(ms_card->magic_gate_id, buf, 16); 3926 3927 #ifdef READ_BYTES_WAIT_INT 3928 retval = ms_poll_int(chip); 3929 if (retval != STATUS_SUCCESS) { 3930 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3931 return STATUS_FAIL; 3932 } 3933 #endif 3934 3935 retval = mg_send_ex_cmd(chip, MG_SET_RD, 0); 3936 if (retval != STATUS_SUCCESS) { 3937 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3938 return STATUS_FAIL; 3939 } 3940 3941 bufflen = min_t(int, 12, scsi_bufflen(srb)); 3942 rtsx_stor_get_xfer_buf(buf, bufflen, srb); 3943 3944 for (i = 0; i < 8; i++) 3945 buf[i] = buf[4 + i]; 3946 3947 for (i = 0; i < 24; i++) 3948 buf[8 + i] = 0; 3949 3950 retval = ms_write_bytes(chip, PRO_WRITE_SHORT_DATA, 3951 32, WAIT_INT, buf, 32); 3952 if (retval != STATUS_SUCCESS) { 3953 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3954 return STATUS_FAIL; 3955 } 3956 if (check_ms_err(chip)) { 3957 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM); 3958 rtsx_clear_ms_error(chip); 3959 return STATUS_FAIL; 3960 } 3961 3962 ms_card->mg_auth = 0; 3963 3964 return STATUS_SUCCESS; 3965 } 3966 3967 int mg_get_rsp_chg(struct scsi_cmnd *srb, struct rtsx_chip *chip) 3968 { 3969 struct ms_info *ms_card = &chip->ms_card; 3970 int retval; 3971 int bufflen; 3972 unsigned int lun = SCSI_LUN(srb); 3973 u8 buf1[32], buf2[36]; 3974 3975 ms_cleanup_work(chip); 3976 3977 retval = ms_switch_clock(chip); 3978 if (retval != STATUS_SUCCESS) 3979 return STATUS_FAIL; 3980 3981 retval = mg_send_ex_cmd(chip, MG_MAKE_RMS, 0); 3982 if (retval != STATUS_SUCCESS) { 3983 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 3984 return STATUS_FAIL; 3985 } 3986 3987 retval = ms_read_bytes(chip, PRO_READ_SHORT_DATA, 32, WAIT_INT, 3988 buf1, 32); 3989 if (retval != STATUS_SUCCESS) { 3990 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 3991 return STATUS_FAIL; 3992 } 3993 if (check_ms_err(chip)) { 3994 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 3995 rtsx_clear_ms_error(chip); 3996 return STATUS_FAIL; 3997 } 3998 3999 buf2[0] = 0x00; 4000 buf2[1] = 0x22; 4001 buf2[2] = 0x00; 4002 buf2[3] = 0x00; 4003 4004 memcpy(buf2 + 4, ms_card->magic_gate_id, 16); 4005 memcpy(buf2 + 20, buf1, 16); 4006 4007 bufflen = min_t(int, 36, scsi_bufflen(srb)); 4008 rtsx_stor_set_xfer_buf(buf2, bufflen, srb); 4009 4010 #ifdef READ_BYTES_WAIT_INT 4011 retval = ms_poll_int(chip); 4012 if (retval != STATUS_SUCCESS) { 4013 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 4014 return STATUS_FAIL; 4015 } 4016 #endif 4017 4018 return STATUS_SUCCESS; 4019 } 4020 4021 int mg_rsp(struct scsi_cmnd *srb, struct rtsx_chip *chip) 4022 { 4023 struct ms_info *ms_card = &chip->ms_card; 4024 int retval; 4025 int i; 4026 int bufflen; 4027 unsigned int lun = SCSI_LUN(srb); 4028 u8 buf[32]; 4029 4030 ms_cleanup_work(chip); 4031 4032 retval = ms_switch_clock(chip); 4033 if (retval != STATUS_SUCCESS) 4034 return STATUS_FAIL; 4035 4036 retval = mg_send_ex_cmd(chip, MG_MAKE_KSE, 0); 4037 if (retval != STATUS_SUCCESS) { 4038 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 4039 return STATUS_FAIL; 4040 } 4041 4042 bufflen = min_t(int, 12, scsi_bufflen(srb)); 4043 rtsx_stor_get_xfer_buf(buf, bufflen, srb); 4044 4045 for (i = 0; i < 8; i++) 4046 buf[i] = buf[4 + i]; 4047 4048 for (i = 0; i < 24; i++) 4049 buf[8 + i] = 0; 4050 4051 retval = ms_write_bytes(chip, PRO_WRITE_SHORT_DATA, 32, WAIT_INT, 4052 buf, 32); 4053 if (retval != STATUS_SUCCESS) { 4054 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 4055 return STATUS_FAIL; 4056 } 4057 if (check_ms_err(chip)) { 4058 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN); 4059 rtsx_clear_ms_error(chip); 4060 return STATUS_FAIL; 4061 } 4062 4063 ms_card->mg_auth = 1; 4064 4065 return STATUS_SUCCESS; 4066 } 4067 4068 int mg_get_ICV(struct scsi_cmnd *srb, struct rtsx_chip *chip) 4069 { 4070 struct ms_info *ms_card = &chip->ms_card; 4071 int retval; 4072 int bufflen; 4073 unsigned int lun = SCSI_LUN(srb); 4074 u8 *buf = NULL; 4075 4076 ms_cleanup_work(chip); 4077 4078 retval = ms_switch_clock(chip); 4079 if (retval != STATUS_SUCCESS) 4080 return STATUS_FAIL; 4081 4082 buf = kmalloc(1028, GFP_KERNEL); 4083 if (!buf) 4084 return STATUS_ERROR; 4085 4086 buf[0] = 0x04; 4087 buf[1] = 0x02; 4088 buf[2] = 0x00; 4089 buf[3] = 0x00; 4090 4091 retval = mg_send_ex_cmd(chip, MG_GET_IBD, ms_card->mg_entry_num); 4092 if (retval != STATUS_SUCCESS) { 4093 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 4094 goto free_buffer; 4095 } 4096 4097 retval = ms_transfer_data(chip, MS_TM_AUTO_READ, PRO_READ_LONG_DATA, 4098 2, WAIT_INT, 0, 0, buf + 4, 1024); 4099 if (retval != STATUS_SUCCESS) { 4100 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 4101 rtsx_clear_ms_error(chip); 4102 goto free_buffer; 4103 } 4104 if (check_ms_err(chip)) { 4105 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR); 4106 rtsx_clear_ms_error(chip); 4107 retval = STATUS_FAIL; 4108 goto free_buffer; 4109 } 4110 4111 bufflen = min_t(int, 1028, scsi_bufflen(srb)); 4112 rtsx_stor_set_xfer_buf(buf, bufflen, srb); 4113 4114 free_buffer: 4115 kfree(buf); 4116 return retval; 4117 } 4118 4119 int mg_set_ICV(struct scsi_cmnd *srb, struct rtsx_chip *chip) 4120 { 4121 struct ms_info *ms_card = &chip->ms_card; 4122 int retval; 4123 int bufflen; 4124 #ifdef MG_SET_ICV_SLOW 4125 int i; 4126 #endif 4127 unsigned int lun = SCSI_LUN(srb); 4128 u8 *buf = NULL; 4129 4130 ms_cleanup_work(chip); 4131 4132 retval = ms_switch_clock(chip); 4133 if (retval != STATUS_SUCCESS) 4134 return STATUS_FAIL; 4135 4136 buf = kmalloc(1028, GFP_KERNEL); 4137 if (!buf) 4138 return STATUS_ERROR; 4139 4140 bufflen = min_t(int, 1028, scsi_bufflen(srb)); 4141 rtsx_stor_get_xfer_buf(buf, bufflen, srb); 4142 4143 retval = mg_send_ex_cmd(chip, MG_SET_IBD, ms_card->mg_entry_num); 4144 if (retval != STATUS_SUCCESS) { 4145 if (ms_card->mg_auth == 0) { 4146 if ((buf[5] & 0xC0) != 0) 4147 set_sense_type 4148 (chip, lun, 4149 SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB); 4150 else 4151 set_sense_type(chip, lun, 4152 SENSE_TYPE_MG_WRITE_ERR); 4153 } else { 4154 set_sense_type(chip, lun, SENSE_TYPE_MG_WRITE_ERR); 4155 } 4156 goto set_ICV_finish; 4157 } 4158 4159 #ifdef MG_SET_ICV_SLOW 4160 for (i = 0; i < 2; i++) { 4161 udelay(50); 4162 4163 rtsx_init_cmd(chip); 4164 4165 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 4166 0xFF, PRO_WRITE_LONG_DATA); 4167 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, WAIT_INT); 4168 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 4169 0x01, RING_BUFFER); 4170 4171 trans_dma_enable(DMA_TO_DEVICE, chip, 512, DMA_512); 4172 4173 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 0xFF, 4174 MS_TRANSFER_START | MS_TM_NORMAL_WRITE); 4175 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER, 4176 MS_TRANSFER_END, MS_TRANSFER_END); 4177 4178 rtsx_send_cmd_no_wait(chip); 4179 4180 retval = rtsx_transfer_data(chip, MS_CARD, buf + 4 + i * 512, 4181 512, 0, DMA_TO_DEVICE, 3000); 4182 if ((retval < 0) || check_ms_err(chip)) { 4183 rtsx_clear_ms_error(chip); 4184 if (ms_card->mg_auth == 0) { 4185 if ((buf[5] & 0xC0) != 0) 4186 set_sense_type 4187 (chip, lun, 4188 SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB); 4189 else 4190 set_sense_type(chip, lun, 4191 SENSE_TYPE_MG_WRITE_ERR); 4192 } else { 4193 set_sense_type(chip, lun, 4194 SENSE_TYPE_MG_WRITE_ERR); 4195 } 4196 retval = STATUS_FAIL; 4197 goto set_ICV_finish; 4198 } 4199 } 4200 #else 4201 retval = ms_transfer_data(chip, MS_TM_AUTO_WRITE, PRO_WRITE_LONG_DATA, 4202 2, WAIT_INT, 0, 0, buf + 4, 1024); 4203 if ((retval != STATUS_SUCCESS) || check_ms_err(chip)) { 4204 rtsx_clear_ms_error(chip); 4205 if (ms_card->mg_auth == 0) { 4206 if ((buf[5] & 0xC0) != 0) 4207 set_sense_type 4208 (chip, lun, 4209 SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB); 4210 else 4211 set_sense_type(chip, lun, 4212 SENSE_TYPE_MG_WRITE_ERR); 4213 } else { 4214 set_sense_type(chip, lun, SENSE_TYPE_MG_WRITE_ERR); 4215 } 4216 goto set_ICV_finish; 4217 } 4218 #endif 4219 4220 set_ICV_finish: 4221 kfree(buf); 4222 return retval; 4223 } 4224 4225 #endif /* SUPPORT_MAGIC_GATE */ 4226 4227 void ms_cleanup_work(struct rtsx_chip *chip) 4228 { 4229 struct ms_info *ms_card = &chip->ms_card; 4230 4231 if (CHK_MSPRO(ms_card)) { 4232 if (ms_card->seq_mode) { 4233 dev_dbg(rtsx_dev(chip), "MS Pro: stop transmission\n"); 4234 mspro_stop_seq_mode(chip); 4235 ms_card->cleanup_counter = 0; 4236 } 4237 if (CHK_MSHG(ms_card)) { 4238 rtsx_write_register(chip, MS_CFG, 4239 MS_2K_SECTOR_MODE, 0x00); 4240 } 4241 } 4242 #ifdef MS_DELAY_WRITE 4243 else if ((!CHK_MSPRO(ms_card)) && 4244 ms_card->delay_write.delay_write_flag) { 4245 dev_dbg(rtsx_dev(chip), "MS: delay write\n"); 4246 ms_delay_write(chip); 4247 ms_card->cleanup_counter = 0; 4248 } 4249 #endif 4250 } 4251 4252 int ms_power_off_card3v3(struct rtsx_chip *chip) 4253 { 4254 int retval; 4255 4256 retval = disable_card_clock(chip, MS_CARD); 4257 if (retval != STATUS_SUCCESS) 4258 return STATUS_FAIL; 4259 4260 if (chip->asic_code) { 4261 retval = ms_pull_ctl_disable(chip); 4262 if (retval != STATUS_SUCCESS) 4263 return STATUS_FAIL; 4264 } else { 4265 retval = rtsx_write_register(chip, FPGA_PULL_CTL, 4266 FPGA_MS_PULL_CTL_BIT | 0x20, 4267 FPGA_MS_PULL_CTL_BIT); 4268 if (retval) 4269 return retval; 4270 } 4271 retval = rtsx_write_register(chip, CARD_OE, MS_OUTPUT_EN, 0); 4272 if (retval) 4273 return retval; 4274 4275 if (!chip->ft2_fast_mode) { 4276 retval = card_power_off(chip, MS_CARD); 4277 if (retval != STATUS_SUCCESS) 4278 return STATUS_FAIL; 4279 } 4280 4281 return STATUS_SUCCESS; 4282 } 4283 4284 int release_ms_card(struct rtsx_chip *chip) 4285 { 4286 struct ms_info *ms_card = &chip->ms_card; 4287 int retval; 4288 4289 #ifdef MS_DELAY_WRITE 4290 ms_card->delay_write.delay_write_flag = 0; 4291 #endif 4292 ms_card->pro_under_formatting = 0; 4293 4294 chip->card_ready &= ~MS_CARD; 4295 chip->card_fail &= ~MS_CARD; 4296 chip->card_wp &= ~MS_CARD; 4297 4298 ms_free_l2p_tbl(chip); 4299 4300 memset(ms_card->raw_sys_info, 0, 96); 4301 #ifdef SUPPORT_PCGL_1P18 4302 memset(ms_card->raw_model_name, 0, 48); 4303 #endif 4304 4305 retval = ms_power_off_card3v3(chip); 4306 if (retval != STATUS_SUCCESS) 4307 return STATUS_FAIL; 4308 4309 return STATUS_SUCCESS; 4310 } 4311