sys/arm/broadcom/bcm2835/bcm2835_sdhci.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2012 Oleksandr Tymoshenko <gonzo@freebsd.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/bus.h>
  35 #include <sys/kernel.h>
  36 #include <sys/lock.h>
  37 #include <sys/malloc.h>
  38 #include <sys/module.h>
  39 #include <sys/mutex.h>
  40 #include <sys/rman.h>
  41 #include <sys/sysctl.h>
  42 #include <sys/taskqueue.h>
  43
  44 #include <machine/bus.h>
  45
  46 #include <dev/ofw/ofw_bus.h>
  47 #include <dev/ofw/ofw_bus_subr.h>
  48
  49 #include <dev/mmc/bridge.h>
  50 #include <dev/mmc/mmcreg.h>
  51
  52 #include <dev/sdhci/sdhci.h>
  53
  54 #include "mmcbr_if.h"
  55 #include "sdhci_if.h"
  56
  57 #include "opt_mmccam.h"
  58
  59 #include "bcm2835_dma.h"
  60 #include <arm/broadcom/bcm2835/bcm2835_mbox_prop.h>
  61 #ifdef NOTYET
  62 #include <arm/broadcom/bcm2835/bcm2835_clkman.h>
  63 #endif
  64 #include <arm/broadcom/bcm2835/bcm2835_vcbus.h>
  65
  66 #define BCM2835_DEFAULT_SDHCI_FREQ      50
  67 #define BCM2838_DEFAULT_SDHCI_FREQ      100
  68
  69 #define BCM_SDHCI_BUFFER_SIZE           512
  70 /*
  71  * NUM_DMA_SEGS is the number of DMA segments we want to accommodate on average.
  72  * We add in a number of segments based on how much we may need to spill into
  73  * another segment due to crossing page boundaries.  e.g. up to PAGE_SIZE, an
  74  * extra page is needed as we can cross a page boundary exactly once.
  75  */
  76 #define NUM_DMA_SEGS                    1
  77 #define NUM_DMA_SPILL_SEGS              \
  78         ((((NUM_DMA_SEGS * BCM_SDHCI_BUFFER_SIZE) - 1) / PAGE_SIZE) + 1)
  79 #define ALLOCATED_DMA_SEGS              (NUM_DMA_SEGS + NUM_DMA_SPILL_SEGS)
  80 #define BCM_DMA_MAXSIZE                 (NUM_DMA_SEGS * BCM_SDHCI_BUFFER_SIZE)
  81
  82 #define BCM_SDHCI_SLOT_LEFT(slot)       \
  83         ((slot)->curcmd->data->len - (slot)->offset)
  84
  85 #define BCM_SDHCI_SEGSZ_LEFT(slot)      \
  86         min(BCM_DMA_MAXSIZE,            \
  87             rounddown(BCM_SDHCI_SLOT_LEFT(slot), BCM_SDHCI_BUFFER_SIZE))
  88
  89 #define DATA_PENDING_MASK       (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL)
  90 #define DATA_XFER_MASK          (DATA_PENDING_MASK | SDHCI_INT_DATA_END)
  91
  92 #ifdef DEBUG
  93 static int bcm2835_sdhci_debug = 0;
  94
  95 TUNABLE_INT("hw.bcm2835.sdhci.debug", &bcm2835_sdhci_debug);
  96 SYSCTL_INT(_hw_sdhci, OID_AUTO, bcm2835_sdhci_debug, CTLFLAG_RWTUN,
  97     &bcm2835_sdhci_debug, 0, "bcm2835 SDHCI debug level");
  98
  99 #define dprintf(fmt, args...)                                   \
 100         do {                                                    \
 101                 if (bcm2835_sdhci_debug)                        \
 102                         printf("%s: " fmt, __func__, ##args);   \
 103         }  while (0)
 104 #else
 105 #define dprintf(fmt, args...)
 106 #endif
 107
 108 static int bcm2835_sdhci_hs = 1;
 109 static int bcm2835_sdhci_pio_mode = 0;
 110
 111 struct bcm_mmc_conf {
 112         int     clock_id;
 113         int     clock_src;
 114         int     default_freq;
 115         int     quirks;
 116         bool    use_dma;
 117 };
 118
 119 struct bcm_mmc_conf bcm2835_sdhci_conf = {
 120         .clock_id       = BCM2835_MBOX_CLOCK_ID_EMMC,
 121         .clock_src      = -1,
 122         .default_freq   = BCM2835_DEFAULT_SDHCI_FREQ,
 123         .quirks         = SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
 124             SDHCI_QUIRK_BROKEN_TIMEOUT_VAL | SDHCI_QUIRK_DONT_SET_HISPD_BIT |
 125             SDHCI_QUIRK_MISSING_CAPS,
 126         .use_dma        = true
 127 };
 128
 129 struct bcm_mmc_conf bcm2838_emmc2_conf = {
 130         .clock_id       = BCM2838_MBOX_CLOCK_ID_EMMC2,
 131         .clock_src      = -1,
 132         .default_freq   = BCM2838_DEFAULT_SDHCI_FREQ,
 133         .quirks         = 0,
 134         /* XXX DMA is currently broken, but it shouldn't be. */
 135         .use_dma        = false
 136 };
 137
 138 static struct ofw_compat_data compat_data[] = {
 139         {"broadcom,bcm2835-sdhci",      (uintptr_t)&bcm2835_sdhci_conf},
 140         {"brcm,bcm2835-sdhci",          (uintptr_t)&bcm2835_sdhci_conf},
 141         {"brcm,bcm2835-mmc",            (uintptr_t)&bcm2835_sdhci_conf},
 142         {"brcm,bcm2711-emmc2",          (uintptr_t)&bcm2838_emmc2_conf},
 143         {"brcm,bcm2838-emmc2",          (uintptr_t)&bcm2838_emmc2_conf},
 144         {NULL,                          0}
 145 };
 146
 147 TUNABLE_INT("hw.bcm2835.sdhci.hs", &bcm2835_sdhci_hs);
 148 TUNABLE_INT("hw.bcm2835.sdhci.pio_mode", &bcm2835_sdhci_pio_mode);
 149
 150 struct bcm_sdhci_softc {
 151         device_t                sc_dev;
 152         struct resource *       sc_mem_res;
 153         struct resource *       sc_irq_res;
 154         bus_space_tag_t         sc_bst;
 155         bus_space_handle_t      sc_bsh;
 156         void *                  sc_intrhand;
 157         struct mmc_request *    sc_req;
 158         struct sdhci_slot       sc_slot;
 159         int                     sc_dma_ch;
 160         bus_dma_tag_t           sc_dma_tag;
 161         bus_dmamap_t            sc_dma_map;
 162         vm_paddr_t              sc_sdhci_buffer_phys;
 163         bus_addr_t              dmamap_seg_addrs[ALLOCATED_DMA_SEGS];
 164         bus_size_t              dmamap_seg_sizes[ALLOCATED_DMA_SEGS];
 165         int                     dmamap_seg_count;
 166         int                     dmamap_seg_index;
 167         int                     dmamap_status;
 168         uint32_t                blksz_and_count;
 169         uint32_t                cmd_and_mode;
 170         bool                    need_update_blk;
 171 #ifdef NOTYET
 172         device_t                clkman;
 173 #endif
 174         struct bcm_mmc_conf *   conf;
 175 };
 176
 177 static int bcm_sdhci_probe(device_t);
 178 static int bcm_sdhci_attach(device_t);
 179 static int bcm_sdhci_detach(device_t);
 180 static void bcm_sdhci_intr(void *);
 181
 182 static int bcm_sdhci_get_ro(device_t, device_t);
 183 static void bcm_sdhci_dma_intr(int ch, void *arg);
 184 static void bcm_sdhci_start_dma(struct sdhci_slot *slot);
 185
 186 static void
 187 bcm_sdhci_dmacb(void *arg, bus_dma_segment_t *segs, int nseg, int err)
 188 {
 189         struct bcm_sdhci_softc *sc = arg;
 190         int i;
 191
 192         /* Sanity check: we can only ever have one mapping at a time. */
 193         KASSERT(sc->dmamap_seg_count == 0, ("leaked DMA segment"));
 194         sc->dmamap_status = err;
 195         sc->dmamap_seg_count = nseg;
 196
 197         /* Note nseg is guaranteed to be zero if err is non-zero. */
 198         for (i = 0; i < nseg; i++) {
 199                 sc->dmamap_seg_addrs[i] = segs[i].ds_addr;
 200                 sc->dmamap_seg_sizes[i] = segs[i].ds_len;
 201         }
 202 }
 203
 204 static int
 205 bcm_sdhci_probe(device_t dev)
 206 {
 207
 208         if (!ofw_bus_status_okay(dev))
 209                 return (ENXIO);
 210
 211         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
 212                 return (ENXIO);
 213
 214         device_set_desc(dev, "Broadcom 2708 SDHCI controller");
 215
 216         return (BUS_PROBE_DEFAULT);
 217 }
 218
 219 static int
 220 bcm_sdhci_attach(device_t dev)
 221 {
 222         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 223         int rid, err;
 224         phandle_t node;
 225         pcell_t cell;
 226         u_int default_freq;
 227
 228         sc->sc_dev = dev;
 229         sc->sc_req = NULL;
 230
 231         sc->conf = (struct bcm_mmc_conf *)ofw_bus_search_compatible(dev,
 232             compat_data)->ocd_data;
 233         if (sc->conf == 0)
 234             return (ENXIO);
 235
 236         err = bcm2835_mbox_set_power_state(BCM2835_MBOX_POWER_ID_EMMC, TRUE);
 237         if (err != 0) {
 238                 if (bootverbose)
 239                         device_printf(dev, "Unable to enable the power\n");
 240                 return (err);
 241         }
 242
 243         default_freq = 0;
 244         err = bcm2835_mbox_get_clock_rate(sc->conf->clock_id, &default_freq);
 245         if (err == 0) {
 246                 /* Convert to MHz */
 247                 default_freq /= 1000000;
 248         }
 249         if (default_freq == 0) {
 250                 node = ofw_bus_get_node(sc->sc_dev);
 251                 if ((OF_getencprop(node, "clock-frequency", &cell,
 252                     sizeof(cell))) > 0)
 253                         default_freq = cell / 1000000;
 254         }
 255         if (default_freq == 0)
 256                 default_freq = sc->conf->default_freq;
 257
 258         if (bootverbose)
 259                 device_printf(dev, "SDHCI frequency: %dMHz\n", default_freq);
 260 #ifdef NOTYET
 261         if (sc->conf->clock_src > 0) {
 262                 uint32_t f;
 263                 sc->clkman = devclass_get_device(
 264                     devclass_find("bcm2835_clkman"), 0);
 265                 if (sc->clkman == NULL) {
 266                         device_printf(dev, "cannot find Clock Manager\n");
 267                         return (ENXIO);
 268                 }
 269
 270                 f = bcm2835_clkman_set_frequency(sc->clkman,
 271                     sc->conf->clock_src, default_freq);
 272                 if (f == 0)
 273                         return (EINVAL);
 274
 275                 if (bootverbose)
 276                         device_printf(dev, "Clock source frequency: %dMHz\n",
 277                             f);
 278         }
 279 #endif
 280
 281         rid = 0;
 282         sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 283             RF_ACTIVE);
 284         if (!sc->sc_mem_res) {
 285                 device_printf(dev, "cannot allocate memory window\n");
 286                 err = ENXIO;
 287                 goto fail;
 288         }
 289
 290         sc->sc_bst = rman_get_bustag(sc->sc_mem_res);
 291         sc->sc_bsh = rman_get_bushandle(sc->sc_mem_res);
 292
 293         rid = 0;
 294         sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 295             RF_ACTIVE | RF_SHAREABLE);
 296         if (!sc->sc_irq_res) {
 297                 device_printf(dev, "cannot allocate interrupt\n");
 298                 err = ENXIO;
 299                 goto fail;
 300         }
 301
 302         if (bus_setup_intr(dev, sc->sc_irq_res, INTR_TYPE_BIO | INTR_MPSAFE,
 303             NULL, bcm_sdhci_intr, sc, &sc->sc_intrhand)) {
 304                 device_printf(dev, "cannot setup interrupt handler\n");
 305                 err = ENXIO;
 306                 goto fail;
 307         }
 308
 309         if (!bcm2835_sdhci_pio_mode)
 310                 sc->sc_slot.opt = SDHCI_PLATFORM_TRANSFER;
 311
 312         sc->sc_slot.caps = SDHCI_CAN_VDD_330 | SDHCI_CAN_VDD_180;
 313         if (bcm2835_sdhci_hs)
 314                 sc->sc_slot.caps |= SDHCI_CAN_DO_HISPD;
 315         sc->sc_slot.caps |= (default_freq << SDHCI_CLOCK_BASE_SHIFT);
 316         sc->sc_slot.quirks = sc->conf->quirks;
 317
 318         sdhci_init_slot(dev, &sc->sc_slot, 0);
 319
 320         if (sc->conf->use_dma) {
 321                 sc->sc_dma_ch = bcm_dma_allocate(BCM_DMA_CH_ANY);
 322                 if (sc->sc_dma_ch == BCM_DMA_CH_INVALID)
 323                         goto fail;
 324
 325                 err = bcm_dma_setup_intr(sc->sc_dma_ch, bcm_sdhci_dma_intr, sc);
 326                 if (err != 0) {
 327                         device_printf(dev,
 328                             "cannot setup dma interrupt handler\n");
 329                         err = ENXIO;
 330                         goto fail;
 331                 }
 332
 333                 /* Allocate bus_dma resources. */
 334                 err = bus_dma_tag_create(bus_get_dma_tag(dev),
 335                     1, 0, bcm283x_dmabus_peripheral_lowaddr(),
 336                     BUS_SPACE_MAXADDR, NULL, NULL,
 337                     BCM_DMA_MAXSIZE, ALLOCATED_DMA_SEGS, BCM_SDHCI_BUFFER_SIZE,
 338                     BUS_DMA_ALLOCNOW, NULL, NULL,
 339                     &sc->sc_dma_tag);
 340
 341                 if (err) {
 342                         device_printf(dev, "failed allocate DMA tag");
 343                         goto fail;
 344                 }
 345
 346                 err = bus_dmamap_create(sc->sc_dma_tag, 0, &sc->sc_dma_map);
 347                 if (err) {
 348                         device_printf(dev, "bus_dmamap_create failed\n");
 349                         goto fail;
 350                 }
 351         }
 352
 353         /* FIXME: Fix along with other BUS_SPACE_PHYSADDR instances */
 354         sc->sc_sdhci_buffer_phys = rman_get_start(sc->sc_mem_res) +
 355             SDHCI_BUFFER;
 356
 357         bus_generic_probe(dev);
 358         bus_generic_attach(dev);
 359
 360         sdhci_start_slot(&sc->sc_slot);
 361
 362         /* Seed our copies. */
 363         sc->blksz_and_count = SDHCI_READ_4(dev, &sc->sc_slot, SDHCI_BLOCK_SIZE);
 364         sc->cmd_and_mode = SDHCI_READ_4(dev, &sc->sc_slot, SDHCI_TRANSFER_MODE);
 365
 366         return (0);
 367
 368 fail:
 369         if (sc->sc_intrhand)
 370                 bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_intrhand);
 371         if (sc->sc_irq_res)
 372                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res);
 373         if (sc->sc_mem_res)
 374                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);
 375
 376         return (err);
 377 }
 378
 379 static int
 380 bcm_sdhci_detach(device_t dev)
 381 {
 382
 383         return (EBUSY);
 384 }
 385
 386 static void
 387 bcm_sdhci_intr(void *arg)
 388 {
 389         struct bcm_sdhci_softc *sc = arg;
 390
 391         sdhci_generic_intr(&sc->sc_slot);
 392 }
 393
 394 static int
 395 bcm_sdhci_get_ro(device_t bus, device_t child)
 396 {
 397
 398         return (0);
 399 }
 400
 401 static inline uint32_t
 402 RD4(struct bcm_sdhci_softc *sc, bus_size_t off)
 403 {
 404         uint32_t val = bus_space_read_4(sc->sc_bst, sc->sc_bsh, off);
 405         return val;
 406 }
 407
 408 static inline void
 409 WR4(struct bcm_sdhci_softc *sc, bus_size_t off, uint32_t val)
 410 {
 411
 412         bus_space_write_4(sc->sc_bst, sc->sc_bsh, off, val);
 413         /*
 414          * The Arasan HC has a bug where it may lose the content of
 415          * consecutive writes to registers that are within two SD-card
 416          * clock cycles of each other (a clock domain crossing problem).
 417          */
 418         if (sc->sc_slot.clock > 0)
 419                 DELAY(((2 * 1000000) / sc->sc_slot.clock) + 1);
 420 }
 421
 422 static uint8_t
 423 bcm_sdhci_read_1(device_t dev, struct sdhci_slot *slot, bus_size_t off)
 424 {
 425         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 426         uint32_t val = RD4(sc, off & ~3);
 427
 428         return ((val >> (off & 3)*8) & 0xff);
 429 }
 430
 431 static uint16_t
 432 bcm_sdhci_read_2(device_t dev, struct sdhci_slot *slot, bus_size_t off)
 433 {
 434         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 435         uint32_t val32;
 436
 437         /*
 438          * Standard 32-bit handling of command and transfer mode, as
 439          * well as block size and count.
 440          */
 441         if ((off == SDHCI_BLOCK_SIZE || off == SDHCI_BLOCK_COUNT) &&
 442             sc->need_update_blk)
 443                 val32 = sc->blksz_and_count;
 444         else if (off == SDHCI_TRANSFER_MODE || off == SDHCI_COMMAND_FLAGS)
 445                 val32 = sc->cmd_and_mode;
 446         else
 447                 val32 = RD4(sc, off & ~3);
 448
 449         return ((val32 >> (off & 3)*8) & 0xffff);
 450 }
 451
 452 static uint32_t
 453 bcm_sdhci_read_4(device_t dev, struct sdhci_slot *slot, bus_size_t off)
 454 {
 455         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 456
 457         return RD4(sc, off);
 458 }
 459
 460 static void
 461 bcm_sdhci_read_multi_4(device_t dev, struct sdhci_slot *slot, bus_size_t off,
 462     uint32_t *data, bus_size_t count)
 463 {
 464         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 465
 466         bus_space_read_multi_4(sc->sc_bst, sc->sc_bsh, off, data, count);
 467 }
 468
 469 static void
 470 bcm_sdhci_write_1(device_t dev, struct sdhci_slot *slot, bus_size_t off,
 471     uint8_t val)
 472 {
 473         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 474         uint32_t val32 = RD4(sc, off & ~3);
 475         val32 &= ~(0xff << (off & 3)*8);
 476         val32 |= (val << (off & 3)*8);
 477         WR4(sc, off & ~3, val32);
 478 }
 479
 480 static void
 481 bcm_sdhci_write_2(device_t dev, struct sdhci_slot *slot, bus_size_t off,
 482     uint16_t val)
 483 {
 484         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 485         uint32_t val32;
 486
 487         /*
 488          * If we have a queued up 16bit value for blk size or count, use and
 489          * update the saved value rather than doing any real register access.
 490          * If we did not touch either since the last write, then read from
 491          * register as at least block count can change.
 492          * Similarly, if we are about to issue a command, always use the saved
 493          * value for transfer mode as we can never write that without issuing
 494          * a command.
 495          */
 496         if ((off == SDHCI_BLOCK_SIZE || off == SDHCI_BLOCK_COUNT) &&
 497             sc->need_update_blk)
 498                 val32 = sc->blksz_and_count;
 499         else if (off == SDHCI_COMMAND_FLAGS)
 500                 val32 = sc->cmd_and_mode;
 501         else
 502                 val32 = RD4(sc, off & ~3);
 503
 504         val32 &= ~(0xffff << (off & 3)*8);
 505         val32 |= (val << (off & 3)*8);
 506
 507         if (off == SDHCI_TRANSFER_MODE)
 508                 sc->cmd_and_mode = val32;
 509         else if (off == SDHCI_BLOCK_SIZE || off == SDHCI_BLOCK_COUNT) {
 510                 sc->blksz_and_count = val32;
 511                 sc->need_update_blk = true;
 512         } else {
 513                 if (off == SDHCI_COMMAND_FLAGS) {
 514                         /* If we saved blk writes, do them now before cmd. */
 515                         if (sc->need_update_blk) {
 516                                 WR4(sc, SDHCI_BLOCK_SIZE, sc->blksz_and_count);
 517                                 sc->need_update_blk = false;
 518                         }
 519                         /* Always save cmd and mode registers. */
 520                         sc->cmd_and_mode = val32;
 521                 }
 522                 WR4(sc, off & ~3, val32);
 523         }
 524 }
 525
 526 static void
 527 bcm_sdhci_write_4(device_t dev, struct sdhci_slot *slot, bus_size_t off,
 528     uint32_t val)
 529 {
 530         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 531         WR4(sc, off, val);
 532 }
 533
 534 static void
 535 bcm_sdhci_write_multi_4(device_t dev, struct sdhci_slot *slot, bus_size_t off,
 536     uint32_t *data, bus_size_t count)
 537 {
 538         struct bcm_sdhci_softc *sc = device_get_softc(dev);
 539
 540         bus_space_write_multi_4(sc->sc_bst, sc->sc_bsh, off, data, count);
 541 }
 542
 543 static void
 544 bcm_sdhci_start_dma_seg(struct bcm_sdhci_softc *sc)
 545 {
 546         struct sdhci_slot *slot;
 547         vm_paddr_t pdst, psrc;
 548         int err, idx, len, sync_op, width;
 549
 550         slot = &sc->sc_slot;
 551         mtx_assert(&slot->mtx, MA_OWNED);
 552         idx = sc->dmamap_seg_index++;
 553         len = sc->dmamap_seg_sizes[idx];
 554         slot->offset += len;
 555         width = (len & 0xf ? BCM_DMA_32BIT : BCM_DMA_128BIT);
 556
 557         if (slot->curcmd->data->flags & MMC_DATA_READ) {
 558                 bcm_dma_setup_src(sc->sc_dma_ch, BCM_DMA_DREQ_EMMC,
 559                     BCM_DMA_SAME_ADDR, BCM_DMA_32BIT);
 560                 bcm_dma_setup_dst(sc->sc_dma_ch, BCM_DMA_DREQ_NONE,
 561                     BCM_DMA_INC_ADDR, width);
 562                 psrc = sc->sc_sdhci_buffer_phys;
 563                 pdst = sc->dmamap_seg_addrs[idx];
 564                 sync_op = BUS_DMASYNC_PREREAD;
 565         } else {
 566                 bcm_dma_setup_src(sc->sc_dma_ch, BCM_DMA_DREQ_NONE,
 567                     BCM_DMA_INC_ADDR, width);
 568                 bcm_dma_setup_dst(sc->sc_dma_ch, BCM_DMA_DREQ_EMMC,
 569                     BCM_DMA_SAME_ADDR, BCM_DMA_32BIT);
 570                 psrc = sc->dmamap_seg_addrs[idx];
 571                 pdst = sc->sc_sdhci_buffer_phys;
 572                 sync_op = BUS_DMASYNC_PREWRITE;
 573         }
 574
 575         /*
 576          * When starting a new DMA operation do the busdma sync operation, and
 577          * disable SDCHI data interrrupts because we'll be driven by DMA
 578          * interrupts (or SDHCI error interrupts) until the IO is done.
 579          */
 580         if (idx == 0) {
 581                 bus_dmamap_sync(sc->sc_dma_tag, sc->sc_dma_map, sync_op);
 582
 583                 slot->intmask &= ~DATA_XFER_MASK;
 584                 bcm_sdhci_write_4(sc->sc_dev, slot, SDHCI_SIGNAL_ENABLE,
 585                     slot->intmask);
 586         }
 587
 588         /*
 589          * Start the DMA transfer.  Only programming errors (like failing to
 590          * allocate a channel) cause a non-zero return from bcm_dma_start().
 591          */
 592         err = bcm_dma_start(sc->sc_dma_ch, psrc, pdst, len);
 593         KASSERT((err == 0), ("bcm2835_sdhci: failed DMA start"));
 594 }
 595
 596 static void
 597 bcm_sdhci_dma_exit(struct bcm_sdhci_softc *sc)
 598 {
 599         struct sdhci_slot *slot = &sc->sc_slot;
 600
 601         mtx_assert(&slot->mtx, MA_OWNED);
 602
 603         /* Re-enable interrupts */
 604         slot->intmask |= DATA_XFER_MASK;
 605         bcm_sdhci_write_4(slot->bus, slot, SDHCI_SIGNAL_ENABLE,
 606             slot->intmask);
 607 }
 608
 609 static void
 610 bcm_sdhci_dma_unload(struct bcm_sdhci_softc *sc)
 611 {
 612         struct sdhci_slot *slot = &sc->sc_slot;
 613
 614         if (sc->dmamap_seg_count == 0)
 615                 return;
 616         if ((slot->curcmd->data->flags & MMC_DATA_READ) != 0)
 617                 bus_dmamap_sync(sc->sc_dma_tag, sc->sc_dma_map,
 618                     BUS_DMASYNC_POSTREAD);
 619         else
 620                 bus_dmamap_sync(sc->sc_dma_tag, sc->sc_dma_map,
 621                     BUS_DMASYNC_POSTWRITE);
 622         bus_dmamap_unload(sc->sc_dma_tag, sc->sc_dma_map);
 623
 624         sc->dmamap_seg_count = 0;
 625         sc->dmamap_seg_index = 0;
 626 }
 627
 628 static void
 629 bcm_sdhci_dma_intr(int ch, void *arg)
 630 {
 631         struct bcm_sdhci_softc *sc = (struct bcm_sdhci_softc *)arg;
 632         struct sdhci_slot *slot = &sc->sc_slot;
 633         uint32_t reg;
 634
 635         mtx_lock(&slot->mtx);
 636         if (slot->curcmd == NULL)
 637                 goto out;
 638         /*
 639          * If there are more segments for the current dma, start the next one.
 640          * Otherwise unload the dma map and decide what to do next based on the
 641          * status of the sdhci controller and whether there's more data left.
 642          */
 643         if (sc->dmamap_seg_index < sc->dmamap_seg_count) {
 644                 bcm_sdhci_start_dma_seg(sc);
 645                 goto out;
 646         }
 647
 648         bcm_sdhci_dma_unload(sc);
 649
 650         /*
 651          * If we had no further segments pending, we need to determine how to
 652          * proceed next.  If the 'data/space pending' bit is already set and we
 653          * can continue via DMA, do so.  Otherwise, re-enable interrupts and
 654          * return.
 655          */
 656         reg = bcm_sdhci_read_4(slot->bus, slot, SDHCI_INT_STATUS);
 657         if ((reg & DATA_PENDING_MASK) != 0 &&
 658             BCM_SDHCI_SEGSZ_LEFT(slot) >= BCM_SDHCI_BUFFER_SIZE) {
 659                 /* ACK any pending interrupts */
 660                 bcm_sdhci_write_4(slot->bus, slot, SDHCI_INT_STATUS,
 661                     DATA_PENDING_MASK);
 662
 663                 bcm_sdhci_start_dma(slot);
 664                 if (slot->curcmd->error != 0) {
 665                         /* We won't recover from this error for this command. */
 666                         bcm_sdhci_dma_unload(sc);
 667                         bcm_sdhci_dma_exit(sc);
 668                         sdhci_finish_data(slot);
 669                 }
 670         } else if ((reg & SDHCI_INT_DATA_END) != 0) {
 671                 bcm_sdhci_dma_exit(sc);
 672                 bcm_sdhci_write_4(slot->bus, slot, SDHCI_INT_STATUS,
 673                     reg);
 674                 slot->flags &= ~PLATFORM_DATA_STARTED;
 675                 sdhci_finish_data(slot);
 676         } else {
 677                 bcm_sdhci_dma_exit(sc);
 678         }
 679 out:
 680         mtx_unlock(&slot->mtx);
 681 }
 682
 683 static void
 684 bcm_sdhci_start_dma(struct sdhci_slot *slot)
 685 {
 686         struct bcm_sdhci_softc *sc = device_get_softc(slot->bus);
 687         uint8_t *buf;
 688         size_t left;
 689
 690         mtx_assert(&slot->mtx, MA_OWNED);
 691
 692         left = BCM_SDHCI_SEGSZ_LEFT(slot);
 693         buf = (uint8_t *)slot->curcmd->data->data + slot->offset;
 694         KASSERT(left != 0,
 695             ("%s: DMA handling incorrectly indicated", __func__));
 696
 697         /*
 698          * No need to check segment count here; if we've not yet unloaded
 699          * previous segments, we'll catch that in bcm_sdhci_dmacb.
 700          */
 701         if (bus_dmamap_load(sc->sc_dma_tag, sc->sc_dma_map, buf, left,
 702             bcm_sdhci_dmacb, sc, BUS_DMA_NOWAIT) != 0 ||
 703             sc->dmamap_status != 0) {
 704                 slot->curcmd->error = MMC_ERR_NO_MEMORY;
 705                 return;
 706         }
 707
 708         /* DMA start */
 709         bcm_sdhci_start_dma_seg(sc);
 710 }
 711
 712 static int
 713 bcm_sdhci_will_handle_transfer(device_t dev, struct sdhci_slot *slot)
 714 {
 715         struct bcm_sdhci_softc *sc = device_get_softc(slot->bus);
 716
 717         if (!sc->conf->use_dma)
 718                 return (0);
 719
 720         /*
 721          * This indicates that we somehow let a data interrupt slip by into the
 722          * SDHCI framework, when it should not have.  This really needs to be
 723          * caught and fixed ASAP, as it really shouldn't happen.
 724          */
 725         KASSERT(sc->dmamap_seg_count == 0,
 726             ("data pending interrupt pushed through SDHCI framework"));
 727
 728         /*
 729          * Do not use DMA for transfers less than our block size.  Checking
 730          * alignment serves little benefit, as we round transfer sizes down to
 731          * a multiple of the block size and push the transfer back to
 732          * SDHCI-driven PIO once we're below the block size.
 733          */
 734         if (BCM_SDHCI_SEGSZ_LEFT(slot) < BCM_DMA_BLOCK_SIZE)
 735                 return (0);
 736
 737         return (1);
 738 }
 739
 740 static void
 741 bcm_sdhci_start_transfer(device_t dev, struct sdhci_slot *slot,
 742     uint32_t *intmask)
 743 {
 744
 745         /* DMA transfer FIFO 1KB */
 746         bcm_sdhci_start_dma(slot);
 747 }
 748
 749 static void
 750 bcm_sdhci_finish_transfer(device_t dev, struct sdhci_slot *slot)
 751 {
 752         struct bcm_sdhci_softc *sc = device_get_softc(slot->bus);
 753
 754         /*
 755          * Clean up.  Interrupts are clearly enabled, because we received an
 756          * SDHCI_INT_DATA_END to get this far -- just make sure we don't leave
 757          * anything laying around.
 758          */
 759         if (sc->dmamap_seg_count != 0) {
 760                 /*
 761                  * Our segment math should have worked out such that we would
 762                  * never finish the transfer without having used up all of the
 763                  * segments.  If we haven't, that means we must have erroneously
 764                  * regressed to SDHCI-driven PIO to finish the operation and
 765                  * this is certainly caused by developer-error.
 766                  */
 767                 bcm_sdhci_dma_unload(sc);
 768         }
 769
 770         sdhci_finish_data(slot);
 771 }
 772
 773 static device_method_t bcm_sdhci_methods[] = {
 774         /* Device interface */
 775         DEVMETHOD(device_probe,         bcm_sdhci_probe),
 776         DEVMETHOD(device_attach,        bcm_sdhci_attach),
 777         DEVMETHOD(device_detach,        bcm_sdhci_detach),
 778
 779         /* Bus interface */
 780         DEVMETHOD(bus_read_ivar,        sdhci_generic_read_ivar),
 781         DEVMETHOD(bus_write_ivar,       sdhci_generic_write_ivar),
 782         DEVMETHOD(bus_add_child,        bus_generic_add_child),
 783
 784         /* MMC bridge interface */
 785         DEVMETHOD(mmcbr_update_ios,     sdhci_generic_update_ios),
 786         DEVMETHOD(mmcbr_request,        sdhci_generic_request),
 787         DEVMETHOD(mmcbr_get_ro,         bcm_sdhci_get_ro),
 788         DEVMETHOD(mmcbr_acquire_host,   sdhci_generic_acquire_host),
 789         DEVMETHOD(mmcbr_release_host,   sdhci_generic_release_host),
 790
 791         /* Platform transfer methods */
 792         DEVMETHOD(sdhci_platform_will_handle,           bcm_sdhci_will_handle_transfer),
 793         DEVMETHOD(sdhci_platform_start_transfer,        bcm_sdhci_start_transfer),
 794         DEVMETHOD(sdhci_platform_finish_transfer,       bcm_sdhci_finish_transfer),
 795         /* SDHCI registers accessors */
 796         DEVMETHOD(sdhci_read_1,         bcm_sdhci_read_1),
 797         DEVMETHOD(sdhci_read_2,         bcm_sdhci_read_2),
 798         DEVMETHOD(sdhci_read_4,         bcm_sdhci_read_4),
 799         DEVMETHOD(sdhci_read_multi_4,   bcm_sdhci_read_multi_4),
 800         DEVMETHOD(sdhci_write_1,        bcm_sdhci_write_1),
 801         DEVMETHOD(sdhci_write_2,        bcm_sdhci_write_2),
 802         DEVMETHOD(sdhci_write_4,        bcm_sdhci_write_4),
 803         DEVMETHOD(sdhci_write_multi_4,  bcm_sdhci_write_multi_4),
 804
 805         DEVMETHOD_END
 806 };
 807
 808 static devclass_t bcm_sdhci_devclass;
 809
 810 static driver_t bcm_sdhci_driver = {
 811         "sdhci_bcm",
 812         bcm_sdhci_methods,
 813         sizeof(struct bcm_sdhci_softc),
 814 };
 815
 816 DRIVER_MODULE(sdhci_bcm, simplebus, bcm_sdhci_driver, bcm_sdhci_devclass,
 817     NULL, NULL);
 818 #ifdef NOTYET
 819 MODULE_DEPEND(sdhci_bcm, bcm2835_clkman, 1, 1, 1);
 820 #endif
 821 SDHCI_DEPEND(sdhci_bcm);
 822 #ifndef MMCCAM
 823 MMC_DECLARE_BRIDGE(sdhci_bcm);
 824 #endif