sys/riscv/sifive/fu540_spi.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2019 Axiado Corporation
   5  * All rights reserved.
   6  *
   7  * This software was developed in part by Philip Paeps and Kristof Provost
   8  * under contract for Axiado Corporation.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/bus.h>
  38 #include <sys/kernel.h>
  39 #include <sys/lock.h>
  40 #include <sys/module.h>
  41 #include <sys/mutex.h>
  42 #include <sys/rman.h>
  43
  44 #include <machine/bus.h>
  45 #include <machine/cpu.h>
  46
  47 #include <dev/extres/clk/clk.h>
  48
  49 #include <dev/ofw/ofw_bus.h>
  50 #include <dev/ofw/ofw_bus_subr.h>
  51 #include <dev/ofw/openfirm.h>
  52
  53 #include <dev/spibus/spi.h>
  54 #include <dev/spibus/spibusvar.h>
  55
  56 #include "spibus_if.h"
  57
  58 #if 1
  59 #define DBGPRINT(dev, fmt, args...) \
  60         device_printf(dev, "%s: " fmt "\n", __func__, ## args)
  61 #else
  62 #define DBGPRINT(dev, fmt, args...)
  63 #endif
  64
  65 static struct resource_spec fuspi_spec[] = {
  66         { SYS_RES_MEMORY, 0, RF_ACTIVE },
  67         RESOURCE_SPEC_END
  68 };
  69
  70 struct fuspi_softc {
  71         device_t                dev;
  72         device_t                parent;
  73
  74         struct mtx              mtx;
  75
  76         struct resource         *res;
  77         bus_space_tag_t         bst;
  78         bus_space_handle_t      bsh;
  79
  80         void                    *ih;
  81
  82         clk_t                   clk;
  83         uint64_t                freq;
  84         uint32_t                cs_max;
  85 };
  86
  87 #define FUSPI_LOCK(sc)                  mtx_lock(&(sc)->mtx)
  88 #define FUSPI_UNLOCK(sc)                mtx_unlock(&(sc)->mtx)
  89 #define FUSPI_ASSERT_LOCKED(sc)         mtx_assert(&(sc)->mtx, MA_OWNED);
  90 #define FUSPI_ASSERT_UNLOCKED(sc)       mtx_assert(&(sc)->mtx, MA_NOTOWNED);
  91
  92 /*
  93  * Register offsets.
  94  * From Sifive-Unleashed-FU540-C000-v1.0.pdf page 101.
  95  */
  96 #define FUSPI_REG_SCKDIV        0x00 /* Serial clock divisor */
  97 #define FUSPI_REG_SCKMODE       0x04 /* Serial clock mode */
  98 #define FUSPI_REG_CSID          0x10 /* Chip select ID */
  99 #define FUSPI_REG_CSDEF         0x14 /* Chip select default */
 100 #define FUSPI_REG_CSMODE        0x18 /* Chip select mode */
 101 #define FUSPI_REG_DELAY0        0x28 /* Delay control 0 */
 102 #define FUSPI_REG_DELAY1        0x2C /* Delay control 1 */
 103 #define FUSPI_REG_FMT           0x40 /* Frame format */
 104 #define FUSPI_REG_TXDATA        0x48 /* Tx FIFO data */
 105 #define FUSPI_REG_RXDATA        0x4C /* Rx FIFO data */
 106 #define FUSPI_REG_TXMARK        0x50 /* Tx FIFO watermark */
 107 #define FUSPI_REG_RXMARK        0x54 /* Rx FIFO watermark */
 108 #define FUSPI_REG_FCTRL         0x60 /* SPI flash interface control* */
 109 #define FUSPI_REG_FFMT          0x64 /* SPI flash instruction format* */
 110 #define FUSPI_REG_IE            0x70 /* SPI interrupt enable */
 111 #define FUSPI_REG_IP            0x74 /* SPI interrupt pending */
 112
 113 #define FUSPI_SCKDIV_MASK       0xfff
 114
 115 #define FUSPI_CSDEF_ALL         ((1 << sc->cs_max)-1)
 116
 117 #define FUSPI_CSMODE_AUTO       0x0U
 118 #define FUSPI_CSMODE_HOLD       0x2U
 119 #define FUSPI_CSMODE_OFF        0x3U
 120
 121 #define FUSPI_TXDATA_DATA_MASK  0xff
 122 #define FUSPI_TXDATA_FULL       (1 << 31)
 123
 124 #define FUSPI_RXDATA_DATA_MASK  0xff
 125 #define FUSPI_RXDATA_EMPTY      (1 << 31)
 126
 127 #define FUSPI_SCKMODE_PHA       (1 << 0)
 128 #define FUSPI_SCKMODE_POL       (1 << 1)
 129
 130 #define FUSPI_FMT_PROTO_SINGLE  0x0U
 131 #define FUSPI_FMT_PROTO_DUAL    0x1U
 132 #define FUSPI_FMT_PROTO_QUAD    0x2U
 133 #define FUSPI_FMT_PROTO_MASK    0x3U
 134 #define FUSPI_FMT_ENDIAN        (1 << 2)
 135 #define FUSPI_FMT_DIR           (1 << 3)
 136 #define FUSPI_FMT_LEN(x)        ((uint32_t)(x) << 16)
 137 #define FUSPI_FMT_LEN_MASK      (0xfU << 16)
 138
 139 #define FUSPI_FIFO_DEPTH        8
 140
 141 #define FUSPI_READ(_sc, _reg)           \
 142     bus_space_read_4((_sc)->bst, (_sc)->bsh, (_reg))
 143 #define FUSPI_WRITE(_sc, _reg, _val)    \
 144     bus_space_write_4((_sc)->bst, (_sc)->bsh, (_reg), (_val))
 145
 146 static void
 147 fuspi_tx(struct fuspi_softc *sc, uint8_t *buf, uint32_t bufsiz)
 148 {
 149         uint32_t val;
 150         uint8_t *p, *end;
 151
 152         KASSERT(buf != NULL, ("TX buffer cannot be NULL"));
 153
 154         end = buf + bufsiz;
 155         for (p = buf; p < end; p++) {
 156                 do {
 157                         val = FUSPI_READ(sc, FUSPI_REG_TXDATA);
 158                 } while (val & FUSPI_TXDATA_FULL);
 159                 val = *p;
 160                 FUSPI_WRITE(sc, FUSPI_REG_TXDATA, val);
 161         }
 162 }
 163
 164 static void
 165 fuspi_rx(struct fuspi_softc *sc, uint8_t *buf, uint32_t bufsiz)
 166 {
 167         uint32_t val;
 168         uint8_t *p, *end;
 169
 170         KASSERT(buf != NULL, ("RX buffer cannot be NULL"));
 171         KASSERT(bufsiz <= FUSPI_FIFO_DEPTH,
 172             ("Cannot receive more than %d bytes at a time\n",
 173             FUSPI_FIFO_DEPTH));
 174
 175         end = buf + bufsiz;
 176         for (p = buf; p < end; p++) {
 177                 do {
 178                         val = FUSPI_READ(sc, FUSPI_REG_RXDATA);
 179                 } while (val & FUSPI_RXDATA_EMPTY);
 180                 *p = val & FUSPI_RXDATA_DATA_MASK;
 181         };
 182 }
 183
 184 static int
 185 fuspi_xfer_buf(struct fuspi_softc *sc, uint8_t *rxbuf, uint8_t *txbuf,
 186     uint32_t txlen, uint32_t rxlen)
 187 {
 188         uint32_t bytes;
 189
 190         KASSERT(txlen == rxlen, ("TX and RX lengths must be equal"));
 191         KASSERT(rxbuf != NULL, ("RX buffer cannot be NULL"));
 192         KASSERT(txbuf != NULL, ("TX buffer cannot be NULL"));
 193
 194         while (txlen) {
 195                 bytes = (txlen > FUSPI_FIFO_DEPTH) ? FUSPI_FIFO_DEPTH : txlen;
 196                 fuspi_tx(sc, txbuf, bytes);
 197                 txbuf += bytes;
 198                 fuspi_rx(sc, rxbuf, bytes);
 199                 rxbuf += bytes;
 200                 txlen -= bytes;
 201         }
 202
 203         return (0);
 204 }
 205
 206 static int
 207 fuspi_setup(struct fuspi_softc *sc, uint32_t cs, uint32_t mode,
 208     uint32_t freq)
 209 {
 210         uint32_t csmode, fmt, sckdiv, sckmode;
 211
 212         FUSPI_ASSERT_LOCKED(sc);
 213
 214         /*
 215          * Fsck = Fin / 2 * (div + 1)
 216          * -> div = Fin / (2 * Fsck) - 1
 217          */
 218         sckdiv = (howmany(sc->freq >> 1, freq) - 1) & FUSPI_SCKDIV_MASK;
 219         FUSPI_WRITE(sc, FUSPI_REG_SCKDIV, sckdiv);
 220
 221         switch (mode) {
 222         case SPIBUS_MODE_CPHA:
 223                 sckmode = FUSPI_SCKMODE_PHA;
 224                 break;
 225         case SPIBUS_MODE_CPOL:
 226                 sckmode = FUSPI_SCKMODE_POL;
 227                 break;
 228         case SPIBUS_MODE_CPOL_CPHA:
 229                 sckmode = FUSPI_SCKMODE_PHA | FUSPI_SCKMODE_POL;
 230                 break;
 231         }
 232         FUSPI_WRITE(sc, FUSPI_REG_SCKMODE, sckmode);
 233
 234         csmode = FUSPI_CSMODE_HOLD;
 235         if (cs & SPIBUS_CS_HIGH)
 236                 csmode = FUSPI_CSMODE_AUTO;
 237         FUSPI_WRITE(sc, FUSPI_REG_CSMODE, csmode);
 238
 239         FUSPI_WRITE(sc, FUSPI_REG_CSID, cs & ~SPIBUS_CS_HIGH);
 240
 241         fmt = FUSPI_FMT_PROTO_SINGLE | FUSPI_FMT_LEN(8);
 242         FUSPI_WRITE(sc, FUSPI_REG_FMT, fmt);
 243
 244         return (0);
 245 }
 246
 247 static int
 248 fuspi_transfer(device_t dev, device_t child, struct spi_command *cmd)
 249 {
 250         struct fuspi_softc *sc;
 251         uint32_t clock, cs, csdef, mode;
 252         int err;
 253
 254         KASSERT(cmd->tx_cmd_sz == cmd->rx_cmd_sz,
 255             ("TX and RX command sizes must be equal"));
 256         KASSERT(cmd->tx_data_sz == cmd->rx_data_sz,
 257             ("TX and RX data sizes must be equal"));
 258
 259         sc = device_get_softc(dev);
 260         spibus_get_cs(child, &cs);
 261         spibus_get_clock(child, &clock);
 262         spibus_get_mode(child, &mode);
 263
 264         if (cs > sc->cs_max) {
 265                 device_printf(sc->dev, "Invalid chip select %u\n", cs);
 266                 return (EINVAL);
 267         }
 268
 269         FUSPI_LOCK(sc);
 270         device_busy(sc->dev);
 271
 272         err = fuspi_setup(sc, cs, mode, clock);
 273         if (err != 0) {
 274                 FUSPI_UNLOCK(sc);
 275                 return (err);
 276         }
 277
 278         err = 0;
 279         if (cmd->tx_cmd_sz > 0)
 280                 err = fuspi_xfer_buf(sc, cmd->rx_cmd, cmd->tx_cmd,
 281                     cmd->tx_cmd_sz, cmd->rx_cmd_sz);
 282         if (cmd->tx_data_sz > 0 && err == 0)
 283                 err = fuspi_xfer_buf(sc, cmd->rx_data, cmd->tx_data,
 284                     cmd->tx_data_sz, cmd->rx_data_sz);
 285
 286         /* Deassert chip select. */
 287         csdef = FUSPI_CSDEF_ALL & ~(1 << cs);
 288         FUSPI_WRITE(sc, FUSPI_REG_CSDEF, csdef);
 289         FUSPI_WRITE(sc, FUSPI_REG_CSDEF, FUSPI_CSDEF_ALL);
 290
 291         device_unbusy(sc->dev);
 292         FUSPI_UNLOCK(sc);
 293
 294         return (err);
 295 }
 296
 297 static int
 298 fuspi_attach(device_t dev)
 299 {
 300         struct fuspi_softc *sc;
 301         int error;
 302
 303         sc = device_get_softc(dev);
 304         sc->dev = dev;
 305
 306         mtx_init(&sc->mtx, device_get_nameunit(sc->dev), NULL, MTX_DEF);
 307
 308         error = bus_alloc_resources(dev, fuspi_spec, &sc->res);
 309         if (error) {
 310                 device_printf(dev, "Couldn't allocate resources\n");
 311                 goto fail;
 312         }
 313         sc->bst = rman_get_bustag(sc->res);
 314         sc->bsh = rman_get_bushandle(sc->res);
 315
 316         error = clk_get_by_ofw_index(dev, 0, 0, &sc->clk);
 317         if (error) {
 318                 device_printf(dev, "Couldn't allocate clock: %d\n", error);
 319                 goto fail;
 320         }
 321         error = clk_enable(sc->clk);
 322         if (error) {
 323                 device_printf(dev, "Couldn't enable clock: %d\n", error);
 324                 goto fail;
 325         }
 326
 327         error = clk_get_freq(sc->clk, &sc->freq);
 328         if (error) {
 329                 device_printf(sc->dev, "Couldn't get frequency: %d\n", error);
 330                 goto fail;
 331         }
 332
 333         /*
 334          * From Sifive-Unleashed-FU540-C000-v1.0.pdf page 103:
 335          * csdef is cs_width bits wide and all ones on reset.
 336          */
 337         sc->cs_max = FUSPI_READ(sc, FUSPI_REG_CSDEF);
 338
 339         /*
 340          * We don't support the direct-mapped flash interface.
 341          * Disable it.
 342          */
 343         FUSPI_WRITE(sc, FUSPI_REG_FCTRL, 0x0);
 344
 345         /* Probe and attach the spibus when interrupts are available. */
 346         sc->parent = device_add_child(dev, "spibus", -1);
 347         config_intrhook_oneshot((ich_func_t)bus_generic_attach, dev);
 348
 349         return (0);
 350
 351 fail:
 352         bus_release_resources(dev, fuspi_spec, &sc->res);
 353         mtx_destroy(&sc->mtx);
 354         return (error);
 355 }
 356
 357 static int
 358 fuspi_probe(device_t dev)
 359 {
 360
 361         if (!ofw_bus_status_okay(dev))
 362                 return (ENXIO);
 363
 364         if (!ofw_bus_is_compatible(dev, "sifive,spi0"))
 365                 return (ENXIO);
 366
 367         device_set_desc(dev, "SiFive FU540 SPI controller");
 368
 369         return (BUS_PROBE_DEFAULT);
 370 }
 371
 372 static phandle_t
 373 fuspi_get_node(device_t bus, device_t dev)
 374 {
 375
 376         return (ofw_bus_get_node(bus));
 377 }
 378
 379 static device_method_t fuspi_methods[] = {
 380         DEVMETHOD(device_probe,         fuspi_probe),
 381         DEVMETHOD(device_attach,        fuspi_attach),
 382
 383         DEVMETHOD(spibus_transfer,      fuspi_transfer),
 384
 385         DEVMETHOD(ofw_bus_get_node,     fuspi_get_node),
 386
 387         DEVMETHOD_END
 388 };
 389
 390 static driver_t fuspi_driver = {
 391         "fu540spi",
 392         fuspi_methods,
 393         sizeof(struct fuspi_softc)
 394 };
 395
 396 static devclass_t fuspi_devclass;
 397
 398 DRIVER_MODULE(fu540spi, simplebus, fuspi_driver, fuspi_devclass, 0, 0);
 399 DRIVER_MODULE(ofw_spibus, fu540spi, ofw_spibus_driver, ofw_spibus_devclass, 0, 0);
 400 MODULE_DEPEND(fu540spi, ofw_spibus, 1, 1, 1);