1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * SD/MMC Greybus driver. 4 * 5 * Copyright 2014-2015 Google Inc. 6 * Copyright 2014-2015 Linaro Ltd. 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/mmc/core.h> 11 #include <linux/mmc/host.h> 12 #include <linux/mmc/mmc.h> 13 #include <linux/scatterlist.h> 14 #include <linux/workqueue.h> 15 #include <linux/greybus.h> 16 17 #include "gbphy.h" 18 19 struct gb_sdio_host { 20 struct gb_connection *connection; 21 struct gbphy_device *gbphy_dev; 22 struct mmc_host *mmc; 23 struct mmc_request *mrq; 24 struct mutex lock; /* lock for this host */ 25 size_t data_max; 26 spinlock_t xfer; /* lock to cancel ongoing transfer */ 27 bool xfer_stop; 28 struct workqueue_struct *mrq_workqueue; 29 struct work_struct mrqwork; 30 u8 queued_events; 31 bool removed; 32 bool card_present; 33 bool read_only; 34 }; 35 36 37 #define GB_SDIO_RSP_R1_R5_R6_R7 (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \ 38 GB_SDIO_RSP_OPCODE) 39 #define GB_SDIO_RSP_R3_R4 (GB_SDIO_RSP_PRESENT) 40 #define GB_SDIO_RSP_R2 (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \ 41 GB_SDIO_RSP_136) 42 #define GB_SDIO_RSP_R1B (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \ 43 GB_SDIO_RSP_OPCODE | GB_SDIO_RSP_BUSY) 44 45 /* kernel vdd starts at 0x80 and we need to translate to greybus ones 0x01 */ 46 #define GB_SDIO_VDD_SHIFT 8 47 48 #ifndef MMC_CAP2_CORE_RUNTIME_PM 49 #define MMC_CAP2_CORE_RUNTIME_PM 0 50 #endif 51 52 static inline bool single_op(struct mmc_command *cmd) 53 { 54 u32 opcode = cmd->opcode; 55 56 return opcode == MMC_WRITE_BLOCK || 57 opcode == MMC_READ_SINGLE_BLOCK; 58 } 59 60 static void _gb_sdio_set_host_caps(struct gb_sdio_host *host, u32 r) 61 { 62 u32 caps = 0; 63 u32 caps2 = 0; 64 65 caps = ((r & GB_SDIO_CAP_NONREMOVABLE) ? MMC_CAP_NONREMOVABLE : 0) | 66 ((r & GB_SDIO_CAP_4_BIT_DATA) ? MMC_CAP_4_BIT_DATA : 0) | 67 ((r & GB_SDIO_CAP_8_BIT_DATA) ? MMC_CAP_8_BIT_DATA : 0) | 68 ((r & GB_SDIO_CAP_MMC_HS) ? MMC_CAP_MMC_HIGHSPEED : 0) | 69 ((r & GB_SDIO_CAP_SD_HS) ? MMC_CAP_SD_HIGHSPEED : 0) | 70 ((r & GB_SDIO_CAP_1_2V_DDR) ? MMC_CAP_1_2V_DDR : 0) | 71 ((r & GB_SDIO_CAP_1_8V_DDR) ? MMC_CAP_1_8V_DDR : 0) | 72 ((r & GB_SDIO_CAP_POWER_OFF_CARD) ? MMC_CAP_POWER_OFF_CARD : 0) | 73 ((r & GB_SDIO_CAP_UHS_SDR12) ? MMC_CAP_UHS_SDR12 : 0) | 74 ((r & GB_SDIO_CAP_UHS_SDR25) ? MMC_CAP_UHS_SDR25 : 0) | 75 ((r & GB_SDIO_CAP_UHS_SDR50) ? MMC_CAP_UHS_SDR50 : 0) | 76 ((r & GB_SDIO_CAP_UHS_SDR104) ? MMC_CAP_UHS_SDR104 : 0) | 77 ((r & GB_SDIO_CAP_UHS_DDR50) ? MMC_CAP_UHS_DDR50 : 0) | 78 ((r & GB_SDIO_CAP_DRIVER_TYPE_A) ? MMC_CAP_DRIVER_TYPE_A : 0) | 79 ((r & GB_SDIO_CAP_DRIVER_TYPE_C) ? MMC_CAP_DRIVER_TYPE_C : 0) | 80 ((r & GB_SDIO_CAP_DRIVER_TYPE_D) ? MMC_CAP_DRIVER_TYPE_D : 0); 81 82 caps2 = ((r & GB_SDIO_CAP_HS200_1_2V) ? MMC_CAP2_HS200_1_2V_SDR : 0) | 83 ((r & GB_SDIO_CAP_HS400_1_2V) ? MMC_CAP2_HS400_1_2V : 0) | 84 ((r & GB_SDIO_CAP_HS400_1_8V) ? MMC_CAP2_HS400_1_8V : 0) | 85 ((r & GB_SDIO_CAP_HS200_1_8V) ? MMC_CAP2_HS200_1_8V_SDR : 0); 86 87 host->mmc->caps = caps; 88 host->mmc->caps2 = caps2 | MMC_CAP2_CORE_RUNTIME_PM; 89 90 if (caps & MMC_CAP_NONREMOVABLE) 91 host->card_present = true; 92 } 93 94 static u32 _gb_sdio_get_host_ocr(u32 ocr) 95 { 96 return (((ocr & GB_SDIO_VDD_165_195) ? MMC_VDD_165_195 : 0) | 97 ((ocr & GB_SDIO_VDD_20_21) ? MMC_VDD_20_21 : 0) | 98 ((ocr & GB_SDIO_VDD_21_22) ? MMC_VDD_21_22 : 0) | 99 ((ocr & GB_SDIO_VDD_22_23) ? MMC_VDD_22_23 : 0) | 100 ((ocr & GB_SDIO_VDD_23_24) ? MMC_VDD_23_24 : 0) | 101 ((ocr & GB_SDIO_VDD_24_25) ? MMC_VDD_24_25 : 0) | 102 ((ocr & GB_SDIO_VDD_25_26) ? MMC_VDD_25_26 : 0) | 103 ((ocr & GB_SDIO_VDD_26_27) ? MMC_VDD_26_27 : 0) | 104 ((ocr & GB_SDIO_VDD_27_28) ? MMC_VDD_27_28 : 0) | 105 ((ocr & GB_SDIO_VDD_28_29) ? MMC_VDD_28_29 : 0) | 106 ((ocr & GB_SDIO_VDD_29_30) ? MMC_VDD_29_30 : 0) | 107 ((ocr & GB_SDIO_VDD_30_31) ? MMC_VDD_30_31 : 0) | 108 ((ocr & GB_SDIO_VDD_31_32) ? MMC_VDD_31_32 : 0) | 109 ((ocr & GB_SDIO_VDD_32_33) ? MMC_VDD_32_33 : 0) | 110 ((ocr & GB_SDIO_VDD_33_34) ? MMC_VDD_33_34 : 0) | 111 ((ocr & GB_SDIO_VDD_34_35) ? MMC_VDD_34_35 : 0) | 112 ((ocr & GB_SDIO_VDD_35_36) ? MMC_VDD_35_36 : 0) 113 ); 114 } 115 116 static int gb_sdio_get_caps(struct gb_sdio_host *host) 117 { 118 struct gb_sdio_get_caps_response response; 119 struct mmc_host *mmc = host->mmc; 120 u16 data_max; 121 u32 blksz; 122 u32 ocr; 123 u32 r; 124 int ret; 125 126 ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_GET_CAPABILITIES, 127 NULL, 0, &response, sizeof(response)); 128 if (ret < 0) 129 return ret; 130 r = le32_to_cpu(response.caps); 131 132 _gb_sdio_set_host_caps(host, r); 133 134 /* get the max block size that could fit our payload */ 135 data_max = gb_operation_get_payload_size_max(host->connection); 136 data_max = min(data_max - sizeof(struct gb_sdio_transfer_request), 137 data_max - sizeof(struct gb_sdio_transfer_response)); 138 139 blksz = min_t(u16, le16_to_cpu(response.max_blk_size), data_max); 140 blksz = max_t(u32, 512, blksz); 141 142 mmc->max_blk_size = rounddown_pow_of_two(blksz); 143 mmc->max_blk_count = le16_to_cpu(response.max_blk_count); 144 host->data_max = data_max; 145 146 /* get ocr supported values */ 147 ocr = _gb_sdio_get_host_ocr(le32_to_cpu(response.ocr)); 148 mmc->ocr_avail = ocr; 149 mmc->ocr_avail_sdio = mmc->ocr_avail; 150 mmc->ocr_avail_sd = mmc->ocr_avail; 151 mmc->ocr_avail_mmc = mmc->ocr_avail; 152 153 /* get frequency range values */ 154 mmc->f_min = le32_to_cpu(response.f_min); 155 mmc->f_max = le32_to_cpu(response.f_max); 156 157 return 0; 158 } 159 160 static void _gb_queue_event(struct gb_sdio_host *host, u8 event) 161 { 162 if (event & GB_SDIO_CARD_INSERTED) 163 host->queued_events &= ~GB_SDIO_CARD_REMOVED; 164 else if (event & GB_SDIO_CARD_REMOVED) 165 host->queued_events &= ~GB_SDIO_CARD_INSERTED; 166 167 host->queued_events |= event; 168 } 169 170 static int _gb_sdio_process_events(struct gb_sdio_host *host, u8 event) 171 { 172 u8 state_changed = 0; 173 174 if (event & GB_SDIO_CARD_INSERTED) { 175 if (host->mmc->caps & MMC_CAP_NONREMOVABLE) 176 return 0; 177 if (host->card_present) 178 return 0; 179 host->card_present = true; 180 state_changed = 1; 181 } 182 183 if (event & GB_SDIO_CARD_REMOVED) { 184 if (host->mmc->caps & MMC_CAP_NONREMOVABLE) 185 return 0; 186 if (!(host->card_present)) 187 return 0; 188 host->card_present = false; 189 state_changed = 1; 190 } 191 192 if (event & GB_SDIO_WP) 193 host->read_only = true; 194 195 if (state_changed) { 196 dev_info(mmc_dev(host->mmc), "card %s now event\n", 197 (host->card_present ? "inserted" : "removed")); 198 mmc_detect_change(host->mmc, 0); 199 } 200 201 return 0; 202 } 203 204 static int gb_sdio_request_handler(struct gb_operation *op) 205 { 206 struct gb_sdio_host *host = gb_connection_get_data(op->connection); 207 struct gb_message *request; 208 struct gb_sdio_event_request *payload; 209 u8 type = op->type; 210 int ret = 0; 211 u8 event; 212 213 if (type != GB_SDIO_TYPE_EVENT) { 214 dev_err(mmc_dev(host->mmc), 215 "unsupported unsolicited event: %u\n", type); 216 return -EINVAL; 217 } 218 219 request = op->request; 220 221 if (request->payload_size < sizeof(*payload)) { 222 dev_err(mmc_dev(host->mmc), "wrong event size received (%zu < %zu)\n", 223 request->payload_size, sizeof(*payload)); 224 return -EINVAL; 225 } 226 227 payload = request->payload; 228 event = payload->event; 229 230 if (host->removed) 231 _gb_queue_event(host, event); 232 else 233 ret = _gb_sdio_process_events(host, event); 234 235 return ret; 236 } 237 238 static int gb_sdio_set_ios(struct gb_sdio_host *host, 239 struct gb_sdio_set_ios_request *request) 240 { 241 int ret; 242 243 ret = gbphy_runtime_get_sync(host->gbphy_dev); 244 if (ret) 245 return ret; 246 247 ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_SET_IOS, request, 248 sizeof(*request), NULL, 0); 249 250 gbphy_runtime_put_autosuspend(host->gbphy_dev); 251 252 return ret; 253 } 254 255 static int _gb_sdio_send(struct gb_sdio_host *host, struct mmc_data *data, 256 size_t len, u16 nblocks, off_t skip) 257 { 258 struct gb_sdio_transfer_request *request; 259 struct gb_sdio_transfer_response *response; 260 struct gb_operation *operation; 261 struct scatterlist *sg = data->sg; 262 unsigned int sg_len = data->sg_len; 263 size_t copied; 264 u16 send_blksz; 265 u16 send_blocks; 266 int ret; 267 268 WARN_ON(len > host->data_max); 269 270 operation = gb_operation_create(host->connection, GB_SDIO_TYPE_TRANSFER, 271 len + sizeof(*request), 272 sizeof(*response), GFP_KERNEL); 273 if (!operation) 274 return -ENOMEM; 275 276 request = operation->request->payload; 277 request->data_flags = data->flags >> 8; 278 request->data_blocks = cpu_to_le16(nblocks); 279 request->data_blksz = cpu_to_le16(data->blksz); 280 281 copied = sg_pcopy_to_buffer(sg, sg_len, &request->data[0], len, skip); 282 283 if (copied != len) { 284 ret = -EINVAL; 285 goto err_put_operation; 286 } 287 288 ret = gb_operation_request_send_sync(operation); 289 if (ret < 0) 290 goto err_put_operation; 291 292 response = operation->response->payload; 293 294 send_blocks = le16_to_cpu(response->data_blocks); 295 send_blksz = le16_to_cpu(response->data_blksz); 296 297 if (len != send_blksz * send_blocks) { 298 dev_err(mmc_dev(host->mmc), "send: size received: %zu != %d\n", 299 len, send_blksz * send_blocks); 300 ret = -EINVAL; 301 } 302 303 err_put_operation: 304 gb_operation_put(operation); 305 306 return ret; 307 } 308 309 static int _gb_sdio_recv(struct gb_sdio_host *host, struct mmc_data *data, 310 size_t len, u16 nblocks, off_t skip) 311 { 312 struct gb_sdio_transfer_request *request; 313 struct gb_sdio_transfer_response *response; 314 struct gb_operation *operation; 315 struct scatterlist *sg = data->sg; 316 unsigned int sg_len = data->sg_len; 317 size_t copied; 318 u16 recv_blksz; 319 u16 recv_blocks; 320 int ret; 321 322 WARN_ON(len > host->data_max); 323 324 operation = gb_operation_create(host->connection, GB_SDIO_TYPE_TRANSFER, 325 sizeof(*request), 326 len + sizeof(*response), GFP_KERNEL); 327 if (!operation) 328 return -ENOMEM; 329 330 request = operation->request->payload; 331 request->data_flags = data->flags >> 8; 332 request->data_blocks = cpu_to_le16(nblocks); 333 request->data_blksz = cpu_to_le16(data->blksz); 334 335 ret = gb_operation_request_send_sync(operation); 336 if (ret < 0) 337 goto err_put_operation; 338 339 response = operation->response->payload; 340 recv_blocks = le16_to_cpu(response->data_blocks); 341 recv_blksz = le16_to_cpu(response->data_blksz); 342 343 if (len != recv_blksz * recv_blocks) { 344 dev_err(mmc_dev(host->mmc), "recv: size received: %d != %zu\n", 345 recv_blksz * recv_blocks, len); 346 ret = -EINVAL; 347 goto err_put_operation; 348 } 349 350 copied = sg_pcopy_from_buffer(sg, sg_len, &response->data[0], len, 351 skip); 352 if (copied != len) 353 ret = -EINVAL; 354 355 err_put_operation: 356 gb_operation_put(operation); 357 358 return ret; 359 } 360 361 static int gb_sdio_transfer(struct gb_sdio_host *host, struct mmc_data *data) 362 { 363 size_t left, len; 364 off_t skip = 0; 365 int ret = 0; 366 u16 nblocks; 367 368 if (single_op(data->mrq->cmd) && data->blocks > 1) { 369 ret = -ETIMEDOUT; 370 goto out; 371 } 372 373 left = data->blksz * data->blocks; 374 375 while (left) { 376 /* check is a stop transmission is pending */ 377 spin_lock(&host->xfer); 378 if (host->xfer_stop) { 379 host->xfer_stop = false; 380 spin_unlock(&host->xfer); 381 ret = -EINTR; 382 goto out; 383 } 384 spin_unlock(&host->xfer); 385 len = min(left, host->data_max); 386 nblocks = len / data->blksz; 387 len = nblocks * data->blksz; 388 389 if (data->flags & MMC_DATA_READ) { 390 ret = _gb_sdio_recv(host, data, len, nblocks, skip); 391 if (ret < 0) 392 goto out; 393 } else { 394 ret = _gb_sdio_send(host, data, len, nblocks, skip); 395 if (ret < 0) 396 goto out; 397 } 398 data->bytes_xfered += len; 399 left -= len; 400 skip += len; 401 } 402 403 out: 404 data->error = ret; 405 return ret; 406 } 407 408 static int gb_sdio_command(struct gb_sdio_host *host, struct mmc_command *cmd) 409 { 410 struct gb_sdio_command_request request = {0}; 411 struct gb_sdio_command_response response; 412 struct mmc_data *data = host->mrq->data; 413 unsigned int timeout_ms; 414 u8 cmd_flags; 415 u8 cmd_type; 416 int i; 417 int ret; 418 419 switch (mmc_resp_type(cmd)) { 420 case MMC_RSP_NONE: 421 cmd_flags = GB_SDIO_RSP_NONE; 422 break; 423 case MMC_RSP_R1: 424 cmd_flags = GB_SDIO_RSP_R1_R5_R6_R7; 425 break; 426 case MMC_RSP_R1B: 427 cmd_flags = GB_SDIO_RSP_R1B; 428 break; 429 case MMC_RSP_R2: 430 cmd_flags = GB_SDIO_RSP_R2; 431 break; 432 case MMC_RSP_R3: 433 cmd_flags = GB_SDIO_RSP_R3_R4; 434 break; 435 default: 436 dev_err(mmc_dev(host->mmc), "cmd flag invalid 0x%04x\n", 437 mmc_resp_type(cmd)); 438 ret = -EINVAL; 439 goto out; 440 } 441 442 switch (mmc_cmd_type(cmd)) { 443 case MMC_CMD_BC: 444 cmd_type = GB_SDIO_CMD_BC; 445 break; 446 case MMC_CMD_BCR: 447 cmd_type = GB_SDIO_CMD_BCR; 448 break; 449 case MMC_CMD_AC: 450 cmd_type = GB_SDIO_CMD_AC; 451 break; 452 case MMC_CMD_ADTC: 453 cmd_type = GB_SDIO_CMD_ADTC; 454 break; 455 default: 456 dev_err(mmc_dev(host->mmc), "cmd type invalid 0x%04x\n", 457 mmc_cmd_type(cmd)); 458 ret = -EINVAL; 459 goto out; 460 } 461 462 request.cmd = cmd->opcode; 463 request.cmd_flags = cmd_flags; 464 request.cmd_type = cmd_type; 465 request.cmd_arg = cpu_to_le32(cmd->arg); 466 /* some controllers need to know at command time data details */ 467 if (data) { 468 request.data_blocks = cpu_to_le16(data->blocks); 469 request.data_blksz = cpu_to_le16(data->blksz); 470 } 471 472 timeout_ms = cmd->busy_timeout ? cmd->busy_timeout : 473 GB_OPERATION_TIMEOUT_DEFAULT; 474 475 ret = gb_operation_sync_timeout(host->connection, GB_SDIO_TYPE_COMMAND, 476 &request, sizeof(request), &response, 477 sizeof(response), timeout_ms); 478 if (ret < 0) 479 goto out; 480 481 /* no response expected */ 482 if (cmd_flags == GB_SDIO_RSP_NONE) 483 goto out; 484 485 /* long response expected */ 486 if (cmd_flags & GB_SDIO_RSP_R2) 487 for (i = 0; i < 4; i++) 488 cmd->resp[i] = le32_to_cpu(response.resp[i]); 489 else 490 cmd->resp[0] = le32_to_cpu(response.resp[0]); 491 492 out: 493 cmd->error = ret; 494 return ret; 495 } 496 497 static void gb_sdio_mrq_work(struct work_struct *work) 498 { 499 struct gb_sdio_host *host; 500 struct mmc_request *mrq; 501 int ret; 502 503 host = container_of(work, struct gb_sdio_host, mrqwork); 504 505 ret = gbphy_runtime_get_sync(host->gbphy_dev); 506 if (ret) 507 return; 508 509 mutex_lock(&host->lock); 510 mrq = host->mrq; 511 if (!mrq) { 512 mutex_unlock(&host->lock); 513 gbphy_runtime_put_autosuspend(host->gbphy_dev); 514 dev_err(mmc_dev(host->mmc), "mmc request is NULL"); 515 return; 516 } 517 518 if (host->removed) { 519 mrq->cmd->error = -ESHUTDOWN; 520 goto done; 521 } 522 523 if (mrq->sbc) { 524 ret = gb_sdio_command(host, mrq->sbc); 525 if (ret < 0) 526 goto done; 527 } 528 529 ret = gb_sdio_command(host, mrq->cmd); 530 if (ret < 0) 531 goto done; 532 533 if (mrq->data) { 534 ret = gb_sdio_transfer(host, mrq->data); 535 if (ret < 0) 536 goto done; 537 } 538 539 if (mrq->stop) { 540 ret = gb_sdio_command(host, mrq->stop); 541 if (ret < 0) 542 goto done; 543 } 544 545 done: 546 host->mrq = NULL; 547 mutex_unlock(&host->lock); 548 mmc_request_done(host->mmc, mrq); 549 gbphy_runtime_put_autosuspend(host->gbphy_dev); 550 } 551 552 static void gb_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq) 553 { 554 struct gb_sdio_host *host = mmc_priv(mmc); 555 struct mmc_command *cmd = mrq->cmd; 556 557 /* Check if it is a cancel to ongoing transfer */ 558 if (cmd->opcode == MMC_STOP_TRANSMISSION) { 559 spin_lock(&host->xfer); 560 host->xfer_stop = true; 561 spin_unlock(&host->xfer); 562 } 563 564 mutex_lock(&host->lock); 565 566 WARN_ON(host->mrq); 567 host->mrq = mrq; 568 569 if (host->removed) { 570 mrq->cmd->error = -ESHUTDOWN; 571 goto out; 572 } 573 if (!host->card_present) { 574 mrq->cmd->error = -ENOMEDIUM; 575 goto out; 576 } 577 578 queue_work(host->mrq_workqueue, &host->mrqwork); 579 580 mutex_unlock(&host->lock); 581 return; 582 583 out: 584 host->mrq = NULL; 585 mutex_unlock(&host->lock); 586 mmc_request_done(mmc, mrq); 587 } 588 589 static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 590 { 591 struct gb_sdio_host *host = mmc_priv(mmc); 592 struct gb_sdio_set_ios_request request; 593 int ret; 594 u8 power_mode; 595 u8 bus_width; 596 u8 timing; 597 u8 signal_voltage; 598 u8 drv_type; 599 u32 vdd = 0; 600 601 mutex_lock(&host->lock); 602 request.clock = cpu_to_le32(ios->clock); 603 604 if (ios->vdd) 605 vdd = 1 << (ios->vdd - GB_SDIO_VDD_SHIFT); 606 request.vdd = cpu_to_le32(vdd); 607 608 request.bus_mode = ios->bus_mode == MMC_BUSMODE_OPENDRAIN ? 609 GB_SDIO_BUSMODE_OPENDRAIN : 610 GB_SDIO_BUSMODE_PUSHPULL; 611 612 switch (ios->power_mode) { 613 case MMC_POWER_OFF: 614 default: 615 power_mode = GB_SDIO_POWER_OFF; 616 break; 617 case MMC_POWER_UP: 618 power_mode = GB_SDIO_POWER_UP; 619 break; 620 case MMC_POWER_ON: 621 power_mode = GB_SDIO_POWER_ON; 622 break; 623 case MMC_POWER_UNDEFINED: 624 power_mode = GB_SDIO_POWER_UNDEFINED; 625 break; 626 } 627 request.power_mode = power_mode; 628 629 switch (ios->bus_width) { 630 case MMC_BUS_WIDTH_1: 631 bus_width = GB_SDIO_BUS_WIDTH_1; 632 break; 633 case MMC_BUS_WIDTH_4: 634 default: 635 bus_width = GB_SDIO_BUS_WIDTH_4; 636 break; 637 case MMC_BUS_WIDTH_8: 638 bus_width = GB_SDIO_BUS_WIDTH_8; 639 break; 640 } 641 request.bus_width = bus_width; 642 643 switch (ios->timing) { 644 case MMC_TIMING_LEGACY: 645 default: 646 timing = GB_SDIO_TIMING_LEGACY; 647 break; 648 case MMC_TIMING_MMC_HS: 649 timing = GB_SDIO_TIMING_MMC_HS; 650 break; 651 case MMC_TIMING_SD_HS: 652 timing = GB_SDIO_TIMING_SD_HS; 653 break; 654 case MMC_TIMING_UHS_SDR12: 655 timing = GB_SDIO_TIMING_UHS_SDR12; 656 break; 657 case MMC_TIMING_UHS_SDR25: 658 timing = GB_SDIO_TIMING_UHS_SDR25; 659 break; 660 case MMC_TIMING_UHS_SDR50: 661 timing = GB_SDIO_TIMING_UHS_SDR50; 662 break; 663 case MMC_TIMING_UHS_SDR104: 664 timing = GB_SDIO_TIMING_UHS_SDR104; 665 break; 666 case MMC_TIMING_UHS_DDR50: 667 timing = GB_SDIO_TIMING_UHS_DDR50; 668 break; 669 case MMC_TIMING_MMC_DDR52: 670 timing = GB_SDIO_TIMING_MMC_DDR52; 671 break; 672 case MMC_TIMING_MMC_HS200: 673 timing = GB_SDIO_TIMING_MMC_HS200; 674 break; 675 case MMC_TIMING_MMC_HS400: 676 timing = GB_SDIO_TIMING_MMC_HS400; 677 break; 678 } 679 request.timing = timing; 680 681 switch (ios->signal_voltage) { 682 case MMC_SIGNAL_VOLTAGE_330: 683 signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_330; 684 break; 685 case MMC_SIGNAL_VOLTAGE_180: 686 default: 687 signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_180; 688 break; 689 case MMC_SIGNAL_VOLTAGE_120: 690 signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_120; 691 break; 692 } 693 request.signal_voltage = signal_voltage; 694 695 switch (ios->drv_type) { 696 case MMC_SET_DRIVER_TYPE_A: 697 drv_type = GB_SDIO_SET_DRIVER_TYPE_A; 698 break; 699 case MMC_SET_DRIVER_TYPE_C: 700 drv_type = GB_SDIO_SET_DRIVER_TYPE_C; 701 break; 702 case MMC_SET_DRIVER_TYPE_D: 703 drv_type = GB_SDIO_SET_DRIVER_TYPE_D; 704 break; 705 case MMC_SET_DRIVER_TYPE_B: 706 default: 707 drv_type = GB_SDIO_SET_DRIVER_TYPE_B; 708 break; 709 } 710 request.drv_type = drv_type; 711 712 ret = gb_sdio_set_ios(host, &request); 713 if (ret < 0) 714 goto out; 715 716 memcpy(&mmc->ios, ios, sizeof(mmc->ios)); 717 718 out: 719 mutex_unlock(&host->lock); 720 } 721 722 static int gb_mmc_get_ro(struct mmc_host *mmc) 723 { 724 struct gb_sdio_host *host = mmc_priv(mmc); 725 726 mutex_lock(&host->lock); 727 if (host->removed) { 728 mutex_unlock(&host->lock); 729 return -ESHUTDOWN; 730 } 731 mutex_unlock(&host->lock); 732 733 return host->read_only; 734 } 735 736 static int gb_mmc_get_cd(struct mmc_host *mmc) 737 { 738 struct gb_sdio_host *host = mmc_priv(mmc); 739 740 mutex_lock(&host->lock); 741 if (host->removed) { 742 mutex_unlock(&host->lock); 743 return -ESHUTDOWN; 744 } 745 mutex_unlock(&host->lock); 746 747 return host->card_present; 748 } 749 750 static int gb_mmc_switch_voltage(struct mmc_host *mmc, struct mmc_ios *ios) 751 { 752 return 0; 753 } 754 755 static const struct mmc_host_ops gb_sdio_ops = { 756 .request = gb_mmc_request, 757 .set_ios = gb_mmc_set_ios, 758 .get_ro = gb_mmc_get_ro, 759 .get_cd = gb_mmc_get_cd, 760 .start_signal_voltage_switch = gb_mmc_switch_voltage, 761 }; 762 763 static int gb_sdio_probe(struct gbphy_device *gbphy_dev, 764 const struct gbphy_device_id *id) 765 { 766 struct gb_connection *connection; 767 struct mmc_host *mmc; 768 struct gb_sdio_host *host; 769 int ret = 0; 770 771 mmc = mmc_alloc_host(sizeof(*host), &gbphy_dev->dev); 772 if (!mmc) 773 return -ENOMEM; 774 775 connection = gb_connection_create(gbphy_dev->bundle, 776 le16_to_cpu(gbphy_dev->cport_desc->id), 777 gb_sdio_request_handler); 778 if (IS_ERR(connection)) { 779 ret = PTR_ERR(connection); 780 goto exit_mmc_free; 781 } 782 783 host = mmc_priv(mmc); 784 host->mmc = mmc; 785 host->removed = true; 786 787 host->connection = connection; 788 gb_connection_set_data(connection, host); 789 host->gbphy_dev = gbphy_dev; 790 gb_gbphy_set_data(gbphy_dev, host); 791 792 ret = gb_connection_enable_tx(connection); 793 if (ret) 794 goto exit_connection_destroy; 795 796 ret = gb_sdio_get_caps(host); 797 if (ret < 0) 798 goto exit_connection_disable; 799 800 mmc->ops = &gb_sdio_ops; 801 802 mmc->max_segs = host->mmc->max_blk_count; 803 804 /* for now we make a map 1:1 between max request and segment size */ 805 mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count; 806 mmc->max_seg_size = mmc->max_req_size; 807 808 mutex_init(&host->lock); 809 spin_lock_init(&host->xfer); 810 host->mrq_workqueue = alloc_workqueue("mmc-%s", 0, 1, 811 dev_name(&gbphy_dev->dev)); 812 if (!host->mrq_workqueue) { 813 ret = -ENOMEM; 814 goto exit_connection_disable; 815 } 816 INIT_WORK(&host->mrqwork, gb_sdio_mrq_work); 817 818 ret = gb_connection_enable(connection); 819 if (ret) 820 goto exit_wq_destroy; 821 822 ret = mmc_add_host(mmc); 823 if (ret < 0) 824 goto exit_wq_destroy; 825 host->removed = false; 826 ret = _gb_sdio_process_events(host, host->queued_events); 827 host->queued_events = 0; 828 829 gbphy_runtime_put_autosuspend(gbphy_dev); 830 831 return ret; 832 833 exit_wq_destroy: 834 destroy_workqueue(host->mrq_workqueue); 835 exit_connection_disable: 836 gb_connection_disable(connection); 837 exit_connection_destroy: 838 gb_connection_destroy(connection); 839 exit_mmc_free: 840 mmc_free_host(mmc); 841 842 return ret; 843 } 844 845 static void gb_sdio_remove(struct gbphy_device *gbphy_dev) 846 { 847 struct gb_sdio_host *host = gb_gbphy_get_data(gbphy_dev); 848 struct gb_connection *connection = host->connection; 849 struct mmc_host *mmc; 850 int ret; 851 852 ret = gbphy_runtime_get_sync(gbphy_dev); 853 if (ret) 854 gbphy_runtime_get_noresume(gbphy_dev); 855 856 mutex_lock(&host->lock); 857 host->removed = true; 858 mmc = host->mmc; 859 gb_connection_set_data(connection, NULL); 860 mutex_unlock(&host->lock); 861 862 flush_workqueue(host->mrq_workqueue); 863 destroy_workqueue(host->mrq_workqueue); 864 gb_connection_disable_rx(connection); 865 mmc_remove_host(mmc); 866 gb_connection_disable(connection); 867 gb_connection_destroy(connection); 868 mmc_free_host(mmc); 869 } 870 871 static const struct gbphy_device_id gb_sdio_id_table[] = { 872 { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_SDIO) }, 873 { }, 874 }; 875 MODULE_DEVICE_TABLE(gbphy, gb_sdio_id_table); 876 877 static struct gbphy_driver sdio_driver = { 878 .name = "sdio", 879 .probe = gb_sdio_probe, 880 .remove = gb_sdio_remove, 881 .id_table = gb_sdio_id_table, 882 }; 883 884 module_gbphy_driver(sdio_driver); 885 MODULE_LICENSE("GPL v2"); 886