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