drivers/staging/greybus/sdio.c

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