drivers/staging/greybus/sdio.c

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