sys/arm/xilinx/zy7_devcfg.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2013 Thomas Skibo
   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  * $FreeBSD$
  29  */
  30
  31 /*
  32  * Zynq-7000 Devcfg driver.  This allows programming the PL (FPGA) section
  33  * of Zynq.
  34  *
  35  * Reference: Zynq-7000 All Programmable SoC Technical Reference Manual.
  36  * (v1.4) November 16, 2012.  Xilinx doc UG585.  PL Configuration is
  37  * covered in section 6.4.5.
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD$");
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/conf.h>
  46 #include <sys/kernel.h>
  47 #include <sys/module.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/lock.h>
  50 #include <sys/mutex.h>
  51 #include <sys/resource.h>
  52 #include <sys/rman.h>
  53 #include <sys/uio.h>
  54
  55 #include <machine/bus.h>
  56 #include <machine/resource.h>
  57 #include <machine/stdarg.h>
  58
  59 #include <dev/ofw/ofw_bus.h>
  60 #include <dev/ofw/ofw_bus_subr.h>
  61
  62 #include <arm/xilinx/zy7_slcr.h>
  63
  64 struct zy7_devcfg_softc {
  65         device_t        dev;
  66         struct mtx      sc_mtx;
  67         struct resource *mem_res;
  68         struct resource *irq_res;
  69         struct cdev     *sc_ctl_dev;
  70         void            *intrhandle;
  71
  72         bus_dma_tag_t   dma_tag;
  73         bus_dmamap_t    dma_map;
  74
  75         int             is_open;
  76
  77         struct sysctl_ctx_list sysctl_tree;
  78         struct sysctl_oid *sysctl_tree_top;
  79 };
  80
  81 static struct zy7_devcfg_softc *zy7_devcfg_softc_p;
  82
  83 #define FCLK_NUM        4
  84
  85 struct zy7_fclk_config {
  86         int             source;
  87         int             frequency;
  88         int             actual_frequency;
  89 };
  90
  91 static struct zy7_fclk_config fclk_configs[FCLK_NUM];
  92
  93 #define DEVCFG_SC_LOCK(sc)              mtx_lock(&(sc)->sc_mtx)
  94 #define DEVCFG_SC_UNLOCK(sc)            mtx_unlock(&(sc)->sc_mtx)
  95 #define DEVCFG_SC_LOCK_INIT(sc) \
  96         mtx_init(&(sc)->sc_mtx, device_get_nameunit((sc)->dev), \
  97             "zy7_devcfg", MTX_DEF)
  98 #define DEVCFG_SC_LOCK_DESTROY(sc)      mtx_destroy(&(sc)->sc_mtx);
  99 #define DEVCFG_SC_ASSERT_LOCKED(sc)     mtx_assert(&(sc)->sc_mtx, MA_OWNED);
 100
 101 #define RD4(sc, off)            (bus_read_4((sc)->mem_res, (off)))
 102 #define WR4(sc, off, val)       (bus_write_4((sc)->mem_res, (off), (val)))
 103
 104 SYSCTL_NODE(_hw, OID_AUTO, fpga, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
 105     "Xilinx Zynq-7000 PL (FPGA) section");
 106
 107 static int zy7_devcfg_sysctl_pl_done(SYSCTL_HANDLER_ARGS);
 108 SYSCTL_PROC(_hw_fpga, OID_AUTO, pl_done,
 109     CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, NULL, 0,
 110     zy7_devcfg_sysctl_pl_done, "I",
 111     "PL section config DONE signal");
 112
 113 static int zy7_en_level_shifters = 1;
 114 SYSCTL_INT(_hw_fpga, OID_AUTO, en_level_shifters, CTLFLAG_RW,
 115            &zy7_en_level_shifters, 0,
 116            "Enable PS-PL level shifters after device config");
 117
 118 static int zy7_ps_vers = 0;
 119 SYSCTL_INT(_hw, OID_AUTO, ps_vers, CTLFLAG_RD, &zy7_ps_vers, 0,
 120            "Zynq-7000 PS version");
 121
 122 static int zy7_devcfg_fclk_sysctl_level_shifters(SYSCTL_HANDLER_ARGS);
 123 SYSCTL_PROC(_hw_fpga, OID_AUTO, level_shifters,
 124     CTLFLAG_RW | CTLTYPE_INT | CTLFLAG_NEEDGIANT, NULL, 0,
 125     zy7_devcfg_fclk_sysctl_level_shifters, "I",
 126     "Enable/disable level shifters");
 127
 128 /* cdev entry points. */
 129 static int zy7_devcfg_open(struct cdev *, int, int, struct thread *);
 130 static int zy7_devcfg_write(struct cdev *, struct uio *, int);
 131 static int zy7_devcfg_close(struct cdev *, int, int, struct thread *);
 132
 133 struct cdevsw zy7_devcfg_cdevsw = {
 134         .d_version =    D_VERSION,
 135         .d_open =       zy7_devcfg_open,
 136         .d_write =      zy7_devcfg_write,
 137         .d_close =      zy7_devcfg_close,
 138         .d_name =       "devcfg",
 139 };
 140
 141 /* Devcfg block registers. */
 142 #define ZY7_DEVCFG_CTRL                 0x0000
 143 #define   ZY7_DEVCFG_CTRL_FORCE_RST             (1<<31)
 144 #define   ZY7_DEVCFG_CTRL_PCFG_PROG_B           (1<<30)
 145 #define   ZY7_DEVCFG_CTRL_PCFG_POR_CNT_4K       (1<<29)
 146 #define   ZY7_DEVCFG_CTRL_PCAP_PR               (1<<27)
 147 #define   ZY7_DEVCFG_CTRL_PCAP_MODE             (1<<26)
 148 #define   ZY7_DEVCFG_CTRL_QTR_PCAP_RATE_EN      (1<<25)
 149 #define   ZY7_DEVCFG_CTRL_MULTIBOOT_EN          (1<<24)
 150 #define   ZY7_DEVCFG_CTRL_JTAG_CHAIN_DIS        (1<<23)
 151 #define   ZY7_DEVCFG_CTRL_USER_MODE             (1<<15)
 152 #define   ZY7_DEVCFG_CTRL_RESVD_WR11            (3<<13) /* always write 11 */
 153 #define   ZY7_DEVCFG_CTRL_PCFG_AES_FUSE         (1<<12)
 154 #define   ZY7_DEVCFG_CTRL_PCFG_AES_EN_MASK      (7<<9)  /* all 1's or 0's */
 155 #define   ZY7_DEVCFG_CTRL_SEU_EN                (1<<8)
 156 #define   ZY7_DEVCFG_CTRL_SEC_EN                (1<<7)
 157 #define   ZY7_DEVCFG_CTRL_SPNIDEN               (1<<6)
 158 #define   ZY7_DEVCFG_CTRL_SPIDEN                (1<<5)
 159 #define   ZY7_DEVCFG_CTRL_NIDEN                 (1<<4)
 160 #define   ZY7_DEVCFG_CTRL_DBGEN                 (1<<3)
 161 #define   ZY7_DEVCFG_CTRL_DAP_EN_MASK           (7<<0)  /* all 1's to enable */
 162
 163 #define ZY7_DEVCFG_LOCK                 0x004
 164 #define   ZY7_DEVCFG_LOCK_AES_FUSE_LOCK         (1<<4)
 165 #define   ZY7_DEVCFG_LOCK_AES_EN                (1<<3)
 166 #define   ZY7_DEVCFG_LOCK_SEU_LOCK              (1<<2)
 167 #define   ZY7_DEVCFG_LOCK_SEC_LOCK              (1<<1)
 168 #define   ZY7_DEVCFG_LOCK_DBG_LOCK              (1<<0)
 169
 170 #define ZY7_DEVCFG_CFG                  0x008
 171 #define   ZY7_DEVCFG_CFG_RFIFO_TH_MASK          (3<<10)
 172 #define   ZY7_DEVCFG_CFG_WFIFO_TH_MASK          (3<<8)
 173 #define   ZY7_DEVCFG_CFG_RCLK_EDGE              (1<<7)
 174 #define   ZY7_DEVCFG_CFG_WCLK_EDGE              (1<<6)
 175 #define   ZY7_DEVCFG_CFG_DIS_SRC_INC            (1<<5)
 176 #define   ZY7_DEVCFG_CFG_DIS_DST_INC            (1<<4)
 177
 178 #define ZY7_DEVCFG_INT_STATUS           0x00C
 179 #define ZY7_DEVCFG_INT_MASK             0x010
 180 #define   ZY7_DEVCFG_INT_PSS_GTS_USR_B          (1<<31)
 181 #define   ZY7_DEVCFG_INT_PSS_FST_CFG_B          (1<<30)
 182 #define   ZY7_DEVCFG_INT_PSS_GPWRDWN_B          (1<<29)
 183 #define   ZY7_DEVCFG_INT_PSS_GTS_CFG_B          (1<<28)
 184 #define   ZY7_DEVCFG_INT_CFG_RESET_B            (1<<27)
 185 #define   ZY7_DEVCFG_INT_AXI_WTO                (1<<23) /* axi write timeout */
 186 #define   ZY7_DEVCFG_INT_AXI_WERR               (1<<22) /* axi write err */
 187 #define   ZY7_DEVCFG_INT_AXI_RTO                (1<<21) /* axi read timeout */
 188 #define   ZY7_DEVCFG_INT_AXI_RERR               (1<<20) /* axi read err */
 189 #define   ZY7_DEVCFG_INT_RX_FIFO_OV             (1<<18) /* rx fifo overflow */
 190 #define   ZY7_DEVCFG_INT_WR_FIFO_LVL            (1<<17) /* wr fifo < level */
 191 #define   ZY7_DEVCFG_INT_RD_FIFO_LVL            (1<<16) /* rd fifo >= level */
 192 #define   ZY7_DEVCFG_INT_DMA_CMD_ERR            (1<<15)
 193 #define   ZY7_DEVCFG_INT_DMA_Q_OV               (1<<14)
 194 #define   ZY7_DEVCFG_INT_DMA_DONE               (1<<13)
 195 #define   ZY7_DEVCFG_INT_DMA_PCAP_DONE          (1<<12)
 196 #define   ZY7_DEVCFG_INT_P2D_LEN_ERR            (1<<11)
 197 #define   ZY7_DEVCFG_INT_PCFG_HMAC_ERR          (1<<6)
 198 #define   ZY7_DEVCFG_INT_PCFG_SEU_ERR           (1<<5)
 199 #define   ZY7_DEVCFG_INT_PCFG_POR_B             (1<<4)
 200 #define   ZY7_DEVCFG_INT_PCFG_CFG_RST           (1<<3)
 201 #define   ZY7_DEVCFG_INT_PCFG_DONE              (1<<2)
 202 #define   ZY7_DEVCFG_INT_PCFG_INIT_PE           (1<<1)
 203 #define   ZY7_DEVCFG_INT_PCFG_INIT_NE           (1<<0)
 204 #define   ZY7_DEVCFG_INT_ERRORS                 0x00f0f860
 205 #define   ZY7_DEVCFG_INT_ALL                    0xf8f7f87f
 206
 207 #define ZY7_DEVCFG_STATUS               0x014
 208 #define   ZY7_DEVCFG_STATUS_DMA_CMD_Q_F         (1<<31) /* cmd queue full */
 209 #define   ZY7_DEVCFG_STATUS_DMA_CMD_Q_E         (1<<30) /* cmd queue empty */
 210 #define   ZY7_DEVCFG_STATUS_DONE_COUNT_MASK     (3<<28)
 211 #define   ZY7_DEVCFG_STATUS_DONE_COUNT_SHIFT    28
 212 #define   ZY7_DEVCFG_STATUS_RX_FIFO_LVL_MASK    (0x1f<<20)
 213 #define   ZY7_DEVCFG_STATUS_RX_FIFO_LVL_SHIFT   20
 214 #define   ZY7_DEVCFG_STATUS_TX_FIFO_LVL_MASK    (0x7f<<12)
 215 #define   ZY7_DEVCFG_STATUS_TX_FIFO_LVL_SHIFT   12
 216 #define   ZY7_DEVCFG_STATUS_PSS_GTS_USR_B       (1<<11)
 217 #define   ZY7_DEVCFG_STATUS_PSS_FST_CFG_B       (1<<10)
 218 #define   ZY7_DEVCFG_STATUS_PSS_GPWRDWN_B       (1<<9)
 219 #define   ZY7_DEVCFG_STATUS_PSS_GTS_CFG_B       (1<<8)
 220 #define   ZY7_DEVCFG_STATUS_ILL_APB_ACCE        (1<<6)
 221 #define   ZY7_DEVCFG_STATUS_PSS_CFG_RESET_B     (1<<5)
 222 #define   ZY7_DEVCFG_STATUS_PCFG_INIT           (1<<4)
 223 #define   ZY7_DEVCFG_STATUS_EFUSE_BBRAM_KEY_DIS (1<<3)
 224 #define   ZY7_DEVCFG_STATUS_EFUSE_SEC_EN        (1<<2)
 225 #define   ZY7_DEVCFG_STATUS_EFUSE_JTAG_DIS      (1<<1)
 226
 227 #define ZY7_DEVCFG_DMA_SRC_ADDR         0x018
 228 #define ZY7_DEVCFG_DMA_DST_ADDR         0x01c
 229 #define   ZY7_DEVCFG_DMA_ADDR_WAIT_PCAP 1
 230 #define   ZY7_DEVCFG_DMA_ADDR_ILLEGAL           0xffffffff
 231
 232 #define ZY7_DEVCFG_DMA_SRC_LEN          0x020   /* in 4-byte words. */
 233 #define ZY7_DEVCFG_DMA_SRC_LEN_MAX              0x7ffffff
 234 #define ZY7_DEVCFG_DMA_DST_LEN          0x024
 235 #define ZY7_DEVCFG_ROM_SHADOW           0x028
 236 #define ZY7_DEVCFG_MULTIBOOT_ADDR       0x02c
 237 #define ZY7_DEVCFG_SW_ID                0x030
 238 #define ZY7_DEVCFG_UNLOCK               0x034
 239 #define ZY7_DEVCFG_UNLOCK_MAGIC                 0x757bdf0d
 240 #define ZY7_DEVCFG_MCTRL                0x080
 241 #define   ZY7_DEVCFG_MCTRL_PS_VERS_MASK         (0xf<<28)
 242 #define   ZY7_DEVCFG_MCTRL_PS_VERS_SHIFT        28
 243 #define   ZY7_DEVCFG_MCTRL_PCFG_POR_B           (1<<8)
 244 #define   ZY7_DEVCFG_MCTRL_INT_PCAP_LPBK        (1<<4)
 245 #define ZY7_DEVCFG_XADCIF_CFG           0x100
 246 #define ZY7_DEVCFG_XADCIF_INT_STAT      0x104
 247 #define ZY7_DEVCFG_XADCIF_INT_MASK      0x108
 248 #define ZY7_DEVCFG_XADCIF_MSTS          0x10c
 249 #define ZY7_DEVCFG_XADCIF_CMD_FIFO      0x110
 250 #define ZY7_DEVCFG_XADCIF_RD_FIFO       0x114
 251 #define ZY7_DEVCFG_XADCIF_MCTL          0x118
 252
 253 static int
 254 zy7_devcfg_fclk_sysctl_source(SYSCTL_HANDLER_ARGS)
 255 {
 256         char buf[4];
 257         struct zy7_fclk_config *cfg;
 258         int unit;
 259         int error;
 260
 261         cfg = arg1;
 262         unit = arg2;
 263
 264         switch (cfg->source) {
 265                 case ZY7_PL_FCLK_SRC_IO:
 266                 case ZY7_PL_FCLK_SRC_IO_ALT:
 267                         strncpy(buf, "IO", sizeof(buf));
 268                         break;
 269                 case ZY7_PL_FCLK_SRC_DDR:
 270                         strncpy(buf, "DDR", sizeof(buf));
 271                         break;
 272                 case ZY7_PL_FCLK_SRC_ARM:
 273                         strncpy(buf, "ARM", sizeof(buf));
 274                         break;
 275                 default:
 276                         strncpy(buf, "???", sizeof(buf));
 277                         break;
 278         }
 279
 280         error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
 281         if (error != 0 || req->newptr == NULL)
 282                 return (error);
 283
 284         if (strcasecmp(buf, "io") == 0)
 285                 cfg->source = ZY7_PL_FCLK_SRC_IO;
 286         else if (strcasecmp(buf, "ddr") == 0)
 287                 cfg->source = ZY7_PL_FCLK_SRC_DDR;
 288         else if (strcasecmp(buf, "arm") == 0)
 289                 cfg->source = ZY7_PL_FCLK_SRC_ARM;
 290         else
 291                 return (EINVAL);
 292
 293         zy7_pl_fclk_set_source(unit, cfg->source);
 294         if (cfg->frequency > 0)
 295                 cfg->actual_frequency = zy7_pl_fclk_get_freq(unit);
 296
 297         return (0);
 298 }
 299
 300 static int
 301 zy7_devcfg_fclk_sysctl_freq(SYSCTL_HANDLER_ARGS)
 302 {
 303         struct zy7_fclk_config *cfg;
 304         int unit;
 305         int error;
 306         int freq;
 307         int new_actual_freq;
 308
 309         cfg = arg1;
 310         unit = arg2;
 311
 312         freq = cfg->frequency;
 313
 314         error = sysctl_handle_int(oidp, &freq, 0, req);
 315         if (error != 0 || req->newptr == NULL)
 316                 return (error);
 317
 318         if (freq > 0) {
 319                 new_actual_freq = zy7_pl_fclk_set_freq(unit, freq);
 320                 if (new_actual_freq < 0)
 321                         return (EINVAL);
 322                 if (!zy7_pl_fclk_enabled(unit))
 323                         zy7_pl_fclk_enable(unit);
 324         }
 325         else {
 326                 zy7_pl_fclk_disable(unit);
 327                 new_actual_freq = 0;
 328         }
 329
 330         cfg->frequency = freq;
 331         cfg->actual_frequency = new_actual_freq;
 332
 333         return (0);
 334 }
 335
 336 static int
 337 zy7_devcfg_fclk_sysctl_level_shifters(SYSCTL_HANDLER_ARGS)
 338 {
 339         int error, enabled;
 340
 341         enabled = zy7_pl_level_shifters_enabled();
 342
 343         error = sysctl_handle_int(oidp, &enabled, 0, req);
 344         if (error != 0 || req->newptr == NULL)
 345                 return (error);
 346
 347         if (enabled)
 348                 zy7_pl_level_shifters_enable();
 349         else
 350                 zy7_pl_level_shifters_disable();
 351
 352         return (0);
 353 }
 354
 355 static int
 356 zy7_devcfg_init_fclk_sysctl(struct zy7_devcfg_softc *sc)
 357 {
 358         struct sysctl_oid *fclk_node;
 359         char fclk_num[4];
 360         int i;
 361
 362         sysctl_ctx_init(&sc->sysctl_tree);
 363         sc->sysctl_tree_top = SYSCTL_ADD_NODE(&sc->sysctl_tree,
 364             SYSCTL_STATIC_CHILDREN(_hw_fpga), OID_AUTO, "fclk",
 365             CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 366         if (sc->sysctl_tree_top == NULL) {
 367                 sysctl_ctx_free(&sc->sysctl_tree);
 368                 return (-1);
 369         }
 370
 371         for (i = 0; i < FCLK_NUM; i++) {
 372                 snprintf(fclk_num, sizeof(fclk_num), "%d", i);
 373                 fclk_node = SYSCTL_ADD_NODE(&sc->sysctl_tree,
 374                     SYSCTL_CHILDREN(sc->sysctl_tree_top), OID_AUTO, fclk_num,
 375                     CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
 376
 377                 SYSCTL_ADD_INT(&sc->sysctl_tree,
 378                     SYSCTL_CHILDREN(fclk_node), OID_AUTO,
 379                     "actual_freq", CTLFLAG_RD,
 380                     &fclk_configs[i].actual_frequency, i,
 381                     "Actual frequency");
 382                 SYSCTL_ADD_PROC(&sc->sysctl_tree,
 383                     SYSCTL_CHILDREN(fclk_node), OID_AUTO,
 384                     "freq", CTLFLAG_RW | CTLTYPE_INT | CTLFLAG_NEEDGIANT,
 385                     &fclk_configs[i], i,
 386                     zy7_devcfg_fclk_sysctl_freq,
 387                     "I", "Configured frequency");
 388                 SYSCTL_ADD_PROC(&sc->sysctl_tree,
 389                     SYSCTL_CHILDREN(fclk_node), OID_AUTO,
 390                     "source", CTLFLAG_RW | CTLTYPE_STRING | CTLFLAG_NEEDGIANT,
 391                     &fclk_configs[i], i,
 392                     zy7_devcfg_fclk_sysctl_source,
 393                     "A", "Clock source");
 394         }
 395
 396         return (0);
 397 }
 398
 399 /* Enable programming the PL through PCAP. */
 400 static void
 401 zy7_devcfg_init_hw(struct zy7_devcfg_softc *sc)
 402 {
 403
 404         DEVCFG_SC_ASSERT_LOCKED(sc);
 405
 406         /* Set devcfg control register. */
 407         WR4(sc, ZY7_DEVCFG_CTRL,
 408             ZY7_DEVCFG_CTRL_PCFG_PROG_B |
 409             ZY7_DEVCFG_CTRL_PCAP_PR |
 410             ZY7_DEVCFG_CTRL_PCAP_MODE |
 411             ZY7_DEVCFG_CTRL_USER_MODE |
 412             ZY7_DEVCFG_CTRL_RESVD_WR11 |
 413             ZY7_DEVCFG_CTRL_SPNIDEN |
 414             ZY7_DEVCFG_CTRL_SPIDEN |
 415             ZY7_DEVCFG_CTRL_NIDEN |
 416             ZY7_DEVCFG_CTRL_DBGEN |
 417             ZY7_DEVCFG_CTRL_DAP_EN_MASK);
 418
 419         /* Turn off internal PCAP loopback. */
 420         WR4(sc, ZY7_DEVCFG_MCTRL, RD4(sc, ZY7_DEVCFG_MCTRL) &
 421             ~ZY7_DEVCFG_MCTRL_INT_PCAP_LPBK);
 422 }
 423
 424 /* Clear previous configuration of the PL by asserting PROG_B. */
 425 static int
 426 zy7_devcfg_reset_pl(struct zy7_devcfg_softc *sc)
 427 {
 428         uint32_t devcfg_ctl;
 429         int tries, err;
 430
 431         DEVCFG_SC_ASSERT_LOCKED(sc);
 432
 433         devcfg_ctl = RD4(sc, ZY7_DEVCFG_CTRL);
 434
 435         /* Clear sticky bits and set up INIT signal positive edge interrupt. */
 436         WR4(sc, ZY7_DEVCFG_INT_STATUS, ZY7_DEVCFG_INT_ALL);
 437         WR4(sc, ZY7_DEVCFG_INT_MASK, ~ZY7_DEVCFG_INT_PCFG_INIT_PE);
 438
 439         /* Deassert PROG_B (active low). */
 440         devcfg_ctl |= ZY7_DEVCFG_CTRL_PCFG_PROG_B;
 441         WR4(sc, ZY7_DEVCFG_CTRL, devcfg_ctl);
 442
 443         /*
 444          * Wait for INIT to assert.  If it is already asserted, we may not get
 445          * an edge interrupt so cancel it and continue.
 446          */
 447         if ((RD4(sc, ZY7_DEVCFG_STATUS) &
 448              ZY7_DEVCFG_STATUS_PCFG_INIT) != 0) {
 449                 /* Already asserted.  Cancel interrupt. */
 450                 WR4(sc, ZY7_DEVCFG_INT_MASK, ~0);
 451         }
 452         else {
 453                 /* Wait for positive edge interrupt. */
 454                 err = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "zy7i1", hz);
 455                 if (err != 0)
 456                         return (err);
 457         }
 458
 459         /* Reassert PROG_B (active low). */
 460         devcfg_ctl &= ~ZY7_DEVCFG_CTRL_PCFG_PROG_B;
 461         WR4(sc, ZY7_DEVCFG_CTRL, devcfg_ctl);
 462
 463         /* Wait for INIT deasserted.  This happens almost instantly. */
 464         tries = 0;
 465         while ((RD4(sc, ZY7_DEVCFG_STATUS) &
 466                 ZY7_DEVCFG_STATUS_PCFG_INIT) != 0) {
 467                 if (++tries >= 100)
 468                         return (EIO);
 469                 DELAY(5);
 470         }
 471
 472         /* Clear sticky bits and set up INIT positive edge interrupt. */
 473         WR4(sc, ZY7_DEVCFG_INT_STATUS, ZY7_DEVCFG_INT_ALL);
 474         WR4(sc, ZY7_DEVCFG_INT_MASK, ~ZY7_DEVCFG_INT_PCFG_INIT_PE);
 475
 476         /* Deassert PROG_B again. */
 477         devcfg_ctl |= ZY7_DEVCFG_CTRL_PCFG_PROG_B;
 478         WR4(sc, ZY7_DEVCFG_CTRL, devcfg_ctl);
 479
 480         /*
 481          * Wait for INIT asserted indicating FPGA internal initialization
 482          * is complete.
 483          */
 484         err = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "zy7i2", hz);
 485         if (err != 0)
 486                 return (err);
 487
 488         /* Clear sticky DONE bit in interrupt status. */
 489         WR4(sc, ZY7_DEVCFG_INT_STATUS, ZY7_DEVCFG_INT_ALL);
 490
 491         return (0);
 492 }
 493
 494 /* Callback function for bus_dmamap_load(). */
 495 static void
 496 zy7_dma_cb2(void *arg, bus_dma_segment_t *seg, int nsegs, int error)
 497 {
 498         if (!error && nsegs == 1)
 499                 *(bus_addr_t *)arg = seg[0].ds_addr;
 500 }
 501
 502 static int
 503 zy7_devcfg_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
 504 {
 505         struct zy7_devcfg_softc *sc = dev->si_drv1;
 506         int err;
 507
 508         DEVCFG_SC_LOCK(sc);
 509         if (sc->is_open) {
 510                 DEVCFG_SC_UNLOCK(sc);
 511                 return (EBUSY);
 512         }
 513
 514         sc->dma_map = NULL;
 515         err = bus_dma_tag_create(bus_get_dma_tag(sc->dev), 4, 0,
 516                                  BUS_SPACE_MAXADDR_32BIT,
 517                                  BUS_SPACE_MAXADDR,
 518                                  NULL, NULL,
 519                                  PAGE_SIZE,
 520                                  1,
 521                                  PAGE_SIZE,
 522                                  0,
 523                                  busdma_lock_mutex,
 524                                  &sc->sc_mtx,
 525                                  &sc->dma_tag);
 526         if (err) {
 527                 DEVCFG_SC_UNLOCK(sc);
 528                 return (err);
 529         }
 530
 531         sc->is_open = 1;
 532         DEVCFG_SC_UNLOCK(sc);
 533         return (0);
 534 }
 535
 536 static int
 537 zy7_devcfg_write(struct cdev *dev, struct uio *uio, int ioflag)
 538 {
 539         struct zy7_devcfg_softc *sc = dev->si_drv1;
 540         void *dma_mem;
 541         bus_addr_t dma_physaddr;
 542         int segsz, err;
 543
 544         DEVCFG_SC_LOCK(sc);
 545
 546         /* First write?  Reset PL. */
 547         if (uio->uio_offset == 0 && uio->uio_resid > 0) {
 548                 zy7_devcfg_init_hw(sc);
 549                 zy7_slcr_preload_pl();
 550                 err = zy7_devcfg_reset_pl(sc);
 551                 if (err != 0) {
 552                         DEVCFG_SC_UNLOCK(sc);
 553                         return (err);
 554                 }
 555         }
 556
 557         /* Allocate dma memory and load. */
 558         err = bus_dmamem_alloc(sc->dma_tag, &dma_mem, BUS_DMA_NOWAIT,
 559                                &sc->dma_map);
 560         if (err != 0) {
 561                 DEVCFG_SC_UNLOCK(sc);
 562                 return (err);
 563         }
 564         err = bus_dmamap_load(sc->dma_tag, sc->dma_map, dma_mem, PAGE_SIZE,
 565                               zy7_dma_cb2, &dma_physaddr, 0);
 566         if (err != 0) {
 567                 bus_dmamem_free(sc->dma_tag, dma_mem, sc->dma_map);
 568                 DEVCFG_SC_UNLOCK(sc);
 569                 return (err);
 570         }
 571
 572         while (uio->uio_resid > 0) {
 573                 /* If DONE signal has been set, we shouldn't write anymore. */
 574                 if ((RD4(sc, ZY7_DEVCFG_INT_STATUS) &
 575                      ZY7_DEVCFG_INT_PCFG_DONE) != 0) {
 576                         err = EIO;
 577                         break;
 578                 }
 579
 580                 /* uiomove the data from user buffer to our dma map. */
 581                 segsz = MIN(PAGE_SIZE, uio->uio_resid);
 582                 DEVCFG_SC_UNLOCK(sc);
 583                 err = uiomove(dma_mem, segsz, uio);
 584                 DEVCFG_SC_LOCK(sc);
 585                 if (err != 0)
 586                         break;
 587
 588                 /* Flush the cache to memory. */
 589                 bus_dmamap_sync(sc->dma_tag, sc->dma_map,
 590                                 BUS_DMASYNC_PREWRITE);
 591
 592                 /* Program devcfg's DMA engine.  The ordering of these
 593                  * register writes is critical.
 594                  */
 595                 if (uio->uio_resid > segsz)
 596                         WR4(sc, ZY7_DEVCFG_DMA_SRC_ADDR,
 597                             (uint32_t) dma_physaddr);
 598                 else
 599                         WR4(sc, ZY7_DEVCFG_DMA_SRC_ADDR,
 600                             (uint32_t) dma_physaddr |
 601                             ZY7_DEVCFG_DMA_ADDR_WAIT_PCAP);
 602                 WR4(sc, ZY7_DEVCFG_DMA_DST_ADDR, ZY7_DEVCFG_DMA_ADDR_ILLEGAL);
 603                 WR4(sc, ZY7_DEVCFG_DMA_SRC_LEN, (segsz+3)/4);
 604                 WR4(sc, ZY7_DEVCFG_DMA_DST_LEN, 0);
 605
 606                 /* Now clear done bit and set up DMA done interrupt. */
 607                 WR4(sc, ZY7_DEVCFG_INT_STATUS, ZY7_DEVCFG_INT_ALL);
 608                 WR4(sc, ZY7_DEVCFG_INT_MASK, ~ZY7_DEVCFG_INT_DMA_DONE);
 609
 610                 /* Wait for DMA done interrupt. */
 611                 err = mtx_sleep(sc->dma_map, &sc->sc_mtx, PCATCH,
 612                                 "zy7dma", hz);
 613                 if (err != 0)
 614                         break;
 615
 616                 bus_dmamap_sync(sc->dma_tag, sc->dma_map,
 617                                 BUS_DMASYNC_POSTWRITE);
 618
 619                 /* Check DONE signal. */
 620                 if ((RD4(sc, ZY7_DEVCFG_INT_STATUS) &
 621                      ZY7_DEVCFG_INT_PCFG_DONE) != 0)
 622                         zy7_slcr_postload_pl(zy7_en_level_shifters);
 623         }
 624
 625         bus_dmamap_unload(sc->dma_tag, sc->dma_map);
 626         bus_dmamem_free(sc->dma_tag, dma_mem, sc->dma_map);
 627         DEVCFG_SC_UNLOCK(sc);
 628         return (err);
 629 }
 630
 631 static int
 632 zy7_devcfg_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
 633 {
 634         struct zy7_devcfg_softc *sc = dev->si_drv1;
 635
 636         DEVCFG_SC_LOCK(sc);
 637         sc->is_open = 0;
 638         bus_dma_tag_destroy(sc->dma_tag);
 639         DEVCFG_SC_UNLOCK(sc);
 640
 641         zy7_slcr_postload_pl(zy7_en_level_shifters);
 642
 643         return (0);
 644 }
 645
 646 static void
 647 zy7_devcfg_intr(void *arg)
 648 {
 649         struct zy7_devcfg_softc *sc = (struct zy7_devcfg_softc *)arg;
 650         uint32_t istatus, imask;
 651
 652         DEVCFG_SC_LOCK(sc);
 653
 654         istatus = RD4(sc, ZY7_DEVCFG_INT_STATUS);
 655         imask = ~RD4(sc, ZY7_DEVCFG_INT_MASK);
 656
 657         /* Turn interrupt off. */
 658         WR4(sc, ZY7_DEVCFG_INT_MASK, ~0);
 659
 660         if ((istatus & imask) == 0) {
 661                 DEVCFG_SC_UNLOCK(sc);
 662                 return;
 663         }
 664
 665         /* DMA done? */
 666         if ((istatus & ZY7_DEVCFG_INT_DMA_DONE) != 0)
 667                 wakeup(sc->dma_map);
 668
 669         /* INIT_B positive edge? */
 670         if ((istatus & ZY7_DEVCFG_INT_PCFG_INIT_PE) != 0)
 671                 wakeup(sc);
 672
 673         DEVCFG_SC_UNLOCK(sc);
 674 }
 675
 676 /* zy7_devcfg_sysctl_pl_done() returns status of the PL_DONE signal.
 677  */
 678 static int
 679 zy7_devcfg_sysctl_pl_done(SYSCTL_HANDLER_ARGS)
 680 {
 681         struct zy7_devcfg_softc *sc = zy7_devcfg_softc_p;
 682         int pl_done = 0;
 683
 684         if (sc) {
 685                 DEVCFG_SC_LOCK(sc);
 686
 687                 /* PCFG_DONE bit is sticky.  Clear it before checking it. */
 688                 WR4(sc, ZY7_DEVCFG_INT_STATUS, ZY7_DEVCFG_INT_PCFG_DONE);
 689                 pl_done = ((RD4(sc, ZY7_DEVCFG_INT_STATUS) &
 690                             ZY7_DEVCFG_INT_PCFG_DONE) != 0);
 691
 692                 DEVCFG_SC_UNLOCK(sc);
 693         }
 694         return (sysctl_handle_int(oidp, &pl_done, 0, req));
 695 }
 696
 697 static int
 698 zy7_devcfg_probe(device_t dev)
 699 {
 700
 701         if (!ofw_bus_status_okay(dev))
 702                 return (ENXIO);
 703
 704         if (!ofw_bus_is_compatible(dev, "xlnx,zy7_devcfg"))
 705                 return (ENXIO);
 706
 707         device_set_desc(dev, "Zynq devcfg block");
 708         return (0);
 709 }
 710
 711 static int zy7_devcfg_detach(device_t dev);
 712
 713 static int
 714 zy7_devcfg_attach(device_t dev)
 715 {
 716         struct zy7_devcfg_softc *sc = device_get_softc(dev);
 717         int i;
 718         int rid, err;
 719
 720         /* Allow only one attach. */
 721         if (zy7_devcfg_softc_p != NULL)
 722                 return (ENXIO);
 723
 724         sc->dev = dev;
 725
 726         DEVCFG_SC_LOCK_INIT(sc);
 727
 728         /* Get memory resource. */
 729         rid = 0;
 730         sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 731                                              RF_ACTIVE);
 732         if (sc->mem_res == NULL) {
 733                 device_printf(dev, "could not allocate memory resources.\n");
 734                 zy7_devcfg_detach(dev);
 735                 return (ENOMEM);
 736         }
 737
 738         /* Allocate IRQ. */
 739         rid = 0;
 740         sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 741                                              RF_ACTIVE);
 742         if (sc->irq_res == NULL) {
 743                 device_printf(dev, "cannot allocate IRQ\n");
 744                 zy7_devcfg_detach(dev);
 745                 return (ENOMEM);
 746         }
 747
 748         /* Activate the interrupt. */
 749         err = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
 750                              NULL, zy7_devcfg_intr, sc, &sc->intrhandle);
 751         if (err) {
 752                 device_printf(dev, "cannot setup IRQ\n");
 753                 zy7_devcfg_detach(dev);
 754                 return (err);
 755         }
 756
 757         /* Create /dev/devcfg */
 758         sc->sc_ctl_dev = make_dev(&zy7_devcfg_cdevsw, 0,
 759                           UID_ROOT, GID_WHEEL, 0600, "devcfg");
 760         if (sc->sc_ctl_dev == NULL) {
 761                 device_printf(dev, "failed to create /dev/devcfg");
 762                 zy7_devcfg_detach(dev);
 763                 return (ENXIO);
 764         }
 765         sc->sc_ctl_dev->si_drv1 = sc;
 766
 767         zy7_devcfg_softc_p = sc;
 768
 769         /* Unlock devcfg registers. */
 770         WR4(sc, ZY7_DEVCFG_UNLOCK, ZY7_DEVCFG_UNLOCK_MAGIC);
 771
 772         /* Make sure interrupts are completely disabled. */
 773         WR4(sc, ZY7_DEVCFG_INT_STATUS, ZY7_DEVCFG_INT_ALL);
 774         WR4(sc, ZY7_DEVCFG_INT_MASK, 0xffffffff);
 775
 776         /* Get PS_VERS for SYSCTL. */
 777         zy7_ps_vers = (RD4(sc, ZY7_DEVCFG_MCTRL) &
 778                        ZY7_DEVCFG_MCTRL_PS_VERS_MASK) >>
 779                 ZY7_DEVCFG_MCTRL_PS_VERS_SHIFT;
 780
 781         for (i = 0; i < FCLK_NUM; i++) {
 782                 fclk_configs[i].source = zy7_pl_fclk_get_source(i);
 783                 fclk_configs[i].actual_frequency =
 784                         zy7_pl_fclk_enabled(i) ? zy7_pl_fclk_get_freq(i) : 0;
 785                 /* Initially assume actual frequency is the configure one */
 786                 fclk_configs[i].frequency = fclk_configs[i].actual_frequency;
 787         }
 788
 789         if (zy7_devcfg_init_fclk_sysctl(sc) < 0)
 790                 device_printf(dev, "failed to initialized sysctl tree\n");
 791
 792         return (0);
 793 }
 794
 795 static int
 796 zy7_devcfg_detach(device_t dev)
 797 {
 798         struct zy7_devcfg_softc *sc = device_get_softc(dev);
 799
 800         if (sc->sysctl_tree_top != NULL) {
 801                 sysctl_ctx_free(&sc->sysctl_tree);
 802                 sc->sysctl_tree_top = NULL;
 803         }
 804
 805         if (device_is_attached(dev))
 806                 bus_generic_detach(dev);
 807
 808         /* Get rid of /dev/devcfg0. */
 809         if (sc->sc_ctl_dev != NULL)
 810                 destroy_dev(sc->sc_ctl_dev);
 811
 812         /* Teardown and release interrupt. */
 813         if (sc->irq_res != NULL) {
 814                 if (sc->intrhandle)
 815                         bus_teardown_intr(dev, sc->irq_res, sc->intrhandle);
 816                 bus_release_resource(dev, SYS_RES_IRQ,
 817                              rman_get_rid(sc->irq_res), sc->irq_res);
 818         }
 819
 820         /* Release memory resource. */
 821         if (sc->mem_res != NULL)
 822                 bus_release_resource(dev, SYS_RES_MEMORY,
 823                              rman_get_rid(sc->mem_res), sc->mem_res);
 824
 825         zy7_devcfg_softc_p = NULL;
 826
 827         DEVCFG_SC_LOCK_DESTROY(sc);
 828
 829         return (0);
 830 }
 831
 832 static device_method_t zy7_devcfg_methods[] = {
 833         /* device_if */
 834         DEVMETHOD(device_probe,         zy7_devcfg_probe),
 835         DEVMETHOD(device_attach,        zy7_devcfg_attach),
 836         DEVMETHOD(device_detach,        zy7_devcfg_detach),
 837
 838         DEVMETHOD_END
 839 };
 840
 841 static driver_t zy7_devcfg_driver = {
 842         "zy7_devcfg",
 843         zy7_devcfg_methods,
 844         sizeof(struct zy7_devcfg_softc),
 845 };
 846 static devclass_t zy7_devcfg_devclass;
 847
 848 DRIVER_MODULE(zy7_devcfg, simplebus, zy7_devcfg_driver, zy7_devcfg_devclass, \
 849               0, 0);
 850 MODULE_DEPEND(zy7_devcfg, zy7_slcr, 1, 1, 1);