1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2018 Thomas Skibo <thomasskibo@yahoo.com> 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 /* 33 * This is a driver for the Quad-SPI Flash Controller in the Xilinx 34 * Zynq-7000 SoC. 35 */ 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/conf.h> 40 #include <sys/kernel.h> 41 #include <sys/module.h> 42 #include <sys/sysctl.h> 43 #include <sys/lock.h> 44 #include <sys/mutex.h> 45 #include <sys/resource.h> 46 #include <sys/rman.h> 47 #include <sys/uio.h> 48 49 #include <machine/bus.h> 50 #include <machine/resource.h> 51 #include <machine/stdarg.h> 52 53 #include <dev/fdt/fdt_common.h> 54 #include <dev/ofw/ofw_bus.h> 55 #include <dev/ofw/ofw_bus_subr.h> 56 57 #include <dev/spibus/spi.h> 58 #include <dev/spibus/spibusvar.h> 59 60 #include <dev/flash/mx25lreg.h> 61 62 #include "spibus_if.h" 63 64 static struct ofw_compat_data compat_data[] = { 65 {"xlnx,zy7_qspi", 1}, 66 {"xlnx,zynq-qspi-1.0", 1}, 67 {NULL, 0} 68 }; 69 70 struct zy7_qspi_softc { 71 device_t dev; 72 device_t child; 73 struct mtx sc_mtx; 74 struct resource *mem_res; 75 struct resource *irq_res; 76 void *intrhandle; 77 78 uint32_t cfg_reg_shadow; 79 uint32_t lqspi_cfg_shadow; 80 uint32_t spi_clock; 81 uint32_t ref_clock; 82 unsigned int spi_clk_real_freq; 83 unsigned int rx_overflows; 84 unsigned int tx_underflows; 85 unsigned int interrupts; 86 unsigned int stray_ints; 87 struct spi_command *cmd; 88 int tx_bytes; /* tx_cmd_sz + tx_data_sz */ 89 int tx_bytes_sent; 90 int rx_bytes; /* rx_cmd_sz + rx_data_sz */ 91 int rx_bytes_rcvd; 92 int busy; 93 int is_dual; 94 int is_stacked; 95 int is_dio; 96 }; 97 98 #define ZY7_QSPI_DEFAULT_SPI_CLOCK 50000000 99 100 #define QSPI_SC_LOCK(sc) mtx_lock(&(sc)->sc_mtx) 101 #define QSPI_SC_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx) 102 #define QSPI_SC_LOCK_INIT(sc) \ 103 mtx_init(&(sc)->sc_mtx, device_get_nameunit((sc)->dev), NULL, MTX_DEF) 104 #define QSPI_SC_LOCK_DESTROY(sc) mtx_destroy(&(sc)->sc_mtx) 105 #define QSPI_SC_ASSERT_LOCKED(sc) mtx_assert(&(sc)->sc_mtx, MA_OWNED) 106 107 #define RD4(sc, off) (bus_read_4((sc)->mem_res, (off))) 108 #define WR4(sc, off, val) (bus_write_4((sc)->mem_res, (off), (val))) 109 110 /* 111 * QSPI device registers. 112 * Reference: Zynq-7000 All Programmable SoC Technical Reference Manual. 113 * (v1.12.2) July 1, 2018. Xilinx doc UG585. 114 */ 115 #define ZY7_QSPI_CONFIG_REG 0x0000 116 #define ZY7_QSPI_CONFIG_IFMODE (1U << 31) 117 #define ZY7_QSPI_CONFIG_ENDIAN (1 << 26) 118 #define ZY7_QSPI_CONFIG_HOLDB_DR (1 << 19) 119 #define ZY7_QSPI_CONFIG_RSVD1 (1 << 17) /* must be 1 */ 120 #define ZY7_QSPI_CONFIG_MANSTRT (1 << 16) 121 #define ZY7_QSPI_CONFIG_MANSTRTEN (1 << 15) 122 #define ZY7_QSPI_CONFIG_SSFORCE (1 << 14) 123 #define ZY7_QSPI_CONFIG_PCS (1 << 10) 124 #define ZY7_QSPI_CONFIG_REF_CLK (1 << 8) 125 #define ZY7_QSPI_CONFIG_FIFO_WIDTH_MASK (3 << 6) 126 #define ZY7_QSPI_CONFIG_FIFO_WIDTH32 (3 << 6) 127 #define ZY7_QSPI_CONFIG_BAUD_RATE_DIV_MASK (7 << 3) 128 #define ZY7_QSPI_CONFIG_BAUD_RATE_DIV_SHIFT 3 129 #define ZY7_QSPI_CONFIG_BAUD_RATE_DIV(x) ((x) << 3) /* divide by 2<<x */ 130 #define ZY7_QSPI_CONFIG_CLK_PH (1 << 2) /* clock phase */ 131 #define ZY7_QSPI_CONFIG_CLK_POL (1 << 1) /* clock polarity */ 132 #define ZY7_QSPI_CONFIG_MODE_SEL (1 << 0) /* master enable */ 133 134 #define ZY7_QSPI_INTR_STAT_REG 0x0004 135 #define ZY7_QSPI_INTR_EN_REG 0x0008 136 #define ZY7_QSPI_INTR_DIS_REG 0x000c 137 #define ZY7_QSPI_INTR_MASK_REG 0x0010 138 #define ZY7_QSPI_INTR_TX_FIFO_UNDERFLOW (1 << 6) 139 #define ZY7_QSPI_INTR_RX_FIFO_FULL (1 << 5) 140 #define ZY7_QSPI_INTR_RX_FIFO_NOT_EMPTY (1 << 4) 141 #define ZY7_QSPI_INTR_TX_FIFO_FULL (1 << 3) 142 #define ZY7_QSPI_INTR_TX_FIFO_NOT_FULL (1 << 2) 143 #define ZY7_QSPI_INTR_RX_OVERFLOW (1 << 0) 144 145 #define ZY7_QSPI_EN_REG 0x0014 146 #define ZY7_SPI_ENABLE 1 147 148 #define ZY7_QSPI_DELAY_REG 0x0018 149 #define ZY7_QSPI_DELAY_NSS_MASK (0xffU << 24) 150 #define ZY7_QSPI_DELAY_NSS_SHIFT 24 151 #define ZY7_QSPI_DELAY_NSS(x) ((x) << 24) 152 #define ZY7_QSPI_DELAY_BTWN_MASK (0xff << 16) 153 #define ZY7_QSPI_DELAY_BTWN_SHIFT 16 154 #define ZY7_QSPI_DELAY_BTWN(x) ((x) << 16) 155 #define ZY7_QSPI_DELAY_AFTER_MASK (0xff << 8) 156 #define ZY7_QSPI_DELAY_AFTER_SHIFT 8 157 #define ZY7_QSPI_DELAY_AFTER(x) ((x) << 8) 158 #define ZY7_QSPI_DELAY_INIT_MASK 0xff 159 #define ZY7_QSPI_DELAY_INIT_SHIFT 0 160 #define ZY7_QSPI_DELAY_INIT(x) (x) 161 162 #define ZY7_QSPI_TXD0_REG 0x001c 163 #define ZY7_QSPI_RX_DATA_REG 0x0020 164 165 #define ZY7_QSPI_SLV_IDLE_CT_REG 0x0024 166 #define ZY7_QSPI_SLV_IDLE_CT_MASK 0xff 167 168 #define ZY7_QSPI_TX_THRESH_REG 0x0028 169 #define ZY7_QSPI_RX_THRESH_REG 0x002c 170 171 #define ZY7_QSPI_GPIO_REG 0x0030 172 #define ZY7_QSPI_GPIO_WP_N 1 173 174 #define ZY7_QSPI_LPBK_DLY_ADJ_REG 0x0038 175 #define ZY7_QSPI_LPBK_DLY_ADJ_LPBK_SEL (1 << 8) 176 #define ZY7_QSPI_LPBK_DLY_ADJ_LPBK_PH (1 << 7) 177 #define ZY7_QSPI_LPBK_DLY_ADJ_USE_LPBK (1 << 5) 178 #define ZY7_QSPI_LPBK_DLY_ADJ_DLY1_MASK (3 << 3) 179 #define ZY7_QSPI_LPBK_DLY_ADJ_DLY1_SHIFT 3 180 #define ZY7_QSPI_LPBK_DLY_ADJ_DLY1(x) ((x) << 3) 181 #define ZY7_QSPI_LPBK_DLY_ADJ_DLY0_MASK 7 182 #define ZY7_QSPI_LPBK_DLY_ADJ_DLY0_SHIFT 0 183 #define ZY7_QSPI_LPBK_DLY_ADJ_DLY0(x) (x) 184 185 #define ZY7_QSPI_TXD1_REG 0x0080 186 #define ZY7_QSPI_TXD2_REG 0x0084 187 #define ZY7_QSPI_TXD3_REG 0x0088 188 189 #define ZY7_QSPI_LQSPI_CFG_REG 0x00a0 190 #define ZY7_QSPI_LQSPI_CFG_LINEAR (1U << 31) 191 #define ZY7_QSPI_LQSPI_CFG_TWO_MEM (1 << 30) 192 #define ZY7_QSPI_LQSPI_CFG_SEP_BUS (1 << 29) 193 #define ZY7_QSPI_LQSPI_CFG_U_PAGE (1 << 28) 194 #define ZY7_QSPI_LQSPI_CFG_MODE_EN (1 << 25) 195 #define ZY7_QSPI_LQSPI_CFG_MODE_ON (1 << 24) 196 #define ZY7_QSPI_LQSPI_CFG_MODE_BITS_MASK (0xff << 16) 197 #define ZY7_QSPI_LQSPI_CFG_MODE_BITS_SHIFT 16 198 #define ZY7_QSPI_LQSPI_CFG_MODE_BITS(x) ((x) << 16) 199 #define ZY7_QSPI_LQSPI_CFG_DUMMY_BYTES_MASK (7 << 8) 200 #define ZY7_QSPI_LQSPI_CFG_DUMMY_BYTES_SHIFT 8 201 #define ZY7_QSPI_LQSPI_CFG_DUMMY_BYTES(x) ((x) << 8) 202 #define ZY7_QSPI_LQSPI_CFG_INST_CODE_MASK 0xff 203 #define ZY7_QSPI_LQSPI_CFG_INST_CODE_SHIFT 0 204 #define ZY7_QSPI_LQSPI_CFG_INST_CODE(x) (x) 205 206 #define ZY7_QSPI_LQSPI_STS_REG 0x00a4 207 #define ZY7_QSPI_LQSPI_STS_D_FSM_ERR (1 << 2) 208 #define ZY7_QSPI_LQSPI_STS_WR_RECVD (1 << 1) 209 210 #define ZY7_QSPI_MOD_ID_REG 0x00fc 211 212 static int zy7_qspi_detach(device_t); 213 214 /* Fill hardware fifo with command and data bytes. */ 215 static void 216 zy7_qspi_write_fifo(struct zy7_qspi_softc *sc, int nbytes) 217 { 218 int n, nvalid; 219 uint32_t data; 220 221 while (nbytes > 0) { 222 nvalid = MIN(4, nbytes); 223 data = 0xffffffff; 224 225 /* 226 * A hardware bug forces us to wait until the tx fifo is 227 * empty before writing partial words. We'll come back 228 * next tx interrupt. 229 */ 230 if (nvalid < 4 && (RD4(sc, ZY7_QSPI_INTR_STAT_REG) & 231 ZY7_QSPI_INTR_TX_FIFO_NOT_FULL) == 0) 232 return; 233 234 if (sc->tx_bytes_sent < sc->cmd->tx_cmd_sz) { 235 /* Writing command. */ 236 n = MIN(nvalid, sc->cmd->tx_cmd_sz - 237 sc->tx_bytes_sent); 238 memcpy(&data, (uint8_t *)sc->cmd->tx_cmd + 239 sc->tx_bytes_sent, n); 240 241 if (nvalid > n) { 242 /* Writing start of data. */ 243 memcpy((uint8_t *)&data + n, 244 sc->cmd->tx_data, nvalid - n); 245 } 246 } else 247 /* Writing data. */ 248 memcpy(&data, (uint8_t *)sc->cmd->tx_data + 249 (sc->tx_bytes_sent - sc->cmd->tx_cmd_sz), nvalid); 250 251 switch (nvalid) { 252 case 1: 253 WR4(sc, ZY7_QSPI_TXD1_REG, data); 254 break; 255 case 2: 256 WR4(sc, ZY7_QSPI_TXD2_REG, data); 257 break; 258 case 3: 259 WR4(sc, ZY7_QSPI_TXD3_REG, data); 260 break; 261 case 4: 262 WR4(sc, ZY7_QSPI_TXD0_REG, data); 263 break; 264 } 265 266 sc->tx_bytes_sent += nvalid; 267 nbytes -= nvalid; 268 } 269 } 270 271 272 /* Read hardware fifo data into command response and data buffers. */ 273 static void 274 zy7_qspi_read_fifo(struct zy7_qspi_softc *sc) 275 { 276 int n, nbytes; 277 uint32_t data; 278 279 do { 280 data = RD4(sc, ZY7_QSPI_RX_DATA_REG); 281 nbytes = MIN(4, sc->rx_bytes - sc->rx_bytes_rcvd); 282 283 /* 284 * Last word in non-word-multiple transfer is packed 285 * non-intuitively. 286 */ 287 if (nbytes < 4) 288 data >>= 8 * (4 - nbytes); 289 290 if (sc->rx_bytes_rcvd < sc->cmd->rx_cmd_sz) { 291 /* Reading command. */ 292 n = MIN(nbytes, sc->cmd->rx_cmd_sz - 293 sc->rx_bytes_rcvd); 294 memcpy((uint8_t *)sc->cmd->rx_cmd + sc->rx_bytes_rcvd, 295 &data, n); 296 sc->rx_bytes_rcvd += n; 297 nbytes -= n; 298 data >>= 8 * n; 299 } 300 301 if (nbytes > 0) { 302 /* Reading data. */ 303 memcpy((uint8_t *)sc->cmd->rx_data + 304 (sc->rx_bytes_rcvd - sc->cmd->rx_cmd_sz), 305 &data, nbytes); 306 sc->rx_bytes_rcvd += nbytes; 307 } 308 309 } while (sc->rx_bytes_rcvd < sc->rx_bytes && 310 (RD4(sc, ZY7_QSPI_INTR_STAT_REG) & 311 ZY7_QSPI_INTR_RX_FIFO_NOT_EMPTY) != 0); 312 } 313 314 /* End a transfer early by draining rx fifo and disabling interrupts. */ 315 static void 316 zy7_qspi_abort_transfer(struct zy7_qspi_softc *sc) 317 { 318 /* Drain receive fifo. */ 319 while ((RD4(sc, ZY7_QSPI_INTR_STAT_REG) & 320 ZY7_QSPI_INTR_RX_FIFO_NOT_EMPTY) != 0) 321 (void)RD4(sc, ZY7_QSPI_RX_DATA_REG); 322 323 /* Shut down interrupts. */ 324 WR4(sc, ZY7_QSPI_INTR_DIS_REG, 325 ZY7_QSPI_INTR_RX_OVERFLOW | 326 ZY7_QSPI_INTR_RX_FIFO_NOT_EMPTY | 327 ZY7_QSPI_INTR_TX_FIFO_NOT_FULL); 328 } 329 330 331 static void 332 zy7_qspi_intr(void *arg) 333 { 334 struct zy7_qspi_softc *sc = (struct zy7_qspi_softc *)arg; 335 uint32_t istatus; 336 337 QSPI_SC_LOCK(sc); 338 339 sc->interrupts++; 340 341 istatus = RD4(sc, ZY7_QSPI_INTR_STAT_REG); 342 343 /* Stray interrupts can happen if a transfer gets interrupted. */ 344 if (!sc->busy) { 345 sc->stray_ints++; 346 QSPI_SC_UNLOCK(sc); 347 return; 348 } 349 350 if ((istatus & ZY7_QSPI_INTR_RX_OVERFLOW) != 0) { 351 device_printf(sc->dev, "rx fifo overflow!\n"); 352 sc->rx_overflows++; 353 354 /* Clear status bit. */ 355 WR4(sc, ZY7_QSPI_INTR_STAT_REG, 356 ZY7_QSPI_INTR_RX_OVERFLOW); 357 } 358 359 /* Empty receive fifo before any more transmit data is sent. */ 360 if (sc->rx_bytes_rcvd < sc->rx_bytes && 361 (istatus & ZY7_QSPI_INTR_RX_FIFO_NOT_EMPTY) != 0) { 362 zy7_qspi_read_fifo(sc); 363 if (sc->rx_bytes_rcvd == sc->rx_bytes) 364 /* Disable receive interrupts. */ 365 WR4(sc, ZY7_QSPI_INTR_DIS_REG, 366 ZY7_QSPI_INTR_RX_FIFO_NOT_EMPTY | 367 ZY7_QSPI_INTR_RX_OVERFLOW); 368 } 369 370 /* 371 * Transmit underflows aren't really a bug because a hardware 372 * bug forces us to allow the tx fifo to go empty between full 373 * and partial fifo writes. Why bother counting? 374 */ 375 if ((istatus & ZY7_QSPI_INTR_TX_FIFO_UNDERFLOW) != 0) { 376 sc->tx_underflows++; 377 378 /* Clear status bit. */ 379 WR4(sc, ZY7_QSPI_INTR_STAT_REG, 380 ZY7_QSPI_INTR_TX_FIFO_UNDERFLOW); 381 } 382 383 /* Fill transmit fifo. */ 384 if (sc->tx_bytes_sent < sc->tx_bytes && 385 (istatus & ZY7_QSPI_INTR_TX_FIFO_NOT_FULL) != 0) { 386 zy7_qspi_write_fifo(sc, MIN(240, sc->tx_bytes - 387 sc->tx_bytes_sent)); 388 389 if (sc->tx_bytes_sent == sc->tx_bytes) { 390 /* 391 * Disable transmit FIFO interrupt, enable receive 392 * FIFO interrupt. 393 */ 394 WR4(sc, ZY7_QSPI_INTR_DIS_REG, 395 ZY7_QSPI_INTR_TX_FIFO_NOT_FULL); 396 WR4(sc, ZY7_QSPI_INTR_EN_REG, 397 ZY7_QSPI_INTR_RX_FIFO_NOT_EMPTY); 398 } 399 } 400 401 /* Finished with transfer? */ 402 if (sc->tx_bytes_sent == sc->tx_bytes && 403 sc->rx_bytes_rcvd == sc->rx_bytes) { 404 405 /* De-assert CS. */ 406 sc->cfg_reg_shadow |= ZY7_QSPI_CONFIG_PCS; 407 WR4(sc, ZY7_QSPI_CONFIG_REG, sc->cfg_reg_shadow); 408 409 wakeup(sc->dev); 410 } 411 412 QSPI_SC_UNLOCK(sc); 413 } 414 415 /* Initialize hardware. */ 416 static int 417 zy7_qspi_init_hw(struct zy7_qspi_softc *sc) 418 { 419 uint32_t baud_div; 420 421 /* Configure LQSPI Config register. Disable linear mode. */ 422 sc->lqspi_cfg_shadow = RD4(sc, ZY7_QSPI_LQSPI_CFG_REG); 423 sc->lqspi_cfg_shadow &= ~(ZY7_QSPI_LQSPI_CFG_LINEAR | 424 ZY7_QSPI_LQSPI_CFG_TWO_MEM | 425 ZY7_QSPI_LQSPI_CFG_SEP_BUS); 426 if (sc->is_dual) { 427 sc->lqspi_cfg_shadow |= ZY7_QSPI_LQSPI_CFG_TWO_MEM; 428 if (sc->is_stacked) { 429 sc->lqspi_cfg_shadow &= 430 ~ZY7_QSPI_LQSPI_CFG_INST_CODE_MASK; 431 sc->lqspi_cfg_shadow |= 432 ZY7_QSPI_LQSPI_CFG_INST_CODE(sc->is_dio ? 433 CMD_READ_DUAL_IO : CMD_READ_QUAD_OUTPUT); 434 } else 435 sc->lqspi_cfg_shadow |= ZY7_QSPI_LQSPI_CFG_SEP_BUS; 436 } 437 WR4(sc, ZY7_QSPI_LQSPI_CFG_REG, sc->lqspi_cfg_shadow); 438 439 /* Find best clock divider. */ 440 baud_div = 0; 441 while ((sc->ref_clock >> (baud_div + 1)) > sc->spi_clock && 442 baud_div < 8) 443 baud_div++; 444 if (baud_div >= 8) { 445 device_printf(sc->dev, "cannot configure clock divider: ref=%d" 446 " spi=%d.\n", sc->ref_clock, sc->spi_clock); 447 return (EINVAL); 448 } 449 sc->spi_clk_real_freq = sc->ref_clock >> (baud_div + 1); 450 451 /* 452 * If divider is 2 (the max speed), use internal loopback master 453 * clock for read data. (See section 12.3.1 in ref man.) 454 */ 455 if (baud_div == 0) 456 WR4(sc, ZY7_QSPI_LPBK_DLY_ADJ_REG, 457 ZY7_QSPI_LPBK_DLY_ADJ_USE_LPBK | 458 ZY7_QSPI_LPBK_DLY_ADJ_DLY1(0) | 459 ZY7_QSPI_LPBK_DLY_ADJ_DLY0(0)); 460 else 461 WR4(sc, ZY7_QSPI_LPBK_DLY_ADJ_REG, 0); 462 463 /* Set up configuration register. */ 464 sc->cfg_reg_shadow = 465 ZY7_QSPI_CONFIG_IFMODE | 466 ZY7_QSPI_CONFIG_HOLDB_DR | 467 ZY7_QSPI_CONFIG_RSVD1 | 468 ZY7_QSPI_CONFIG_SSFORCE | 469 ZY7_QSPI_CONFIG_PCS | 470 ZY7_QSPI_CONFIG_FIFO_WIDTH32 | 471 ZY7_QSPI_CONFIG_BAUD_RATE_DIV(baud_div) | 472 ZY7_QSPI_CONFIG_MODE_SEL; 473 WR4(sc, ZY7_QSPI_CONFIG_REG, sc->cfg_reg_shadow); 474 475 /* 476 * Set thresholds. We must use 1 for tx threshold because there 477 * is no fifo empty flag and we need one to implement a bug 478 * workaround. 479 */ 480 WR4(sc, ZY7_QSPI_TX_THRESH_REG, 1); 481 WR4(sc, ZY7_QSPI_RX_THRESH_REG, 1); 482 483 /* Clear and disable all interrupts. */ 484 WR4(sc, ZY7_QSPI_INTR_STAT_REG, ~0); 485 WR4(sc, ZY7_QSPI_INTR_DIS_REG, ~0); 486 487 /* Enable SPI. */ 488 WR4(sc, ZY7_QSPI_EN_REG, ZY7_SPI_ENABLE); 489 490 return (0); 491 } 492 493 494 static void 495 zy7_qspi_add_sysctls(device_t dev) 496 { 497 struct zy7_qspi_softc *sc = device_get_softc(dev); 498 struct sysctl_ctx_list *ctx; 499 struct sysctl_oid_list *child; 500 501 ctx = device_get_sysctl_ctx(dev); 502 child = SYSCTL_CHILDREN(device_get_sysctl_tree(dev)); 503 504 SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "spi_clk_real_freq", CTLFLAG_RD, 505 &sc->spi_clk_real_freq, 0, "SPI clock real frequency"); 506 507 SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "rx_overflows", CTLFLAG_RD, 508 &sc->rx_overflows, 0, "RX FIFO overflow events"); 509 510 SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_underflows", CTLFLAG_RD, 511 &sc->tx_underflows, 0, "TX FIFO underflow events"); 512 513 SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "interrupts", CTLFLAG_RD, 514 &sc->interrupts, 0, "interrupt calls"); 515 516 SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "stray_ints", CTLFLAG_RD, 517 &sc->stray_ints, 0, "stray interrupts"); 518 } 519 520 521 static int 522 zy7_qspi_probe(device_t dev) 523 { 524 525 if (!ofw_bus_status_okay(dev)) 526 return (ENXIO); 527 528 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0) 529 return (ENXIO); 530 531 device_set_desc(dev, "Zynq Quad-SPI Flash Controller"); 532 533 return (BUS_PROBE_DEFAULT); 534 } 535 536 537 static int 538 zy7_qspi_attach(device_t dev) 539 { 540 struct zy7_qspi_softc *sc; 541 int rid, err; 542 phandle_t node; 543 pcell_t cell; 544 545 sc = device_get_softc(dev); 546 sc->dev = dev; 547 548 QSPI_SC_LOCK_INIT(sc); 549 550 /* Get ref-clock, spi-clock, and other properties. */ 551 node = ofw_bus_get_node(dev); 552 if (OF_getprop(node, "ref-clock", &cell, sizeof(cell)) > 0) 553 sc->ref_clock = fdt32_to_cpu(cell); 554 else { 555 device_printf(dev, "must have ref-clock property\n"); 556 return (ENXIO); 557 } 558 if (OF_getprop(node, "spi-clock", &cell, sizeof(cell)) > 0) 559 sc->spi_clock = fdt32_to_cpu(cell); 560 else 561 sc->spi_clock = ZY7_QSPI_DEFAULT_SPI_CLOCK; 562 if (OF_getprop(node, "is-stacked", &cell, sizeof(cell)) > 0 && 563 fdt32_to_cpu(cell) != 0) { 564 sc->is_dual = 1; 565 sc->is_stacked = 1; 566 } else if (OF_getprop(node, "is-dual", &cell, sizeof(cell)) > 0 && 567 fdt32_to_cpu(cell) != 0) 568 sc->is_dual = 1; 569 if (OF_getprop(node, "is-dio", &cell, sizeof(cell)) > 0 && 570 fdt32_to_cpu(cell) != 0) 571 sc->is_dio = 1; 572 573 /* Get memory resource. */ 574 rid = 0; 575 sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 576 RF_ACTIVE); 577 if (sc->mem_res == NULL) { 578 device_printf(dev, "could not allocate memory resources.\n"); 579 zy7_qspi_detach(dev); 580 return (ENOMEM); 581 } 582 583 /* Allocate IRQ. */ 584 rid = 0; 585 sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 586 RF_ACTIVE); 587 if (sc->irq_res == NULL) { 588 device_printf(dev, "could not allocate IRQ resource.\n"); 589 zy7_qspi_detach(dev); 590 return (ENOMEM); 591 } 592 593 /* Activate the interrupt. */ 594 err = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC | INTR_MPSAFE, 595 NULL, zy7_qspi_intr, sc, &sc->intrhandle); 596 if (err) { 597 device_printf(dev, "could not setup IRQ.\n"); 598 zy7_qspi_detach(dev); 599 return (err); 600 } 601 602 /* Configure the device. */ 603 err = zy7_qspi_init_hw(sc); 604 if (err) { 605 zy7_qspi_detach(dev); 606 return (err); 607 } 608 609 sc->child = device_add_child(dev, "spibus", -1); 610 611 zy7_qspi_add_sysctls(dev); 612 613 /* Attach spibus driver as a child later when interrupts work. */ 614 config_intrhook_oneshot((ich_func_t)bus_generic_attach, dev); 615 616 return (0); 617 } 618 619 static int 620 zy7_qspi_detach(device_t dev) 621 { 622 struct zy7_qspi_softc *sc = device_get_softc(dev); 623 624 if (device_is_attached(dev)) 625 bus_generic_detach(dev); 626 627 /* Delete child bus. */ 628 if (sc->child) 629 device_delete_child(dev, sc->child); 630 631 /* Disable hardware. */ 632 if (sc->mem_res != NULL) { 633 /* Disable SPI. */ 634 WR4(sc, ZY7_QSPI_EN_REG, 0); 635 636 /* Clear and disable all interrupts. */ 637 WR4(sc, ZY7_QSPI_INTR_STAT_REG, ~0); 638 WR4(sc, ZY7_QSPI_INTR_DIS_REG, ~0); 639 } 640 641 /* Teardown and release interrupt. */ 642 if (sc->irq_res != NULL) { 643 if (sc->intrhandle) 644 bus_teardown_intr(dev, sc->irq_res, sc->intrhandle); 645 bus_release_resource(dev, SYS_RES_IRQ, 646 rman_get_rid(sc->irq_res), sc->irq_res); 647 } 648 649 /* Release memory resource. */ 650 if (sc->mem_res != NULL) 651 bus_release_resource(dev, SYS_RES_MEMORY, 652 rman_get_rid(sc->mem_res), sc->mem_res); 653 654 QSPI_SC_LOCK_DESTROY(sc); 655 656 return (0); 657 } 658 659 660 static phandle_t 661 zy7_qspi_get_node(device_t bus, device_t dev) 662 { 663 664 return (ofw_bus_get_node(bus)); 665 } 666 667 668 static int 669 zy7_qspi_transfer(device_t dev, device_t child, struct spi_command *cmd) 670 { 671 struct zy7_qspi_softc *sc = device_get_softc(dev); 672 int err = 0; 673 674 KASSERT(cmd->tx_cmd_sz == cmd->rx_cmd_sz, 675 ("TX/RX command sizes should be equal")); 676 KASSERT(cmd->tx_data_sz == cmd->rx_data_sz, 677 ("TX/RX data sizes should be equal")); 678 679 if (sc->is_dual && cmd->tx_data_sz % 2 != 0) { 680 device_printf(dev, "driver does not support odd byte data " 681 "transfers in dual mode. (sz=%d)\n", cmd->tx_data_sz); 682 return (EINVAL); 683 } 684 685 QSPI_SC_LOCK(sc); 686 687 /* Wait for controller available. */ 688 while (sc->busy != 0) { 689 err = mtx_sleep(dev, &sc->sc_mtx, 0, "zqspi0", 0); 690 if (err) { 691 QSPI_SC_UNLOCK(sc); 692 return (err); 693 } 694 } 695 696 /* Start transfer. */ 697 sc->busy = 1; 698 sc->cmd = cmd; 699 sc->tx_bytes = sc->cmd->tx_cmd_sz + sc->cmd->tx_data_sz; 700 sc->tx_bytes_sent = 0; 701 sc->rx_bytes = sc->cmd->rx_cmd_sz + sc->cmd->rx_data_sz; 702 sc->rx_bytes_rcvd = 0; 703 704 /* Enable interrupts. zy7_qspi_intr() will handle transfer. */ 705 WR4(sc, ZY7_QSPI_INTR_EN_REG, 706 ZY7_QSPI_INTR_TX_FIFO_NOT_FULL | 707 ZY7_QSPI_INTR_RX_OVERFLOW); 708 709 #ifdef SPI_XFER_U_PAGE /* XXX: future support for stacked memories. */ 710 if (sc->is_stacked) { 711 if ((cmd->flags & SPI_XFER_U_PAGE) != 0) 712 sc->lqspi_cfg_shadow |= ZY7_QSPI_LQSPI_CFG_U_PAGE; 713 else 714 sc->lqspi_cfg_shadow &= ~ZY7_QSPI_LQSPI_CFG_U_PAGE; 715 WR4(sc, ZY7_QSPI_LQSPI_CFG_REG, sc->lqspi_cfg_shadow); 716 } 717 #endif 718 719 /* Assert CS. */ 720 sc->cfg_reg_shadow &= ~ZY7_QSPI_CONFIG_PCS; 721 WR4(sc, ZY7_QSPI_CONFIG_REG, sc->cfg_reg_shadow); 722 723 /* Wait for completion. */ 724 err = mtx_sleep(dev, &sc->sc_mtx, 0, "zqspi1", hz * 2); 725 if (err) 726 zy7_qspi_abort_transfer(sc); 727 728 /* Release controller. */ 729 sc->busy = 0; 730 wakeup_one(dev); 731 732 QSPI_SC_UNLOCK(sc); 733 734 return (err); 735 } 736 737 static device_method_t zy7_qspi_methods[] = { 738 /* Device interface */ 739 DEVMETHOD(device_probe, zy7_qspi_probe), 740 DEVMETHOD(device_attach, zy7_qspi_attach), 741 DEVMETHOD(device_detach, zy7_qspi_detach), 742 743 /* SPI interface */ 744 DEVMETHOD(spibus_transfer, zy7_qspi_transfer), 745 746 /* ofw_bus interface */ 747 DEVMETHOD(ofw_bus_get_node, zy7_qspi_get_node), 748 749 DEVMETHOD_END 750 }; 751 752 753 static driver_t zy7_qspi_driver = { 754 "zy7_qspi", 755 zy7_qspi_methods, 756 sizeof(struct zy7_qspi_softc), 757 }; 758 static devclass_t zy7_qspi_devclass; 759 760 DRIVER_MODULE(zy7_qspi, simplebus, zy7_qspi_driver, zy7_qspi_devclass, 0, 0); 761 DRIVER_MODULE(ofw_spibus, zy7_qspi, ofw_spibus_driver, ofw_spibus_devclass, 0, 0); 762 SIMPLEBUS_PNP_INFO(compat_data); 763 MODULE_DEPEND(zy7_qspi, ofw_spibus, 1, 1, 1); 764