sys/dev/disk/mmcsd/mmcsd.c

   1 /*-
   2  * Copyright (c) 2006 Bernd Walter.  All rights reserved.
   3  * Copyright (c) 2006 M. Warner Losh.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  *
  25  * Portions of this software may have been developed with reference to
  26  * the SD Simplified Specification.  The following disclaimer may apply:
  27  *
  28  * The following conditions apply to the release of the simplified
  29  * specification ("Simplified Specification") by the SD Card Association and
  30  * the SD Group. The Simplified Specification is a subset of the complete SD
  31  * Specification which is owned by the SD Card Association and the SD
  32  * Group. This Simplified Specification is provided on a non-confidential
  33  * basis subject to the disclaimers below. Any implementation of the
  34  * Simplified Specification may require a license from the SD Card
  35  * Association, SD Group, SD-3C LLC or other third parties.
  36  *
  37  * Disclaimers:
  38  *
  39  * The information contained in the Simplified Specification is presented only
  40  * as a standard specification for SD Cards and SD Host/Ancillary products and
  41  * is provided "AS-IS" without any representations or warranties of any
  42  * kind. No responsibility is assumed by the SD Group, SD-3C LLC or the SD
  43  * Card Association for any damages, any infringements of patents or other
  44  * right of the SD Group, SD-3C LLC, the SD Card Association or any third
  45  * parties, which may result from its use. No license is granted by
  46  * implication, estoppel or otherwise under any patent or other rights of the
  47  * SD Group, SD-3C LLC, the SD Card Association or any third party. Nothing
  48  * herein shall be construed as an obligation by the SD Group, the SD-3C LLC
  49  * or the SD Card Association to disclose or distribute any technical
  50  * information, know-how or other confidential information to any third party.
  51  *
  52  * $FreeBSD: src/sys/dev/mmc/mmcsd.c,v 1.20 2009/02/17 19:17:25 mav Exp $
  53  */
  54
  55 #include <sys/param.h>
  56 #include <sys/systm.h>
  57 #include <sys/buf.h>
  58 #include <sys/bus.h>
  59 #include <sys/conf.h>
  60 #include <sys/disk.h>
  61 #include <sys/device.h>
  62 #include <sys/devicestat.h>
  63 #include <sys/kernel.h>
  64 #include <sys/kthread.h>
  65 #include <sys/lock.h>
  66 #include <sys/malloc.h>
  67 #include <sys/module.h>
  68 #include <sys/spinlock.h>
  69
  70 #include <sys/buf2.h>
  71 #include <sys/mplock2.h>
  72
  73 #include <bus/mmc/mmcvar.h>
  74 #include <bus/mmc/mmcreg.h>
  75
  76 #include "mmcbus_if.h"
  77
  78 struct mmcsd_softc {
  79         device_t dev;
  80         cdev_t dev_t;
  81         struct lock sc_lock;
  82         struct disk disk;
  83         struct devstat device_stats;
  84         int unit;
  85         struct thread *td;
  86         struct bio_queue_head bio_queue;
  87         daddr_t eblock, eend;   /* Range remaining after the last erase. */
  88         int running;
  89         int suspend;
  90 };
  91
  92 /* bus entry points */
  93 static int mmcsd_probe(device_t dev);
  94 static int mmcsd_attach(device_t dev);
  95 static int mmcsd_detach(device_t dev);
  96
  97 /* disk routines */
  98 static d_open_t mmcsd_open;
  99 static d_close_t mmcsd_close;
 100 static d_strategy_t mmcsd_strategy;
 101 static d_dump_t mmcsd_dump;
 102
 103 static void mmcsd_task(void *arg);
 104
 105 static const char *mmcsd_card_name(device_t dev);
 106 static int mmcsd_bus_bit_width(device_t dev);
 107
 108 #define MMCSD_LOCK(_sc)         lockmgr(&(_sc)->sc_lock, LK_EXCLUSIVE)
 109 #define MMCSD_UNLOCK(_sc)       lockmgr(&(_sc)->sc_lock, LK_RELEASE)
 110 #define MMCSD_LOCK_INIT(_sc)    lockinit(&(_sc)->sc_lock, "mmcsd", 0, LK_CANRECURSE)
 111 #define MMCSD_LOCK_DESTROY(_sc) lockuninit(&(_sc)->sc_lock);
 112 #define MMCSD_ASSERT_LOCKED(_sc) KKASSERT(lockstatus(&(_sc)->sc_lock, curthread) != 0);
 113 #define MMCSD_ASSERT_UNLOCKED(_sc) KKASSERT(lockstatus(&(_sc)->sc_lock, curthread) == 0);
 114
 115 static struct dev_ops mmcsd_ops = {
 116         { "mmcsd", 0, D_DISK },
 117         .d_open = mmcsd_open,
 118         .d_close = mmcsd_close,
 119         .d_strategy = mmcsd_strategy,
 120         .d_dump = mmcsd_dump,
 121 };
 122
 123 static int
 124 mmcsd_probe(device_t dev)
 125 {
 126
 127         device_quiet(dev);
 128         device_set_desc(dev, "MMC/SD Memory Card");
 129         return (0);
 130 }
 131
 132 static int
 133 mmcsd_attach(device_t dev)
 134 {
 135         struct mmcsd_softc *sc;
 136         struct disk_info info;
 137         cdev_t dsk;
 138         intmax_t mb;
 139         char unit;
 140         int sector_size;
 141
 142         sc = device_get_softc(dev);
 143         sc->dev = dev;
 144         MMCSD_LOCK_INIT(sc);
 145
 146         sector_size = mmc_get_sector_size(dev);
 147         devstat_add_entry(&sc->device_stats, "mmcsd", device_get_unit(dev),
 148             sector_size, DEVSTAT_NO_ORDERED_TAGS,
 149             DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER,
 150             DEVSTAT_PRIORITY_DISK);
 151
 152         dsk = disk_create(sc->unit, &sc->disk, &mmcsd_ops);
 153         dsk->si_drv1 = sc;
 154         sc->dev_t = dsk;
 155
 156         dsk->si_iosize_max = 4*1024*1024;       /* Maximum defined SD card AU size. */
 157
 158         bzero(&info, sizeof(info));
 159         info.d_media_blksize = sector_size;
 160         info.d_media_blocks = mmc_get_media_size(dev);
 161         disk_setdiskinfo(&sc->disk, &info);
 162
 163         /*
 164          * Display in most natural units.  There's no cards < 1MB.
 165          * The SD standard goes to 2GiB, but the data format supports
 166          * up to 4GiB and some card makers push it up to this limit.
 167          * The SDHC standard only goes to 32GiB (the data format in
 168          * SDHC is good to 2TiB however, which isn't too ugly at
 169          * 2048GiBm, so we note it in passing here and don't add the
 170          * code to print TiB).
 171          */
 172         mb = (info.d_media_blksize * info.d_media_blocks) >> 20;        /* 1MiB == 1 << 20 */
 173         unit = 'M';
 174         if (mb >= 10240) {              /* 1GiB = 1024 MiB */
 175                 unit = 'G';
 176                 mb /= 1024;
 177         }
 178         device_printf(dev, "%ju%cB <%s Memory Card>%s at %s %dMHz/%dbit\n",
 179             mb, unit, mmcsd_card_name(dev),
 180             mmc_get_read_only(dev) ? " (read-only)" : "",
 181             device_get_nameunit(device_get_parent(dev)),
 182             mmc_get_tran_speed(dev) / 1000000, mmcsd_bus_bit_width(dev));
 183
 184         bioq_init(&sc->bio_queue);
 185
 186         sc->running = 1;
 187         sc->suspend = 0;
 188         sc->eblock = sc->eend = 0;
 189         kthread_create(mmcsd_task, sc, &sc->td, "mmc/sd card task");
 190
 191         return (0);
 192 }
 193
 194 static int
 195 mmcsd_detach(device_t dev)
 196 {
 197         struct mmcsd_softc *sc = device_get_softc(dev);
 198         struct buf *q_bp;
 199         struct bio *q_bio;
 200
 201         MMCSD_LOCK(sc);
 202         sc->suspend = 0;
 203         if (sc->running > 0) {
 204                 /* kill thread */
 205                 sc->running = 0;
 206                 wakeup(sc);
 207                 /* wait for thread to finish. */
 208                 while (sc->running != -1)
 209                         lksleep(sc, &sc->sc_lock, 0, "detach", 0);
 210         }
 211         MMCSD_UNLOCK(sc);
 212
 213         /* Flush the request queue.
 214          *
 215          * XXX: Return all queued I/O with ENXIO. Is this correct?
 216          */
 217         while ((q_bio = bioq_takefirst(&sc->bio_queue)) != NULL) {
 218                 q_bp = q_bio->bio_buf;
 219                 q_bp->b_resid = q_bp->b_bcount;
 220                 q_bp->b_error = ENXIO;
 221                 q_bp->b_flags |= B_ERROR;
 222                 biodone(q_bio);
 223         }
 224
 225         /* kill disk */
 226         disk_destroy(&sc->disk);
 227         devstat_remove_entry(&sc->device_stats);
 228
 229         MMCSD_LOCK_DESTROY(sc);
 230
 231         return (0);
 232 }
 233
 234 static int
 235 mmcsd_suspend(device_t dev)
 236 {
 237         struct mmcsd_softc *sc = device_get_softc(dev);
 238
 239         MMCSD_LOCK(sc);
 240         sc->suspend = 1;
 241         if (sc->running > 0) {
 242                 /* kill thread */
 243                 sc->running = 0;
 244                 wakeup(sc);
 245                 /* wait for thread to finish. */
 246                 while (sc->running != -1)
 247                         lksleep(sc, &sc->sc_lock, 0, "detach", 0);
 248         }
 249         MMCSD_UNLOCK(sc);
 250         return (0);
 251 }
 252
 253 static int
 254 mmcsd_resume(device_t dev)
 255 {
 256         struct mmcsd_softc *sc = device_get_softc(dev);
 257
 258         MMCSD_LOCK(sc);
 259         sc->suspend = 0;
 260         if (sc->running <= 0) {
 261                 sc->running = 1;
 262                 MMCSD_UNLOCK(sc);
 263                 kthread_create(mmcsd_task, sc, &sc->td, "mmc/sd card task");
 264         } else
 265                 MMCSD_UNLOCK(sc);
 266         return (0);
 267 }
 268
 269 static int
 270 mmcsd_open(struct dev_open_args *ap)
 271 {
 272         return (0);
 273 }
 274
 275 static int
 276 mmcsd_close(struct dev_close_args *ap)
 277 {
 278         return (0);
 279 }
 280
 281 static int
 282 mmcsd_strategy(struct dev_strategy_args *ap)
 283 {
 284         struct mmcsd_softc *sc;
 285         struct bio *bio = ap->a_bio;
 286         struct buf *bp = bio->bio_buf;
 287
 288         sc = (struct mmcsd_softc *)ap->a_head.a_dev->si_drv1;
 289         MMCSD_LOCK(sc);
 290         if (sc->running > 0 || sc->suspend > 0) {
 291                 bioqdisksort(&sc->bio_queue, bio);
 292                 devstat_start_transaction(&sc->device_stats);
 293                 MMCSD_UNLOCK(sc);
 294                 wakeup(sc);
 295         } else {
 296                 MMCSD_UNLOCK(sc);
 297                 bp->b_error = ENXIO;
 298                 bp->b_flags |= B_ERROR;
 299                 bp->b_resid = bp->b_bcount;
 300                 biodone(bio);
 301         }
 302         return (0);
 303 }
 304
 305 static daddr_t
 306 mmcsd_rw(struct mmcsd_softc *sc, struct bio *bio)
 307 {
 308         daddr_t block, end;
 309         struct mmc_command cmd;
 310         struct mmc_command stop;
 311         struct mmc_request req;
 312         struct mmc_data data;
 313         device_t dev = sc->dev;
 314         int sz = sc->disk.d_info.d_media_blksize;
 315         struct buf *bp = bio->bio_buf;
 316
 317         block = bio->bio_offset / sz;
 318         end = block + (bp->b_bcount / sz);
 319         while (block < end) {
 320                 char *vaddr = bp->b_data +
 321                     (block - (bio->bio_offset / sz)) * sz;
 322                 int numblocks = min(end - block, mmc_get_max_data(dev));
 323                 memset(&req, 0, sizeof(req));
 324                 memset(&cmd, 0, sizeof(cmd));
 325                 memset(&stop, 0, sizeof(stop));
 326                 req.cmd = &cmd;
 327                 cmd.data = &data;
 328                 if (bp->b_cmd == BUF_CMD_READ) {
 329                         if (numblocks > 1)
 330                                 cmd.opcode = MMC_READ_MULTIPLE_BLOCK;
 331                         else
 332                                 cmd.opcode = MMC_READ_SINGLE_BLOCK;
 333                 } else {
 334                         if (numblocks > 1)
 335                                 cmd.opcode = MMC_WRITE_MULTIPLE_BLOCK;
 336                         else
 337                                 cmd.opcode = MMC_WRITE_BLOCK;
 338                 }
 339                 cmd.arg = block;
 340                 if (!mmc_get_high_cap(dev))
 341                         cmd.arg <<= 9;
 342                 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
 343                 data.data = vaddr;
 344                 data.mrq = &req;
 345                 if (bp->b_cmd == BUF_CMD_READ)
 346                         data.flags = MMC_DATA_READ;
 347                 else
 348                         data.flags = MMC_DATA_WRITE;
 349                 data.len = numblocks * sz;
 350                 if (numblocks > 1) {
 351                         data.flags |= MMC_DATA_MULTI;
 352                         stop.opcode = MMC_STOP_TRANSMISSION;
 353                         stop.arg = 0;
 354                         stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
 355                         req.stop = &stop;
 356                 }
 357 //              kprintf("Len %d  %lld-%lld flags %#x sz %d\n",
 358 //                  (int)data.len, (long long)block, (long long)end, data.flags, sz);
 359                 MMCBUS_WAIT_FOR_REQUEST(device_get_parent(dev), dev,
 360                     &req);
 361                 if (req.cmd->error != MMC_ERR_NONE)
 362                         break;
 363                 block += numblocks;
 364         }
 365         return (block);
 366 }
 367
 368 static daddr_t
 369 mmcsd_delete(struct mmcsd_softc *sc, struct bio *bio)
 370 {
 371         daddr_t block, end, start, stop;
 372         struct mmc_command cmd;
 373         struct mmc_request req;
 374         device_t dev = sc->dev;
 375         int sz = sc->disk.d_info.d_media_blksize;
 376         int erase_sector;
 377         struct buf *bp = bio->bio_buf;
 378
 379         block = bio->bio_offset / sz;
 380         end = block + (bp->b_bcount / sz);
 381         /* Coalesce with part remaining from previous request. */
 382         if (block > sc->eblock && block <= sc->eend)
 383                 block = sc->eblock;
 384         if (end >= sc->eblock && end < sc->eend)
 385                 end = sc->eend;
 386         /* Safe round to the erase sector boundaries. */
 387         erase_sector = mmc_get_erase_sector(dev);
 388         start = block + erase_sector - 1;        /* Round up. */
 389         start -= start % erase_sector;
 390         stop = end;                             /* Round down. */
 391         stop -= end % erase_sector;
 392         /* We can't erase area smaller then sector, store it for later. */
 393         if (start >= stop) {
 394                 sc->eblock = block;
 395                 sc->eend = end;
 396                 return (end);
 397         }
 398
 399         /* Set erase start position. */
 400         memset(&req, 0, sizeof(req));
 401         memset(&cmd, 0, sizeof(cmd));
 402         req.cmd = &cmd;
 403         if (mmc_get_card_type(dev) == mode_sd)
 404                 cmd.opcode = SD_ERASE_WR_BLK_START;
 405         else
 406                 cmd.opcode = MMC_ERASE_GROUP_START;
 407         cmd.arg = start;
 408         if (!mmc_get_high_cap(dev))
 409                 cmd.arg <<= 9;
 410         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 411         MMCBUS_WAIT_FOR_REQUEST(device_get_parent(dev), dev,
 412             &req);
 413         if (req.cmd->error != MMC_ERR_NONE) {
 414             kprintf("erase err1: %d\n", req.cmd->error);
 415             return (block);
 416         }
 417         /* Set erase stop position. */
 418         memset(&req, 0, sizeof(req));
 419         memset(&cmd, 0, sizeof(cmd));
 420         req.cmd = &cmd;
 421         if (mmc_get_card_type(dev) == mode_sd)
 422                 cmd.opcode = SD_ERASE_WR_BLK_END;
 423         else
 424                 cmd.opcode = MMC_ERASE_GROUP_END;
 425         cmd.arg = stop;
 426         if (!mmc_get_high_cap(dev))
 427                 cmd.arg <<= 9;
 428         cmd.arg--;
 429         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 430         MMCBUS_WAIT_FOR_REQUEST(device_get_parent(dev), dev,
 431             &req);
 432         if (req.cmd->error != MMC_ERR_NONE) {
 433             kprintf("erase err2: %d\n", req.cmd->error);
 434             return (block);
 435         }
 436         /* Erase range. */
 437         memset(&req, 0, sizeof(req));
 438         memset(&cmd, 0, sizeof(cmd));
 439         req.cmd = &cmd;
 440         cmd.opcode = MMC_ERASE;
 441         cmd.arg = 0;
 442         cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
 443         MMCBUS_WAIT_FOR_REQUEST(device_get_parent(dev), dev,
 444             &req);
 445         if (req.cmd->error != MMC_ERR_NONE) {
 446             kprintf("erase err3 %d\n", req.cmd->error);
 447             return (block);
 448         }
 449         /* Store one of remaining parts for the next call. */
 450         if ((bio->bio_offset / sz) >= sc->eblock || block == start) {
 451                 sc->eblock = stop;      /* Predict next forward. */
 452                 sc->eend = end;
 453         } else {
 454                 sc->eblock = block;     /* Predict next backward. */
 455                 sc->eend = start;
 456         }
 457         return (end);
 458 }
 459
 460 static int
 461 mmcsd_dump(struct dev_dump_args *ap)
 462 {
 463 #if 0
 464         cdev_t cdev = ap->a_head.a_dev;
 465         struct mmcsd_softc *sc = (struct mmcsd_softc *)cdev->si_drv1;
 466         device_t dev = sc->dev;
 467         struct bio bp;
 468         daddr_t block, end;
 469         int length = ap->a_length;
 470
 471         /* length zero is special and really means flush buffers to media */
 472         if (!length)
 473                 return (0);
 474
 475         bzero(&bp, sizeof(struct bio));
 476         bp.bio_driver_info = cdev;
 477         bp.bio_pblkno = offset / sc->disk->d_sectorsize;
 478         bp.bio_bcount = length;
 479         bp.bio_data = virtual;
 480         bp.bio_cmd = BIO_WRITE;
 481         end = bp.bio_pblkno + bp.bio_bcount / sc->disk.d_info.d_media_blksize;
 482         MMCBUS_ACQUIRE_BUS(device_get_parent(dev), dev);
 483         block = mmcsd_rw(sc, &bp);
 484         MMCBUS_RELEASE_BUS(device_get_parent(dev), dev);
 485         return ((end < block) ? EIO : 0);
 486 #endif
 487         return EIO;
 488 }
 489
 490 static void
 491 mmcsd_task(void *arg)
 492 {
 493         struct mmcsd_softc *sc = (struct mmcsd_softc*)arg;
 494         struct bio *bio;
 495         struct buf *bp;
 496         int sz;
 497         daddr_t block, end;
 498         device_t dev;
 499
 500         get_mplock();
 501         dev = sc->dev;
 502
 503         while (1) {
 504                 MMCSD_LOCK(sc);
 505                 do {
 506                         if (sc->running == 0)
 507                                 goto out;
 508                         bio = bioq_takefirst(&sc->bio_queue);
 509                         if (bio == NULL)
 510                                 lksleep(sc, &sc->sc_lock, 0, "jobqueue", 0);
 511                 } while (bio == NULL);
 512                 bp = bio->bio_buf;
 513                 MMCSD_UNLOCK(sc);
 514                 if (bp->b_cmd != BUF_CMD_READ && mmc_get_read_only(dev)) {
 515                         bp->b_error = EROFS;
 516                         bp->b_resid = bp->b_bcount;
 517                         bp->b_flags |= B_ERROR;
 518                         devstat_end_transaction_buf(&sc->device_stats, bp);
 519                         biodone(bio);
 520                         continue;
 521                 }
 522                 MMCBUS_ACQUIRE_BUS(device_get_parent(dev), dev);
 523                 sz = sc->disk.d_info.d_media_blksize;
 524                 block = bio->bio_offset / sz;
 525                 end = block + (bp->b_bcount / sz);
 526                 if (bp->b_cmd == BUF_CMD_READ ||
 527                     bp->b_cmd == BUF_CMD_WRITE) {
 528                         /* Access to the remaining erase block obsoletes it. */
 529                         if (block < sc->eend && end > sc->eblock)
 530                                 sc->eblock = sc->eend = 0;
 531                         block = mmcsd_rw(sc, bio);
 532                 } else if (bp->b_cmd == BUF_CMD_FREEBLKS) {
 533                         block = mmcsd_delete(sc, bio);
 534                 }
 535                 MMCBUS_RELEASE_BUS(device_get_parent(dev), dev);
 536                 if (block < end) {
 537                         bp->b_error = EIO;
 538                         bp->b_resid = (end - block) * sz;
 539                         bp->b_flags |= B_ERROR;
 540                 }
 541                 devstat_end_transaction_buf(&sc->device_stats, bp);
 542                 biodone(bio);
 543         }
 544 out:
 545         /* tell parent we're done */
 546         sc->running = -1;
 547         MMCSD_UNLOCK(sc);
 548         wakeup(sc);
 549
 550         rel_mplock();
 551 }
 552
 553 static const char *
 554 mmcsd_card_name(device_t dev)
 555 {
 556         if (mmc_get_card_type(dev) == mode_mmc)
 557                 return ("MMC");
 558         if (mmc_get_high_cap(dev))
 559                 return ("SDHC");
 560         return ("SD");
 561 }
 562
 563 static int
 564 mmcsd_bus_bit_width(device_t dev)
 565 {
 566         if (mmc_get_bus_width(dev) == bus_width_1)
 567                 return (1);
 568         if (mmc_get_bus_width(dev) == bus_width_4)
 569                 return (4);
 570         return (8);
 571 }
 572
 573 static device_method_t mmcsd_methods[] = {
 574         DEVMETHOD(device_probe, mmcsd_probe),
 575         DEVMETHOD(device_attach, mmcsd_attach),
 576         DEVMETHOD(device_detach, mmcsd_detach),
 577         DEVMETHOD(device_suspend, mmcsd_suspend),
 578         DEVMETHOD(device_resume, mmcsd_resume),
 579         DEVMETHOD_END
 580 };
 581
 582 static driver_t mmcsd_driver = {
 583         "mmcsd",
 584         mmcsd_methods,
 585         sizeof(struct mmcsd_softc),
 586 };
 587 static devclass_t mmcsd_devclass;
 588
 589 DRIVER_MODULE(mmcsd, mmc, mmcsd_driver, mmcsd_devclass, NULL, NULL);