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
  19 struct gb_sdio_host {
  20         struct gb_connection    *connection;
  21         struct mmc_host         *mmc;
  22         struct mmc_request      *mrq;
  23         struct mutex            lock;   /* lock for this host */
  24         size_t                  data_max;
  25         void                    *xfer_buffer;
  26         spinlock_t              xfer;   /* lock to cancel ongoing transfer */
  27         bool                    xfer_stop;
  28         struct work_struct      mrqwork;
  29         u8                      queued_events;
  30         bool                    removed;
  31         bool                    card_present;
  32         bool                    read_only;
  33 };
  34
  35 static struct workqueue_struct *gb_sdio_mrq_workqueue;
  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 static inline bool single_op(struct mmc_command *cmd)
  46 {
  47         uint32_t opcode = cmd->opcode;
  48
  49         return opcode == MMC_WRITE_BLOCK ||
  50                opcode == MMC_READ_SINGLE_BLOCK;
  51 }
  52
  53 static void _gb_sdio_set_host_caps(struct gb_sdio_host *host, u32 r)
  54 {
  55         u32 caps = 0;
  56         u32 caps2 = 0;
  57
  58         caps = (r & GB_SDIO_CAP_NONREMOVABLE ? MMC_CAP_NONREMOVABLE : 0) |
  59                 (r & GB_SDIO_CAP_4_BIT_DATA ? MMC_CAP_4_BIT_DATA : 0) |
  60                 (r & GB_SDIO_CAP_8_BIT_DATA ? MMC_CAP_8_BIT_DATA : 0) |
  61                 (r & GB_SDIO_CAP_MMC_HS ? MMC_CAP_MMC_HIGHSPEED : 0) |
  62                 (r & GB_SDIO_CAP_SD_HS ? MMC_CAP_SD_HIGHSPEED : 0) |
  63                 (r & GB_SDIO_CAP_ERASE ? MMC_CAP_ERASE : 0) |
  64                 (r & GB_SDIO_CAP_1_2V_DDR ? MMC_CAP_1_2V_DDR : 0) |
  65                 (r & GB_SDIO_CAP_1_8V_DDR ? MMC_CAP_1_8V_DDR : 0) |
  66                 (r & GB_SDIO_CAP_POWER_OFF_CARD ? MMC_CAP_POWER_OFF_CARD : 0) |
  67                 (r & GB_SDIO_CAP_UHS_SDR12 ? MMC_CAP_UHS_SDR12 : 0) |
  68                 (r & GB_SDIO_CAP_UHS_SDR25 ? MMC_CAP_UHS_SDR25 : 0) |
  69                 (r & GB_SDIO_CAP_UHS_SDR50 ? MMC_CAP_UHS_SDR50 : 0) |
  70                 (r & GB_SDIO_CAP_UHS_SDR104 ? MMC_CAP_UHS_SDR104 : 0) |
  71                 (r & GB_SDIO_CAP_UHS_DDR50 ? MMC_CAP_UHS_DDR50 : 0) |
  72                 (r & GB_SDIO_CAP_DRIVER_TYPE_A ? MMC_CAP_DRIVER_TYPE_A : 0) |
  73                 (r & GB_SDIO_CAP_DRIVER_TYPE_C ? MMC_CAP_DRIVER_TYPE_C : 0) |
  74                 (r & GB_SDIO_CAP_DRIVER_TYPE_D ? MMC_CAP_DRIVER_TYPE_D : 0);
  75
  76         caps2 = (r & GB_SDIO_CAP_HS200_1_2V ? MMC_CAP2_HS200_1_2V_SDR : 0) |
  77 #ifdef MMC_HS400_SUPPORTED
  78                 (r & GB_SDIO_CAP_HS400_1_2V ? MMC_CAP2_HS400_1_2V : 0) |
  79                 (r & GB_SDIO_CAP_HS400_1_8V ? MMC_CAP2_HS400_1_8V : 0) |
  80 #endif
  81                 (r & GB_SDIO_CAP_HS200_1_8V ? MMC_CAP2_HS200_1_8V_SDR : 0);
  82
  83         host->mmc->caps = caps | MMC_CAP_NEEDS_POLL;
  84         host->mmc->caps2 = caps2;
  85
  86         if (caps & MMC_CAP_NONREMOVABLE)
  87                 host->card_present = true;
  88 }
  89
  90 static int gb_sdio_get_caps(struct gb_sdio_host *host)
  91 {
  92         struct gb_sdio_get_caps_response response;
  93         struct mmc_host *mmc = host->mmc;
  94         u16 data_max;
  95         u32 blksz;
  96         u32 r;
  97         int ret;
  98
  99         ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_GET_CAPABILITIES,
 100                                 NULL, 0, &response, sizeof(response));
 101         if (ret < 0)
 102                 return ret;
 103         r = le32_to_cpu(response.caps);
 104
 105         _gb_sdio_set_host_caps(host, r);
 106
 107         /* get the max block size that could fit our payload */
 108         data_max = gb_operation_get_payload_size_max(host->connection);
 109         data_max = min(data_max - sizeof(struct gb_sdio_transfer_request),
 110                        data_max - sizeof(struct gb_sdio_transfer_response));
 111
 112         blksz = min(le16_to_cpu(response.max_blk_size), data_max);
 113         blksz = max_t(u32, 512, blksz);
 114
 115         mmc->max_blk_size = rounddown_pow_of_two(blksz);
 116         mmc->max_blk_count = le16_to_cpu(response.max_blk_count);
 117         host->data_max = data_max;
 118
 119         /* get ocr supported values */
 120         mmc->ocr_avail = le32_to_cpu(response.ocr);
 121         mmc->ocr_avail_sdio = mmc->ocr_avail;
 122         mmc->ocr_avail_sd = mmc->ocr_avail;
 123         mmc->ocr_avail_mmc = mmc->ocr_avail;
 124
 125         return 0;
 126 }
 127
 128 static void _gb_queue_event(struct gb_sdio_host *host, u8 event)
 129 {
 130         if (event & GB_SDIO_CARD_INSERTED)
 131                 host->queued_events &= ~GB_SDIO_CARD_REMOVED;
 132         else if (event & GB_SDIO_CARD_REMOVED)
 133                 host->queued_events &= ~GB_SDIO_CARD_INSERTED;
 134
 135         host->queued_events |= event;
 136 }
 137
 138 static int _gb_sdio_process_events(struct gb_sdio_host *host, u8 event)
 139 {
 140         u8 state_changed = 0;
 141
 142         if (event & GB_SDIO_CARD_INSERTED) {
 143                 if (!mmc_card_is_removable(host->mmc))
 144                         return 0;
 145                 if (host->card_present)
 146                         return 0;
 147                 host->card_present = true;
 148                 state_changed = 1;
 149         }
 150
 151         if (event & GB_SDIO_CARD_REMOVED) {
 152                 if (!mmc_card_is_removable(host->mmc))
 153                         return 0;
 154                 if (!(host->card_present))
 155                         return 0;
 156                 host->card_present = false;
 157                 state_changed = 1;
 158         }
 159
 160         if (event & GB_SDIO_WP) {
 161                 host->read_only = true;
 162         }
 163
 164         if (state_changed) {
 165                 dev_info(mmc_dev(host->mmc), "card %s now event\n",
 166                          (host->card_present ?  "inserted" : "removed"));
 167                 mmc_detect_change(host->mmc, 0);
 168         }
 169
 170         return 0;
 171 }
 172
 173 static int gb_sdio_event_recv(u8 type, struct gb_operation *op)
 174 {
 175         struct gb_connection *connection = op->connection;
 176         struct gb_sdio_host *host = connection->private;
 177         struct gb_message *request;
 178         struct gb_sdio_event_request *payload;
 179         int ret =  0;
 180         u8 event;
 181
 182         if (type != GB_SDIO_TYPE_EVENT) {
 183                 dev_err(&connection->dev,
 184                         "unsupported unsolicited event: %u\n", type);
 185                 return -EINVAL;
 186         }
 187
 188         request = op->request;
 189
 190         if (request->payload_size < sizeof(*payload)) {
 191                 dev_err(mmc_dev(host->mmc), "wrong event size received (%zu < %zu)\n",
 192                         request->payload_size, sizeof(*payload));
 193                 return -EINVAL;
 194         }
 195
 196         payload = request->payload;
 197         event = payload->event;
 198
 199         if (host->removed)
 200                 _gb_queue_event(host, event);
 201         else
 202                 ret = _gb_sdio_process_events(host, event);
 203
 204         return ret;
 205 }
 206
 207 static int gb_sdio_set_ios(struct gb_sdio_host *host,
 208                            struct gb_sdio_set_ios_request *request)
 209 {
 210         return gb_operation_sync(host->connection, GB_SDIO_TYPE_SET_IOS,
 211                                  request, sizeof(*request), NULL, 0);
 212 }
 213
 214 static int _gb_sdio_send(struct gb_sdio_host *host, struct mmc_data *data,
 215                          size_t len, u16 nblocks, off_t skip)
 216 {
 217         struct gb_sdio_transfer_request *request;
 218         struct gb_sdio_transfer_response response;
 219         struct scatterlist *sg = data->sg;
 220         unsigned int sg_len = data->sg_len;
 221         size_t copied;
 222         u16 send_blksz;
 223         u16 send_blocks;
 224         int ret;
 225
 226         WARN_ON(len > host->data_max);
 227
 228         request = host->xfer_buffer;
 229         request->data_flags = (data->flags >> 8);
 230         request->data_blocks = cpu_to_le16(nblocks);
 231         request->data_blksz = cpu_to_le16(data->blksz);
 232
 233         copied = sg_pcopy_to_buffer(sg, sg_len, &request->data[0], len, skip);
 234
 235         if (copied != len)
 236                 return -EINVAL;
 237
 238         ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_TRANSFER,
 239                                 request, len + sizeof(*request),
 240                                 &response, sizeof(response));
 241         if (ret < 0)
 242                 return ret;
 243
 244         send_blocks = le16_to_cpu(response.data_blocks);
 245         send_blksz = le16_to_cpu(response.data_blksz);
 246
 247         if (len != send_blksz * send_blocks) {
 248                 dev_err(mmc_dev(host->mmc), "send: size received: %zu != %d\n",
 249                         len, send_blksz * send_blocks);
 250                 return -EINVAL;
 251         }
 252
 253         return ret;
 254 }
 255
 256 static int _gb_sdio_recv(struct gb_sdio_host *host, struct mmc_data *data,
 257                          size_t len, u16 nblocks, off_t skip)
 258 {
 259         struct gb_sdio_transfer_request request;
 260         struct gb_sdio_transfer_response *response;
 261         struct scatterlist *sg = data->sg;
 262         unsigned int sg_len = data->sg_len;
 263         size_t copied;
 264         u16 recv_blksz;
 265         u16 recv_blocks;
 266         int ret;
 267
 268         WARN_ON(len > host->data_max);
 269
 270         request.data_flags = (data->flags >> 8);
 271         request.data_blocks = cpu_to_le16(nblocks);
 272         request.data_blksz = cpu_to_le16(data->blksz);
 273
 274         response = host->xfer_buffer;
 275
 276         ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_TRANSFER,
 277                                 &request, sizeof(request), response, len +
 278                                 sizeof(*response));
 279         if (ret < 0)
 280                 return ret;
 281
 282         recv_blocks = le16_to_cpu(response->data_blocks);
 283         recv_blksz = le16_to_cpu(response->data_blksz);
 284
 285         if (len != recv_blksz * recv_blocks) {
 286                 dev_err(mmc_dev(host->mmc), "recv: size received: %d != %zu\n",
 287                         recv_blksz * recv_blocks, len);
 288                 return -EINVAL;
 289         }
 290
 291         copied = sg_pcopy_from_buffer(sg, sg_len, &response->data[0], len,
 292                                       skip);
 293         if (copied != len)
 294                 return -EINVAL;
 295
 296         return 0;
 297 }
 298
 299 static int gb_sdio_transfer(struct gb_sdio_host *host, struct mmc_data *data)
 300 {
 301         size_t left, len;
 302         off_t skip = 0;
 303         int ret = 0;
 304         u16 nblocks;
 305
 306         if (single_op(data->mrq->cmd) && data->blocks > 1) {
 307                 ret = -ETIMEDOUT;
 308                 goto out;
 309         }
 310
 311         left = data->blksz * data->blocks;
 312
 313         while (left) {
 314                 /* check is a stop transmission is pending */
 315                 spin_lock(&host->xfer);
 316                 if (host->xfer_stop) {
 317                         host->xfer_stop = false;
 318                         spin_unlock(&host->xfer);
 319                         ret = -EINTR;
 320                         goto out;
 321                 }
 322                 spin_unlock(&host->xfer);
 323                 len = min(left, host->data_max);
 324                 nblocks = len / data->blksz;
 325                 len = nblocks * data->blksz;
 326
 327                 if (data->flags & MMC_DATA_READ) {
 328                         ret = _gb_sdio_recv(host, data, len, nblocks, skip);
 329                         if (ret < 0)
 330                                 goto out;
 331                 } else {
 332                         ret = _gb_sdio_send(host, data, len, nblocks, skip);
 333                         if (ret < 0)
 334                                 goto out;
 335                 }
 336                 data->bytes_xfered += len;
 337                 left -= len;
 338                 skip += len;
 339         }
 340
 341 out:
 342         data->error = ret;
 343         return ret;
 344 }
 345
 346 static int gb_sdio_command(struct gb_sdio_host *host, struct mmc_command *cmd)
 347 {
 348         struct gb_sdio_command_request request;
 349         struct gb_sdio_command_response response;
 350         u8 cmd_flags;
 351         u8 cmd_type;
 352         int i;
 353         int ret = 0;
 354
 355         switch (mmc_resp_type(cmd)) {
 356         case MMC_RSP_NONE:
 357                 cmd_flags = GB_SDIO_RSP_NONE;
 358                 break;
 359         case MMC_RSP_R1:
 360                 cmd_flags = GB_SDIO_RSP_R1_R5_R6_R7;
 361                 break;
 362         case MMC_RSP_R1B:
 363                 cmd_flags = GB_SDIO_RSP_R1B;
 364                 break;
 365         case MMC_RSP_R2:
 366                 cmd_flags = GB_SDIO_RSP_R2;
 367                 break;
 368         case MMC_RSP_R3:
 369                 cmd_flags = GB_SDIO_RSP_R3_R4;
 370                 break;
 371         default:
 372                 dev_err(mmc_dev(host->mmc), "cmd flag invalid %04x\n",
 373                         mmc_resp_type(cmd));
 374                 ret = -EINVAL;
 375                 goto out;
 376         }
 377
 378         switch (mmc_cmd_type(cmd)) {
 379         case MMC_CMD_BC:
 380                 cmd_type = GB_SDIO_CMD_BC;
 381                 break;
 382         case MMC_CMD_BCR:
 383                 cmd_type = GB_SDIO_CMD_BCR;
 384                 break;
 385         case MMC_CMD_AC:
 386                 cmd_type = GB_SDIO_CMD_AC;
 387                 break;
 388         case MMC_CMD_ADTC:
 389                 cmd_type = GB_SDIO_CMD_ADTC;
 390                 break;
 391         default:
 392                 dev_err(mmc_dev(host->mmc), "cmd type invalid %04x\n",
 393                         mmc_cmd_type(cmd));
 394                 ret = -EINVAL;
 395                 goto out;
 396         }
 397
 398         request.cmd = cmd->opcode;
 399         request.cmd_flags = cmd_flags;
 400         request.cmd_type = cmd_type;
 401         request.cmd_arg = cpu_to_le32(cmd->arg);
 402
 403         ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_COMMAND,
 404                                 &request, sizeof(request), &response,
 405                                 sizeof(response));
 406         if (ret < 0)
 407                 goto out;
 408
 409         /* no response expected */
 410         if (cmd_flags & GB_SDIO_RSP_NONE)
 411                 goto out;
 412
 413         /* long response expected */
 414         if (cmd_flags & GB_SDIO_RSP_R2)
 415                 for (i = 0; i < 4; i++)
 416                         cmd->resp[i] = le32_to_cpu(response.resp[i]);
 417         else
 418                 cmd->resp[0] = le32_to_cpu(response.resp[0]);
 419
 420 out:
 421         cmd->error = ret;
 422         return ret;
 423 }
 424
 425 static void gb_sdio_mrq_work(struct work_struct *work)
 426 {
 427         struct gb_sdio_host *host;
 428         struct mmc_request *mrq;
 429         int ret;
 430
 431         host = container_of(work, struct gb_sdio_host, mrqwork);
 432
 433         mutex_lock(&host->lock);
 434         mrq = host->mrq;
 435         if (!mrq) {
 436                 mutex_unlock(&host->lock);
 437                 dev_err(mmc_dev(host->mmc), "mmc request is NULL");
 438                 return;
 439         }
 440
 441         if (host->removed) {
 442                 mrq->cmd->error = -ESHUTDOWN;
 443                 goto done;
 444         }
 445
 446         if (mrq->sbc) {
 447                 ret = gb_sdio_command(host, mrq->sbc);
 448                 if (ret < 0)
 449                         goto done;
 450         }
 451
 452         ret = gb_sdio_command(host, mrq->cmd);
 453         if (ret < 0)
 454                 goto done;
 455
 456         if (mrq->data) {
 457                 ret = gb_sdio_transfer(host, host->mrq->data);
 458                 if (ret < 0)
 459                         goto done;
 460         }
 461
 462         if (mrq->stop) {
 463                 ret = gb_sdio_command(host, mrq->stop);
 464                 if (ret < 0)
 465                         goto done;
 466         }
 467
 468 done:
 469         host->mrq = NULL;
 470         mutex_unlock(&host->lock);
 471         mmc_request_done(host->mmc, mrq);
 472 }
 473
 474 static void gb_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
 475 {
 476         struct gb_sdio_host *host = mmc_priv(mmc);
 477         struct mmc_command *cmd = mrq->cmd;
 478
 479         /* Check if it is a cancel to ongoing transfer */
 480         if (cmd->opcode == MMC_STOP_TRANSMISSION) {
 481                 spin_lock(&host->xfer);
 482                 host->xfer_stop = true;
 483                 spin_unlock(&host->xfer);
 484         }
 485
 486         mutex_lock(&host->lock);
 487
 488         WARN_ON(host->mrq);
 489         host->mrq = mrq;
 490
 491         if (host->removed) {
 492                 mrq->cmd->error = -ESHUTDOWN;
 493                 goto out;
 494         }
 495         if (!host->card_present) {
 496                 mrq->cmd->error = -ENOMEDIUM;
 497                 goto out;
 498         }
 499
 500         queue_work(gb_sdio_mrq_workqueue, &host->mrqwork);
 501
 502         mutex_unlock(&host->lock);
 503         return;
 504
 505 out:
 506         host->mrq = NULL;
 507         mutex_unlock(&host->lock);
 508         mmc_request_done(mmc, mrq);
 509 }
 510
 511 static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 512 {
 513         struct gb_sdio_host *host = mmc_priv(mmc);
 514         struct gb_sdio_set_ios_request request;
 515         int ret;
 516         u8 power_mode;
 517         u8 bus_width;
 518         u8 timing;
 519         u8 signal_voltage;
 520         u8 drv_type;
 521
 522         mutex_lock(&host->lock);
 523         request.clock = cpu_to_le32(ios->clock);
 524         request.vdd = cpu_to_le32(1 << ios->vdd);
 525
 526         request.bus_mode = (ios->bus_mode == MMC_BUSMODE_OPENDRAIN ?
 527                             GB_SDIO_BUSMODE_OPENDRAIN :
 528                             GB_SDIO_BUSMODE_PUSHPULL);
 529
 530         switch (ios->power_mode) {
 531         case MMC_POWER_OFF:
 532         default:
 533                 power_mode = GB_SDIO_POWER_OFF;
 534                 break;
 535         case MMC_POWER_UP:
 536                 power_mode = GB_SDIO_POWER_UP;
 537                 break;
 538         case MMC_POWER_ON:
 539                 power_mode = GB_SDIO_POWER_ON;
 540                 break;
 541 #ifdef MMC_POWER_UNDEFINED_SUPPORTED
 542         case MMC_POWER_UNDEFINED:
 543                 power_mode = GB_SDIO_POWER_UNDEFINED;
 544                 break;
 545 #endif
 546         }
 547         request.power_mode = power_mode;
 548
 549         switch (ios->bus_width) {
 550         case MMC_BUS_WIDTH_1:
 551                 bus_width = GB_SDIO_BUS_WIDTH_1;
 552                 break;
 553         case MMC_BUS_WIDTH_4:
 554         default:
 555                 bus_width = GB_SDIO_BUS_WIDTH_4;
 556                 break;
 557         case MMC_BUS_WIDTH_8:
 558                 bus_width = GB_SDIO_BUS_WIDTH_8;
 559                 break;
 560         }
 561         request.bus_width = bus_width;
 562
 563         switch (ios->timing) {
 564         case MMC_TIMING_LEGACY:
 565         default:
 566                 timing = GB_SDIO_TIMING_LEGACY;
 567                 break;
 568         case MMC_TIMING_MMC_HS:
 569                 timing = GB_SDIO_TIMING_MMC_HS;
 570                 break;
 571         case MMC_TIMING_SD_HS:
 572                 timing = GB_SDIO_TIMING_SD_HS;
 573                 break;
 574         case MMC_TIMING_UHS_SDR12:
 575                 timing = GB_SDIO_TIMING_UHS_SDR12;
 576                 break;
 577         case MMC_TIMING_UHS_SDR25:
 578                 timing = GB_SDIO_TIMING_UHS_SDR25;
 579                 break;
 580         case MMC_TIMING_UHS_SDR50:
 581                 timing = GB_SDIO_TIMING_UHS_SDR50;
 582                 break;
 583         case MMC_TIMING_UHS_SDR104:
 584                 timing = GB_SDIO_TIMING_UHS_SDR104;
 585                 break;
 586         case MMC_TIMING_UHS_DDR50:
 587                 timing = GB_SDIO_TIMING_UHS_DDR50;
 588                 break;
 589 #ifdef MMC_DDR52_DEFINED
 590         case MMC_TIMING_MMC_DDR52:
 591                 timing = GB_SDIO_TIMING_MMC_DDR52;
 592                 break;
 593 #endif
 594         case MMC_TIMING_MMC_HS200:
 595                 timing = GB_SDIO_TIMING_MMC_HS200;
 596                 break;
 597 #ifdef MMC_HS400_SUPPORTED
 598         case MMC_TIMING_MMC_HS400:
 599                 timing = GB_SDIO_TIMING_MMC_HS400;
 600                 break;
 601 #endif
 602         }
 603         request.timing = timing;
 604
 605         switch (ios->signal_voltage) {
 606         case MMC_SIGNAL_VOLTAGE_330:
 607                 signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_330;
 608                 break;
 609         case MMC_SIGNAL_VOLTAGE_180:
 610         default:
 611                 signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_180;
 612                 break;
 613         case MMC_SIGNAL_VOLTAGE_120:
 614                 signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_120;
 615                 break;
 616         }
 617         request.signal_voltage = signal_voltage;
 618
 619         switch (ios->drv_type) {
 620         case MMC_SET_DRIVER_TYPE_A:
 621                 drv_type = GB_SDIO_SET_DRIVER_TYPE_A;
 622                 break;
 623         case MMC_SET_DRIVER_TYPE_C:
 624                 drv_type = GB_SDIO_SET_DRIVER_TYPE_C;
 625                 break;
 626         case MMC_SET_DRIVER_TYPE_D:
 627                 drv_type = GB_SDIO_SET_DRIVER_TYPE_D;
 628                 break;
 629         case MMC_SET_DRIVER_TYPE_B:
 630         default:
 631                 drv_type = GB_SDIO_SET_DRIVER_TYPE_B;
 632                 break;
 633         }
 634         request.drv_type = drv_type;
 635
 636         ret = gb_sdio_set_ios(host, &request);
 637         if (ret < 0)
 638                 goto out;
 639
 640         memcpy(&mmc->ios, ios, sizeof(mmc->ios));
 641
 642 out:
 643         mutex_unlock(&host->lock);
 644 }
 645
 646 static int gb_mmc_get_ro(struct mmc_host *mmc)
 647 {
 648         struct gb_sdio_host *host = mmc_priv(mmc);
 649
 650         mutex_lock(&host->lock);
 651         if (host->removed)
 652                 return -ESHUTDOWN;
 653         mutex_unlock(&host->lock);
 654         return host->read_only;
 655 }
 656
 657 static int gb_mmc_get_cd(struct mmc_host *mmc)
 658 {
 659         struct gb_sdio_host *host = mmc_priv(mmc);
 660
 661         mutex_lock(&host->lock);
 662         if (host->removed)
 663                 return -ESHUTDOWN;
 664         mutex_unlock(&host->lock);
 665         return host->card_present;
 666 }
 667
 668 static const struct mmc_host_ops gb_sdio_ops = {
 669         .request        = gb_mmc_request,
 670         .set_ios        = gb_mmc_set_ios,
 671         .get_ro         = gb_mmc_get_ro,
 672         .get_cd         = gb_mmc_get_cd,
 673 };
 674
 675 static int gb_sdio_connection_init(struct gb_connection *connection)
 676 {
 677         struct mmc_host *mmc;
 678         struct gb_sdio_host *host;
 679         size_t max_buffer;
 680         int ret = 0;
 681
 682         mmc = mmc_alloc_host(sizeof(*host), &connection->dev);
 683         if (!mmc)
 684                 return -ENOMEM;
 685
 686         host = mmc_priv(mmc);
 687         host->mmc = mmc;
 688         host->removed = true;
 689
 690         host->connection = connection;
 691         connection->private = host;
 692
 693         ret = gb_sdio_get_caps(host);
 694         if (ret < 0)
 695                 goto free_mmc;
 696
 697         mmc->ops = &gb_sdio_ops;
 698
 699         /* for now we just make a map 1:1 between max blocks and segments */
 700         mmc->max_segs = host->mmc->max_blk_count;
 701         mmc->max_seg_size = host->mmc->max_blk_size;
 702
 703         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
 704
 705         max_buffer = gb_operation_get_payload_size_max(host->connection);
 706         host->xfer_buffer = kzalloc(max_buffer, GFP_KERNEL);
 707         if (!host->xfer_buffer) {
 708                 ret = -ENOMEM;
 709                 goto free_mmc;
 710         }
 711         mutex_init(&host->lock);
 712         spin_lock_init(&host->xfer);
 713         gb_sdio_mrq_workqueue = alloc_workqueue("gb_sdio_mrq", 0, 1);
 714         INIT_WORK(&host->mrqwork, gb_sdio_mrq_work);
 715
 716         ret = mmc_add_host(mmc);
 717         if (ret < 0)
 718                 goto free_work;
 719         host->removed = false;
 720         ret = _gb_sdio_process_events(host, host->queued_events);
 721         host->queued_events = 0;
 722
 723         return ret;
 724
 725 free_work:
 726         destroy_workqueue(gb_sdio_mrq_workqueue);
 727         kfree(host->xfer_buffer);
 728
 729 free_mmc:
 730         connection->private = NULL;
 731         mmc_free_host(mmc);
 732
 733         return ret;
 734 }
 735
 736 static void gb_sdio_connection_exit(struct gb_connection *connection)
 737 {
 738         struct mmc_host *mmc;
 739         struct gb_sdio_host *host = connection->private;
 740
 741         if (!host)
 742                 return;
 743
 744         mutex_lock(&host->lock);
 745         host->removed = true;
 746         mmc = host->mmc;
 747         connection->private = NULL;
 748         mutex_unlock(&host->lock);
 749
 750         flush_workqueue(gb_sdio_mrq_workqueue);
 751         destroy_workqueue(gb_sdio_mrq_workqueue);
 752         mmc_remove_host(mmc);
 753         mmc_free_host(mmc);
 754         kfree(host->xfer_buffer);
 755 }
 756
 757 static struct gb_protocol sdio_protocol = {
 758         .name                   = "sdio",
 759         .id                     = GREYBUS_PROTOCOL_SDIO,
 760         .major                  = GB_SDIO_VERSION_MAJOR,
 761         .minor                  = GB_SDIO_VERSION_MINOR,
 762         .connection_init        = gb_sdio_connection_init,
 763         .connection_exit        = gb_sdio_connection_exit,
 764         .request_recv           = gb_sdio_event_recv,
 765 };
 766
 767 gb_builtin_protocol_driver(sdio_protocol);