+41 -91

drivers/mfd/rtsx_pcr.c

reviewed

··· 338 338 int num_sg, bool read, int timeout) 339 339 { 340 340 struct completion trans_done; 341 341 - int err = 0, count; 341 341 + u8 dir; 342 342 + int err = 0, i, count; 342 343 long timeleft; 343 344 unsigned long flags; 345 345 + struct scatterlist *sg; 346 346 + enum dma_data_direction dma_dir; 347 347 + u32 val; 348 348 + dma_addr_t addr; 349 349 + unsigned int len; 344 350 345 345 - count = rtsx_pci_dma_map_sg(pcr, sglist, num_sg, read); 351 351 + dev_dbg(&(pcr->pci->dev), "--> %s: num_sg = %d\n", __func__, num_sg); 352 352 + 353 353 + /* don't transfer data during abort processing */ 354 354 + if (pcr->remove_pci) 355 355 + return -EINVAL; 356 356 + 357 357 + if ((sglist == NULL) || (num_sg <= 0)) 358 358 + return -EINVAL; 359 359 + 360 360 + if (read) { 361 361 + dir = DEVICE_TO_HOST; 362 362 + dma_dir = DMA_FROM_DEVICE; 363 363 + } else { 364 364 + dir = HOST_TO_DEVICE; 365 365 + dma_dir = DMA_TO_DEVICE; 366 366 + } 367 367 + 368 368 + count = dma_map_sg(&(pcr->pci->dev), sglist, num_sg, dma_dir); 346 369 if (count < 1) { 347 370 dev_err(&(pcr->pci->dev), "scatterlist map failed\n"); 348 371 return -EINVAL; 349 372 } 350 373 dev_dbg(&(pcr->pci->dev), "DMA mapping count: %d\n", count); 351 374 375 375 + val = ((u32)(dir & 0x01) << 29) | TRIG_DMA | ADMA_MODE; 376 376 + pcr->sgi = 0; 377 377 + for_each_sg(sglist, sg, count, i) { 378 378 + addr = sg_dma_address(sg); 379 379 + len = sg_dma_len(sg); 380 380 + rtsx_pci_add_sg_tbl(pcr, addr, len, i == count - 1); 381 381 + } 352 382 353 383 spin_lock_irqsave(&pcr->lock, flags); 354 384 355 385 pcr->done = &trans_done; 356 386 pcr->trans_result = TRANS_NOT_READY; 357 387 init_completion(&trans_done); 388 388 + rtsx_pci_writel(pcr, RTSX_HDBAR, pcr->host_sg_tbl_addr); 389 389 + rtsx_pci_writel(pcr, RTSX_HDBCTLR, val); 358 390 359 391 spin_unlock_irqrestore(&pcr->lock, flags); 360 360 - 361 361 - rtsx_pci_dma_transfer(pcr, sglist, count, read); 362 392 363 393 timeleft = wait_for_completion_interruptible_timeout( 364 394 &trans_done, msecs_to_jiffies(timeout)); ··· 413 383 pcr->done = NULL; 414 384 spin_unlock_irqrestore(&pcr->lock, flags); 415 385 416 416 - rtsx_pci_dma_unmap_sg(pcr, sglist, num_sg, read); 386 386 + dma_unmap_sg(&(pcr->pci->dev), sglist, num_sg, dma_dir); 417 387 418 388 if ((err < 0) && (err != -ENODEV)) 419 389 rtsx_pci_stop_cmd(pcr); ··· 424 394 return err; 425 395 } 426 396 EXPORT_SYMBOL_GPL(rtsx_pci_transfer_data); 427 427 - 428 428 - int rtsx_pci_dma_map_sg(struct rtsx_pcr *pcr, struct scatterlist *sglist, 429 429 - int num_sg, bool read) 430 430 - { 431 431 - enum dma_data_direction dir = read ? DMA_FROM_DEVICE : DMA_TO_DEVICE; 432 432 - 433 433 - if (pcr->remove_pci) 434 434 - return -EINVAL; 435 435 - 436 436 - if ((sglist == NULL) || num_sg < 1) 437 437 - return -EINVAL; 438 438 - 439 439 - return dma_map_sg(&(pcr->pci->dev), sglist, num_sg, dir); 440 440 - } 441 441 - EXPORT_SYMBOL_GPL(rtsx_pci_dma_map_sg); 442 442 - 443 443 - int rtsx_pci_dma_unmap_sg(struct rtsx_pcr *pcr, struct scatterlist *sglist, 444 444 - int num_sg, bool read) 445 445 - { 446 446 - enum dma_data_direction dir = read ? DMA_FROM_DEVICE : DMA_TO_DEVICE; 447 447 - 448 448 - if (pcr->remove_pci) 449 449 - return -EINVAL; 450 450 - 451 451 - if (sglist == NULL || num_sg < 1) 452 452 - return -EINVAL; 453 453 - 454 454 - dma_unmap_sg(&(pcr->pci->dev), sglist, num_sg, dir); 455 455 - return num_sg; 456 456 - } 457 457 - EXPORT_SYMBOL_GPL(rtsx_pci_dma_unmap_sg); 458 458 - 459 459 - int rtsx_pci_dma_transfer(struct rtsx_pcr *pcr, struct scatterlist *sglist, 460 460 - int sg_count, bool read) 461 461 - { 462 462 - struct scatterlist *sg; 463 463 - dma_addr_t addr; 464 464 - unsigned int len; 465 465 - int i; 466 466 - u32 val; 467 467 - u8 dir = read ? DEVICE_TO_HOST : HOST_TO_DEVICE; 468 468 - unsigned long flags; 469 469 - 470 470 - if (pcr->remove_pci) 471 471 - return -EINVAL; 472 472 - 473 473 - if ((sglist == NULL) || (sg_count < 1)) 474 474 - return -EINVAL; 475 475 - 476 476 - val = ((u32)(dir & 0x01) << 29) | TRIG_DMA | ADMA_MODE; 477 477 - pcr->sgi = 0; 478 478 - for_each_sg(sglist, sg, sg_count, i) { 479 479 - addr = sg_dma_address(sg); 480 480 - len = sg_dma_len(sg); 481 481 - rtsx_pci_add_sg_tbl(pcr, addr, len, i == sg_count - 1); 482 482 - } 483 483 - 484 484 - spin_lock_irqsave(&pcr->lock, flags); 485 485 - 486 486 - rtsx_pci_writel(pcr, RTSX_HDBAR, pcr->host_sg_tbl_addr); 487 487 - rtsx_pci_writel(pcr, RTSX_HDBCTLR, val); 488 488 - 489 489 - spin_unlock_irqrestore(&pcr->lock, flags); 490 490 - 491 491 - return 0; 492 492 - } 493 493 - EXPORT_SYMBOL_GPL(rtsx_pci_dma_transfer); 494 397 495 398 int rtsx_pci_read_ppbuf(struct rtsx_pcr *pcr, u8 *buf, int buf_len) 496 399 { ··· 836 873 int_reg = rtsx_pci_readl(pcr, RTSX_BIPR); 837 874 /* Clear interrupt flag */ 838 875 rtsx_pci_writel(pcr, RTSX_BIPR, int_reg); 839 839 - dev_dbg(&pcr->pci->dev, "=========== BIPR 0x%8x ==========\n", int_reg); 840 840 - 841 876 if ((int_reg & pcr->bier) == 0) { 842 877 spin_unlock(&pcr->lock); 843 878 return IRQ_NONE; ··· 866 905 } 867 906 868 907 if (int_reg & (NEED_COMPLETE_INT | DELINK_INT)) { 869 869 - if (int_reg & (TRANS_FAIL_INT | DELINK_INT)) 908 908 + if (int_reg & (TRANS_FAIL_INT | DELINK_INT)) { 870 909 pcr->trans_result = TRANS_RESULT_FAIL; 871 871 - else if (int_reg & TRANS_OK_INT) 910 910 + if (pcr->done) 911 911 + complete(pcr->done); 912 912 + } else if (int_reg & TRANS_OK_INT) { 872 913 pcr->trans_result = TRANS_RESULT_OK; 873 873 - 874 874 - if (pcr->done) 875 875 - complete(pcr->done); 876 876 - 877 877 - if (int_reg & SD_EXIST) { 878 878 - struct rtsx_slot *slot = &pcr->slots[RTSX_SD_CARD]; 879 879 - if (slot && slot->done_transfer) 880 880 - slot->done_transfer(slot->p_dev); 881 881 - } 882 882 - 883 883 - if (int_reg & MS_EXIST) { 884 884 - struct rtsx_slot *slot = &pcr->slots[RTSX_SD_CARD]; 885 885 - if (slot && slot->done_transfer) 886 886 - slot->done_transfer(slot->p_dev); 914 914 + if (pcr->done) 915 915 + complete(pcr->done); 887 916 } 888 917 } 889 889 - 890 918 891 919 if (pcr->card_inserted || pcr->card_removed) 892 920 schedule_delayed_work(&pcr->carddet_work,

+66 -348

drivers/mmc/host/rtsx_pci_sdmmc.c

reviewed

··· 31 31 #include <linux/mfd/rtsx_pci.h> 32 32 #include <asm/unaligned.h> 33 33 34 34 - struct realtek_next { 35 35 - unsigned int sg_count; 36 36 - s32 cookie; 37 37 - }; 38 38 - 39 34 struct realtek_pci_sdmmc { 40 35 struct platform_device *pdev; 41 36 struct rtsx_pcr *pcr; 42 37 struct mmc_host *mmc; 43 38 struct mmc_request *mrq; 44 44 - struct mmc_command *cmd; 45 45 - struct mmc_data *data; 46 39 47 47 - spinlock_t lock; 48 48 - struct timer_list timer; 49 49 - struct tasklet_struct cmd_tasklet; 50 50 - struct tasklet_struct data_tasklet; 51 51 - struct tasklet_struct finish_tasklet; 40 40 + struct mutex host_mutex; 52 41 53 53 - u8 rsp_type; 54 54 - u8 rsp_len; 55 55 - int sg_count; 56 42 u8 ssc_depth; 57 43 unsigned int clock; 58 44 bool vpclk; ··· 48 62 int power_state; 49 63 #define SDMMC_POWER_ON 1 50 64 #define SDMMC_POWER_OFF 0 51 51 - 52 52 - struct realtek_next next_data; 53 65 }; 54 54 - 55 55 - static int sd_start_multi_rw(struct realtek_pci_sdmmc *host, 56 56 - struct mmc_request *mrq); 57 66 58 67 static inline struct device *sdmmc_dev(struct realtek_pci_sdmmc *host) 59 68 { ··· 85 104 #else 86 105 #define sd_print_debug_regs(host) 87 106 #endif /* DEBUG */ 88 88 - 89 89 - static void sd_isr_done_transfer(struct platform_device *pdev) 90 90 - { 91 91 - struct realtek_pci_sdmmc *host = platform_get_drvdata(pdev); 92 92 - 93 93 - spin_lock(&host->lock); 94 94 - if (host->cmd) 95 95 - tasklet_schedule(&host->cmd_tasklet); 96 96 - if (host->data) 97 97 - tasklet_schedule(&host->data_tasklet); 98 98 - spin_unlock(&host->lock); 99 99 - } 100 100 - 101 101 - static void sd_request_timeout(unsigned long host_addr) 102 102 - { 103 103 - struct realtek_pci_sdmmc *host = (struct realtek_pci_sdmmc *)host_addr; 104 104 - unsigned long flags; 105 105 - 106 106 - spin_lock_irqsave(&host->lock, flags); 107 107 - 108 108 - if (!host->mrq) { 109 109 - dev_err(sdmmc_dev(host), "error: no request exist\n"); 110 110 - goto out; 111 111 - } 112 112 - 113 113 - if (host->cmd) 114 114 - host->cmd->error = -ETIMEDOUT; 115 115 - if (host->data) 116 116 - host->data->error = -ETIMEDOUT; 117 117 - 118 118 - dev_dbg(sdmmc_dev(host), "timeout for request\n"); 119 119 - 120 120 - out: 121 121 - tasklet_schedule(&host->finish_tasklet); 122 122 - spin_unlock_irqrestore(&host->lock, flags); 123 123 - } 124 124 - 125 125 - static void sd_finish_request(unsigned long host_addr) 126 126 - { 127 127 - struct realtek_pci_sdmmc *host = (struct realtek_pci_sdmmc *)host_addr; 128 128 - struct rtsx_pcr *pcr = host->pcr; 129 129 - struct mmc_request *mrq; 130 130 - struct mmc_command *cmd; 131 131 - struct mmc_data *data; 132 132 - unsigned long flags; 133 133 - bool any_error; 134 134 - 135 135 - spin_lock_irqsave(&host->lock, flags); 136 136 - 137 137 - del_timer(&host->timer); 138 138 - mrq = host->mrq; 139 139 - if (!mrq) { 140 140 - dev_err(sdmmc_dev(host), "error: no request need finish\n"); 141 141 - goto out; 142 142 - } 143 143 - 144 144 - cmd = mrq->cmd; 145 145 - data = mrq->data; 146 146 - 147 147 - any_error = (mrq->sbc && mrq->sbc->error) || 148 148 - (mrq->stop && mrq->stop->error) || 149 149 - (cmd && cmd->error) || (data && data->error); 150 150 - 151 151 - if (any_error) { 152 152 - rtsx_pci_stop_cmd(pcr); 153 153 - sd_clear_error(host); 154 154 - } 155 155 - 156 156 - if (data) { 157 157 - if (any_error) 158 158 - data->bytes_xfered = 0; 159 159 - else 160 160 - data->bytes_xfered = data->blocks * data->blksz; 161 161 - 162 162 - if (!data->host_cookie) 163 163 - rtsx_pci_dma_unmap_sg(pcr, data->sg, data->sg_len, 164 164 - data->flags & MMC_DATA_READ); 165 165 - 166 166 - } 167 167 - 168 168 - host->mrq = NULL; 169 169 - host->cmd = NULL; 170 170 - host->data = NULL; 171 171 - 172 172 - out: 173 173 - spin_unlock_irqrestore(&host->lock, flags); 174 174 - mutex_unlock(&pcr->pcr_mutex); 175 175 - mmc_request_done(host->mmc, mrq); 176 176 - } 177 107 178 108 static int sd_read_data(struct realtek_pci_sdmmc *host, u8 *cmd, u16 byte_cnt, 179 109 u8 *buf, int buf_len, int timeout) ··· 203 311 return 0; 204 312 } 205 313 206 206 - static void sd_send_cmd(struct realtek_pci_sdmmc *host, struct mmc_command *cmd) 314 314 + static void sd_send_cmd_get_rsp(struct realtek_pci_sdmmc *host, 315 315 + struct mmc_command *cmd) 207 316 { 208 317 struct rtsx_pcr *pcr = host->pcr; 209 318 u8 cmd_idx = (u8)cmd->opcode; ··· 212 319 int err = 0; 213 320 int timeout = 100; 214 321 int i; 322 322 + u8 *ptr; 323 323 + int stat_idx = 0; 215 324 u8 rsp_type; 216 325 int rsp_len = 5; 217 217 - unsigned long flags; 218 218 - 219 219 - if (host->cmd) 220 220 - dev_err(sdmmc_dev(host), "error: cmd already exist\n"); 221 221 - 222 222 - host->cmd = cmd; 326 326 + bool clock_toggled = false; 223 327 224 328 dev_dbg(sdmmc_dev(host), "%s: SD/MMC CMD %d, arg = 0x%08x\n", 225 329 __func__, cmd_idx, arg); ··· 251 361 err = -EINVAL; 252 362 goto out; 253 363 } 254 254 - host->rsp_type = rsp_type; 255 255 - host->rsp_len = rsp_len; 256 364 257 365 if (rsp_type == SD_RSP_TYPE_R1b) 258 366 timeout = 3000; ··· 260 372 0xFF, SD_CLK_TOGGLE_EN); 261 373 if (err < 0) 262 374 goto out; 375 375 + 376 376 + clock_toggled = true; 263 377 } 264 378 265 379 rtsx_pci_init_cmd(pcr); ··· 285 395 /* Read data from ping-pong buffer */ 286 396 for (i = PPBUF_BASE2; i < PPBUF_BASE2 + 16; i++) 287 397 rtsx_pci_add_cmd(pcr, READ_REG_CMD, (u16)i, 0, 0); 398 398 + stat_idx = 16; 288 399 } else if (rsp_type != SD_RSP_TYPE_R0) { 289 400 /* Read data from SD_CMDx registers */ 290 401 for (i = SD_CMD0; i <= SD_CMD4; i++) 291 402 rtsx_pci_add_cmd(pcr, READ_REG_CMD, (u16)i, 0, 0); 403 403 + stat_idx = 5; 292 404 } 293 405 294 406 rtsx_pci_add_cmd(pcr, READ_REG_CMD, SD_STAT1, 0, 0); 295 407 296 296 - mod_timer(&host->timer, jiffies + msecs_to_jiffies(timeout)); 297 297 - 298 298 - spin_lock_irqsave(&pcr->lock, flags); 299 299 - pcr->trans_result = TRANS_NOT_READY; 300 300 - rtsx_pci_send_cmd_no_wait(pcr); 301 301 - spin_unlock_irqrestore(&pcr->lock, flags); 302 302 - 303 303 - return; 304 304 - 305 305 - out: 306 306 - cmd->error = err; 307 307 - tasklet_schedule(&host->finish_tasklet); 308 308 - } 309 309 - 310 310 - static void sd_get_rsp(unsigned long host_addr) 311 311 - { 312 312 - struct realtek_pci_sdmmc *host = (struct realtek_pci_sdmmc *)host_addr; 313 313 - struct rtsx_pcr *pcr = host->pcr; 314 314 - struct mmc_command *cmd; 315 315 - int i, err = 0, stat_idx; 316 316 - u8 *ptr, rsp_type; 317 317 - unsigned long flags; 318 318 - 319 319 - spin_lock_irqsave(&host->lock, flags); 320 320 - 321 321 - cmd = host->cmd; 322 322 - host->cmd = NULL; 323 323 - 324 324 - if (!cmd) { 325 325 - dev_err(sdmmc_dev(host), "error: cmd not exist\n"); 408 408 + err = rtsx_pci_send_cmd(pcr, timeout); 409 409 + if (err < 0) { 410 410 + sd_print_debug_regs(host); 411 411 + sd_clear_error(host); 412 412 + dev_dbg(sdmmc_dev(host), 413 413 + "rtsx_pci_send_cmd error (err = %d)\n", err); 326 414 goto out; 327 415 } 328 328 - 329 329 - spin_lock(&pcr->lock); 330 330 - if (pcr->trans_result == TRANS_NO_DEVICE) 331 331 - err = -ENODEV; 332 332 - else if (pcr->trans_result != TRANS_RESULT_OK) 333 333 - err = -EINVAL; 334 334 - spin_unlock(&pcr->lock); 335 335 - 336 336 - if (err < 0) 337 337 - goto out; 338 338 - 339 339 - rsp_type = host->rsp_type; 340 340 - stat_idx = host->rsp_len; 341 416 342 417 if (rsp_type == SD_RSP_TYPE_R0) { 343 418 err = 0; ··· 340 485 cmd->resp[0]); 341 486 } 342 487 343 343 - if (cmd == host->mrq->sbc) { 344 344 - sd_send_cmd(host, host->mrq->cmd); 345 345 - spin_unlock_irqrestore(&host->lock, flags); 346 346 - return; 347 347 - } 348 348 - 349 349 - if (cmd == host->mrq->stop) 350 350 - goto out; 351 351 - 352 352 - if (cmd->data) { 353 353 - sd_start_multi_rw(host, host->mrq); 354 354 - spin_unlock_irqrestore(&host->lock, flags); 355 355 - return; 356 356 - } 357 357 - 358 488 out: 359 489 cmd->error = err; 360 490 361 361 - tasklet_schedule(&host->finish_tasklet); 362 362 - spin_unlock_irqrestore(&host->lock, flags); 491 491 + if (err && clock_toggled) 492 492 + rtsx_pci_write_register(pcr, SD_BUS_STAT, 493 493 + SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, 0); 363 494 } 364 495 365 365 - static int sd_pre_dma_transfer(struct realtek_pci_sdmmc *host, 366 366 - struct mmc_data *data, struct realtek_next *next) 367 367 - { 368 368 - struct rtsx_pcr *pcr = host->pcr; 369 369 - int read = data->flags & MMC_DATA_READ; 370 370 - int sg_count = 0; 371 371 - 372 372 - if (!next && data->host_cookie && 373 373 - data->host_cookie != host->next_data.cookie) { 374 374 - dev_err(sdmmc_dev(host), 375 375 - "error: invalid cookie data[%d] host[%d]\n", 376 376 - data->host_cookie, host->next_data.cookie); 377 377 - data->host_cookie = 0; 378 378 - } 379 379 - 380 380 - if (next || (!next && data->host_cookie != host->next_data.cookie)) 381 381 - sg_count = rtsx_pci_dma_map_sg(pcr, 382 382 - data->sg, data->sg_len, read); 383 383 - else 384 384 - sg_count = host->next_data.sg_count; 385 385 - 386 386 - if (next) { 387 387 - next->sg_count = sg_count; 388 388 - if (++next->cookie < 0) 389 389 - next->cookie = 1; 390 390 - data->host_cookie = next->cookie; 391 391 - } 392 392 - 393 393 - return sg_count; 394 394 - } 395 395 - 396 396 - static void sdmmc_pre_req(struct mmc_host *mmc, struct mmc_request *mrq, 397 397 - bool is_first_req) 398 398 - { 399 399 - struct realtek_pci_sdmmc *host = mmc_priv(mmc); 400 400 - struct mmc_data *data = mrq->data; 401 401 - 402 402 - if (data->host_cookie) { 403 403 - dev_err(sdmmc_dev(host), 404 404 - "error: descard already cookie data[%d]\n", 405 405 - data->host_cookie); 406 406 - data->host_cookie = 0; 407 407 - } 408 408 - 409 409 - dev_dbg(sdmmc_dev(host), "dma sg prepared: %d\n", 410 410 - sd_pre_dma_transfer(host, data, &host->next_data)); 411 411 - } 412 412 - 413 413 - static void sdmmc_post_req(struct mmc_host *mmc, struct mmc_request *mrq, 414 414 - int err) 415 415 - { 416 416 - struct realtek_pci_sdmmc *host = mmc_priv(mmc); 417 417 - struct rtsx_pcr *pcr = host->pcr; 418 418 - struct mmc_data *data = mrq->data; 419 419 - int read = data->flags & MMC_DATA_READ; 420 420 - 421 421 - rtsx_pci_dma_unmap_sg(pcr, data->sg, data->sg_len, read); 422 422 - data->host_cookie = 0; 423 423 - } 424 424 - 425 425 - static int sd_start_multi_rw(struct realtek_pci_sdmmc *host, 426 426 - struct mmc_request *mrq) 496 496 + static int sd_rw_multi(struct realtek_pci_sdmmc *host, struct mmc_request *mrq) 427 497 { 428 498 struct rtsx_pcr *pcr = host->pcr; 429 499 struct mmc_host *mmc = host->mmc; 430 500 struct mmc_card *card = mmc->card; 431 501 struct mmc_data *data = mrq->data; 432 502 int uhs = mmc_card_uhs(card); 433 433 - int read = data->flags & MMC_DATA_READ; 503 503 + int read = (data->flags & MMC_DATA_READ) ? 1 : 0; 434 504 u8 cfg2, trans_mode; 435 505 int err; 436 506 size_t data_len = data->blksz * data->blocks; 437 437 - 438 438 - if (host->data) 439 439 - dev_err(sdmmc_dev(host), "error: data already exist\n"); 440 440 - 441 441 - host->data = data; 442 507 443 508 if (read) { 444 509 cfg2 = SD_CALCULATE_CRC7 | SD_CHECK_CRC16 | ··· 410 635 rtsx_pci_add_cmd(pcr, CHECK_REG_CMD, SD_TRANSFER, 411 636 SD_TRANSFER_END, SD_TRANSFER_END); 412 637 413 413 - mod_timer(&host->timer, jiffies + 10 * HZ); 414 638 rtsx_pci_send_cmd_no_wait(pcr); 415 639 416 416 - err = rtsx_pci_dma_transfer(pcr, data->sg, host->sg_count, read); 640 640 + err = rtsx_pci_transfer_data(pcr, data->sg, data->sg_len, read, 10000); 417 641 if (err < 0) { 418 418 - data->error = err; 419 419 - tasklet_schedule(&host->finish_tasklet); 642 642 + sd_clear_error(host); 643 643 + return err; 420 644 } 645 645 + 421 646 return 0; 422 422 - } 423 423 - 424 424 - static void sd_finish_multi_rw(unsigned long host_addr) 425 425 - { 426 426 - struct realtek_pci_sdmmc *host = (struct realtek_pci_sdmmc *)host_addr; 427 427 - struct rtsx_pcr *pcr = host->pcr; 428 428 - struct mmc_data *data; 429 429 - int err = 0; 430 430 - unsigned long flags; 431 431 - 432 432 - spin_lock_irqsave(&host->lock, flags); 433 433 - 434 434 - if (!host->data) { 435 435 - dev_err(sdmmc_dev(host), "error: no data exist\n"); 436 436 - goto out; 437 437 - } 438 438 - 439 439 - data = host->data; 440 440 - host->data = NULL; 441 441 - 442 442 - if (pcr->trans_result == TRANS_NO_DEVICE) 443 443 - err = -ENODEV; 444 444 - else if (pcr->trans_result != TRANS_RESULT_OK) 445 445 - err = -EINVAL; 446 446 - 447 447 - if (err < 0) { 448 448 - data->error = err; 449 449 - goto out; 450 450 - } 451 451 - 452 452 - if (!host->mrq->sbc && data->stop) { 453 453 - sd_send_cmd(host, data->stop); 454 454 - spin_unlock_irqrestore(&host->lock, flags); 455 455 - return; 456 456 - } 457 457 - 458 458 - out: 459 459 - tasklet_schedule(&host->finish_tasklet); 460 460 - spin_unlock_irqrestore(&host->lock, flags); 461 647 } 462 648 463 649 static inline void sd_enable_initial_mode(struct realtek_pci_sdmmc *host) ··· 637 901 return 0; 638 902 } 639 903 640 640 - static inline bool sd_use_muti_rw(struct mmc_command *cmd) 641 641 - { 642 642 - return mmc_op_multi(cmd->opcode) || 643 643 - (cmd->opcode == MMC_READ_SINGLE_BLOCK) || 644 644 - (cmd->opcode == MMC_WRITE_BLOCK); 645 645 - } 646 646 - 647 904 static void sdmmc_request(struct mmc_host *mmc, struct mmc_request *mrq) 648 905 { 649 906 struct realtek_pci_sdmmc *host = mmc_priv(mmc); ··· 645 916 struct mmc_data *data = mrq->data; 646 917 unsigned int data_size = 0; 647 918 int err; 648 648 - unsigned long flags; 649 649 - 650 650 - mutex_lock(&pcr->pcr_mutex); 651 651 - spin_lock_irqsave(&host->lock, flags); 652 652 - 653 653 - if (host->mrq) 654 654 - dev_err(sdmmc_dev(host), "error: request already exist\n"); 655 655 - host->mrq = mrq; 656 919 657 920 if (host->eject) { 658 921 cmd->error = -ENOMEDIUM; ··· 657 936 goto finish; 658 937 } 659 938 939 939 + mutex_lock(&pcr->pcr_mutex); 940 940 + 660 941 rtsx_pci_start_run(pcr); 661 942 662 943 rtsx_pci_switch_clock(pcr, host->clock, host->ssc_depth, ··· 667 944 rtsx_pci_write_register(pcr, CARD_SHARE_MODE, 668 945 CARD_SHARE_MASK, CARD_SHARE_48_SD); 669 946 947 947 + mutex_lock(&host->host_mutex); 948 948 + host->mrq = mrq; 949 949 + mutex_unlock(&host->host_mutex); 950 950 + 670 951 if (mrq->data) 671 952 data_size = data->blocks * data->blksz; 672 953 673 673 - if (sd_use_muti_rw(cmd)) 674 674 - host->sg_count = sd_pre_dma_transfer(host, data, NULL); 954 954 + if (!data_size || mmc_op_multi(cmd->opcode) || 955 955 + (cmd->opcode == MMC_READ_SINGLE_BLOCK) || 956 956 + (cmd->opcode == MMC_WRITE_BLOCK)) { 957 957 + sd_send_cmd_get_rsp(host, cmd); 675 958 676 676 - if (!data_size || sd_use_muti_rw(cmd)) { 677 677 - if (mrq->sbc) 678 678 - sd_send_cmd(host, mrq->sbc); 679 679 - else 680 680 - sd_send_cmd(host, cmd); 681 681 - spin_unlock_irqrestore(&host->lock, flags); 959 959 + if (!cmd->error && data_size) { 960 960 + sd_rw_multi(host, mrq); 961 961 + 962 962 + if (mmc_op_multi(cmd->opcode) && mrq->stop) 963 963 + sd_send_cmd_get_rsp(host, mrq->stop); 964 964 + } 682 965 } else { 683 683 - spin_unlock_irqrestore(&host->lock, flags); 684 966 sd_normal_rw(host, mrq); 685 685 - tasklet_schedule(&host->finish_tasklet); 686 967 } 687 687 - return; 968 968 + 969 969 + if (mrq->data) { 970 970 + if (cmd->error || data->error) 971 971 + data->bytes_xfered = 0; 972 972 + else 973 973 + data->bytes_xfered = data->blocks * data->blksz; 974 974 + } 975 975 + 976 976 + mutex_unlock(&pcr->pcr_mutex); 688 977 689 978 finish: 690 690 - tasklet_schedule(&host->finish_tasklet); 691 691 - spin_unlock_irqrestore(&host->lock, flags); 979 979 + if (cmd->error) 980 980 + dev_dbg(sdmmc_dev(host), "cmd->error = %d\n", cmd->error); 981 981 + 982 982 + mutex_lock(&host->host_mutex); 983 983 + host->mrq = NULL; 984 984 + mutex_unlock(&host->host_mutex); 985 985 + 986 986 + mmc_request_done(mmc, mrq); 692 987 } 693 988 694 989 static int sd_set_bus_width(struct realtek_pci_sdmmc *host, ··· 1141 1400 } 1142 1401 1143 1402 static const struct mmc_host_ops realtek_pci_sdmmc_ops = { 1144 1144 - .pre_req = sdmmc_pre_req, 1145 1145 - .post_req = sdmmc_post_req, 1146 1403 .request = sdmmc_request, 1147 1404 .set_ios = sdmmc_set_ios, 1148 1405 .get_ro = sdmmc_get_ro, ··· 1204 1465 struct realtek_pci_sdmmc *host; 1205 1466 struct rtsx_pcr *pcr; 1206 1467 struct pcr_handle *handle = pdev->dev.platform_data; 1207 1207 - unsigned long host_addr; 1208 1468 1209 1469 if (!handle) 1210 1470 return -ENXIO; ··· 1227 1489 pcr->slots[RTSX_SD_CARD].p_dev = pdev; 1228 1490 pcr->slots[RTSX_SD_CARD].card_event = rtsx_pci_sdmmc_card_event; 1229 1491 1230 1230 - host_addr = (unsigned long)host; 1231 1231 - host->next_data.cookie = 1; 1232 1232 - setup_timer(&host->timer, sd_request_timeout, host_addr); 1233 1233 - tasklet_init(&host->cmd_tasklet, sd_get_rsp, host_addr); 1234 1234 - tasklet_init(&host->data_tasklet, sd_finish_multi_rw, host_addr); 1235 1235 - tasklet_init(&host->finish_tasklet, sd_finish_request, host_addr); 1236 1236 - spin_lock_init(&host->lock); 1492 1492 + mutex_init(&host->host_mutex); 1237 1493 1238 1238 - pcr->slots[RTSX_SD_CARD].done_transfer = sd_isr_done_transfer; 1239 1494 realtek_init_host(host); 1240 1495 1241 1496 mmc_add_host(mmc); ··· 1241 1510 struct realtek_pci_sdmmc *host = platform_get_drvdata(pdev); 1242 1511 struct rtsx_pcr *pcr; 1243 1512 struct mmc_host *mmc; 1244 1244 - struct mmc_request *mrq; 1245 1245 - unsigned long flags; 1246 1513 1247 1514 if (!host) 1248 1515 return 0; ··· 1248 1519 pcr = host->pcr; 1249 1520 pcr->slots[RTSX_SD_CARD].p_dev = NULL; 1250 1521 pcr->slots[RTSX_SD_CARD].card_event = NULL; 1251 1251 - pcr->slots[RTSX_SD_CARD].done_transfer = NULL; 1252 1522 mmc = host->mmc; 1253 1253 - mrq = host->mrq; 1254 1523 1255 1255 - spin_lock_irqsave(&host->lock, flags); 1524 1524 + mutex_lock(&host->host_mutex); 1256 1525 if (host->mrq) { 1257 1526 dev_dbg(&(pdev->dev), 1258 1527 "%s: Controller removed during transfer\n", 1259 1528 mmc_hostname(mmc)); 1260 1529 1261 1261 - if (mrq->sbc) 1262 1262 - mrq->sbc->error = -ENOMEDIUM; 1263 1263 - if (mrq->cmd) 1264 1264 - mrq->cmd->error = -ENOMEDIUM; 1265 1265 - if (mrq->stop) 1266 1266 - mrq->stop->error = -ENOMEDIUM; 1267 1267 - if (mrq->data) 1268 1268 - mrq->data->error = -ENOMEDIUM; 1530 1530 + rtsx_pci_complete_unfinished_transfer(pcr); 1269 1531 1270 1270 - tasklet_schedule(&host->finish_tasklet); 1532 1532 + host->mrq->cmd->error = -ENOMEDIUM; 1533 1533 + if (host->mrq->stop) 1534 1534 + host->mrq->stop->error = -ENOMEDIUM; 1535 1535 + mmc_request_done(mmc, host->mrq); 1271 1536 } 1272 1272 - spin_unlock_irqrestore(&host->lock, flags); 1273 1273 - 1274 1274 - del_timer_sync(&host->timer); 1275 1275 - tasklet_kill(&host->cmd_tasklet); 1276 1276 - tasklet_kill(&host->data_tasklet); 1277 1277 - tasklet_kill(&host->finish_tasklet); 1537 1537 + mutex_unlock(&host->host_mutex); 1278 1538 1279 1539 mmc_remove_host(mmc); 1280 1540 host->eject = true;

-1

include/linux/mfd/rtsx_common.h

reviewed

··· 45 45 struct rtsx_slot { 46 46 struct platform_device *p_dev; 47 47 void (*card_event)(struct platform_device *p_dev); 48 48 - void (*done_transfer)(struct platform_device *p_dev); 49 48 }; 50 49 51 50 #endif

-6

include/linux/mfd/rtsx_pci.h

reviewed

··· 943 943 int rtsx_pci_send_cmd(struct rtsx_pcr *pcr, int timeout); 944 944 int rtsx_pci_transfer_data(struct rtsx_pcr *pcr, struct scatterlist *sglist, 945 945 int num_sg, bool read, int timeout); 946 946 - int rtsx_pci_dma_map_sg(struct rtsx_pcr *pcr, struct scatterlist *sglist, 947 947 - int num_sg, bool read); 948 948 - int rtsx_pci_dma_unmap_sg(struct rtsx_pcr *pcr, struct scatterlist *sglist, 949 949 - int num_sg, bool read); 950 950 - int rtsx_pci_dma_transfer(struct rtsx_pcr *pcr, struct scatterlist *sglist, 951 951 - int sg_count, bool read); 952 946 int rtsx_pci_read_ppbuf(struct rtsx_pcr *pcr, u8 *buf, int buf_len); 953 947 int rtsx_pci_write_ppbuf(struct rtsx_pcr *pcr, u8 *buf, int buf_len); 954 948 int rtsx_pci_card_pull_ctl_enable(struct rtsx_pcr *pcr, int card);