drivers/bus/dpaa/base/qbman/qman_driver.c

   1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
   2  *
   3  * Copyright 2008-2016 Freescale Semiconductor Inc.
   4  * Copyright 2017,2019 NXP
   5  *
   6  */
   7
   8 #include <fsl_usd.h>
   9 #include <process.h>
  10 #include "qman_priv.h"
  11 #include <sys/ioctl.h>
  12 #include <rte_branch_prediction.h>
  13
  14 /* Global variable containing revision id (even on non-control plane systems
  15  * where CCSR isn't available).
  16  */
  17 u16 qman_ip_rev;
  18 u16 qm_channel_pool1 = QMAN_CHANNEL_POOL1;
  19 u16 qm_channel_caam = QMAN_CHANNEL_CAAM;
  20 u16 qm_channel_pme = QMAN_CHANNEL_PME;
  21
  22 /* Ccsr map address to access ccsrbased register */
  23 static void *qman_ccsr_map;
  24 /* The qman clock frequency */
  25 static u32 qman_clk;
  26
  27 static __thread int qmfd = -1;
  28 static __thread struct qm_portal_config qpcfg;
  29 static __thread struct dpaa_ioctl_portal_map map = {
  30         .type = dpaa_portal_qman
  31 };
  32
  33 static int fsl_qman_portal_init(uint32_t index, int is_shared)
  34 {
  35         struct qman_portal *portal;
  36         struct dpaa_ioctl_irq_map irq_map;
  37         int ret;
  38
  39         /* Allocate and map a qman portal */
  40         map.index = index;
  41         ret = process_portal_map(&map);
  42         if (ret) {
  43                 error(0, ret, "process_portal_map()");
  44                 return ret;
  45         }
  46         qpcfg.channel = map.channel;
  47         qpcfg.pools = map.pools;
  48         qpcfg.index = map.index;
  49
  50         /* Make the portal's cache-[enabled|inhibited] regions */
  51         qpcfg.addr_virt[DPAA_PORTAL_CE] = map.addr.cena;
  52         qpcfg.addr_virt[DPAA_PORTAL_CI] = map.addr.cinh;
  53
  54         qmfd = open(QMAN_PORTAL_IRQ_PATH, O_RDONLY);
  55         if (qmfd == -1) {
  56                 pr_err("QMan irq init failed\n");
  57                 process_portal_unmap(&map.addr);
  58                 return -EBUSY;
  59         }
  60
  61         qpcfg.is_shared = is_shared;
  62         qpcfg.node = NULL;
  63         qpcfg.irq = qmfd;
  64
  65         portal = qman_create_affine_portal(&qpcfg, NULL);
  66         if (!portal) {
  67                 pr_err("Qman portal initialisation failed (%d)\n",
  68                        qpcfg.cpu);
  69                 process_portal_unmap(&map.addr);
  70                 return -EBUSY;
  71         }
  72
  73         irq_map.type = dpaa_portal_qman;
  74         irq_map.portal_cinh = map.addr.cinh;
  75         process_portal_irq_map(qmfd, &irq_map);
  76         return 0;
  77 }
  78
  79 static int fsl_qman_portal_finish(void)
  80 {
  81         __maybe_unused const struct qm_portal_config *cfg;
  82         int ret;
  83
  84         process_portal_irq_unmap(qmfd);
  85
  86         cfg = qman_destroy_affine_portal(NULL);
  87         DPAA_BUG_ON(cfg != &qpcfg);
  88         ret = process_portal_unmap(&map.addr);
  89         if (ret)
  90                 error(0, ret, "process_portal_unmap()");
  91         return ret;
  92 }
  93
  94 int qman_thread_fd(void)
  95 {
  96         return qmfd;
  97 }
  98
  99 int qman_thread_init(void)
 100 {
 101         /* Convert from contiguous/virtual cpu numbering to real cpu when
 102          * calling into the code that is dependent on the device naming.
 103          */
 104         return fsl_qman_portal_init(QBMAN_ANY_PORTAL_IDX, 0);
 105 }
 106
 107 int qman_thread_finish(void)
 108 {
 109         return fsl_qman_portal_finish();
 110 }
 111
 112 void qman_thread_irq(void)
 113 {
 114         qbman_invoke_irq(qpcfg.irq);
 115
 116         /* Now we need to uninhibit interrupts. This is the only code outside
 117          * the regular portal driver that manipulates any portal register, so
 118          * rather than breaking that encapsulation I am simply hard-coding the
 119          * offset to the inhibit register here.
 120          */
 121         out_be32(qpcfg.addr_virt[DPAA_PORTAL_CI] + 0x36C0, 0);
 122 }
 123
 124 void qman_fq_portal_thread_irq(struct qman_portal *qp)
 125 {
 126         qman_portal_uninhibit_isr(qp);
 127 }
 128
 129 struct qman_portal *fsl_qman_fq_portal_create(int *fd)
 130 {
 131         struct qman_portal *portal = NULL;
 132         struct qm_portal_config *q_pcfg;
 133         struct dpaa_ioctl_irq_map irq_map;
 134         struct dpaa_ioctl_portal_map q_map = {0};
 135         int q_fd = 0, ret;
 136
 137         q_pcfg = kzalloc((sizeof(struct qm_portal_config)), 0);
 138         if (!q_pcfg) {
 139                 error(0, -1, "q_pcfg kzalloc failed");
 140                 return NULL;
 141         }
 142
 143         /* Allocate and map a qman portal */
 144         q_map.type = dpaa_portal_qman;
 145         q_map.index = QBMAN_ANY_PORTAL_IDX;
 146         ret = process_portal_map(&q_map);
 147         if (ret) {
 148                 error(0, ret, "process_portal_map()");
 149                 kfree(q_pcfg);
 150                 return NULL;
 151         }
 152         q_pcfg->channel = q_map.channel;
 153         q_pcfg->pools = q_map.pools;
 154         q_pcfg->index = q_map.index;
 155
 156         /* Make the portal's cache-[enabled|inhibited] regions */
 157         q_pcfg->addr_virt[DPAA_PORTAL_CE] = q_map.addr.cena;
 158         q_pcfg->addr_virt[DPAA_PORTAL_CI] = q_map.addr.cinh;
 159
 160         q_fd = open(QMAN_PORTAL_IRQ_PATH, O_RDONLY);
 161         if (q_fd == -1) {
 162                 pr_err("QMan irq init failed\n");
 163                 goto err;
 164         }
 165
 166         q_pcfg->irq = q_fd;
 167
 168         portal = qman_alloc_global_portal(q_pcfg);
 169         if (!portal) {
 170                 pr_err("Qman portal initialisation failed (%d)\n",
 171                        q_pcfg->cpu);
 172                 goto err;
 173         }
 174
 175         irq_map.type = dpaa_portal_qman;
 176         irq_map.portal_cinh = q_map.addr.cinh;
 177         process_portal_irq_map(q_fd, &irq_map);
 178
 179         *fd = q_fd;
 180         return portal;
 181 err:
 182         if (portal)
 183                 qman_free_global_portal(portal);
 184         if (q_fd)
 185                 close(q_fd);
 186         process_portal_unmap(&q_map.addr);
 187         kfree(q_pcfg);
 188         return NULL;
 189 }
 190
 191 int fsl_qman_fq_portal_init(struct qman_portal *qp)
 192 {
 193         struct qman_portal *res;
 194
 195         res = qman_init_portal(qp, NULL, NULL);
 196         if (!res) {
 197                 pr_err("Qman portal initialisation failed\n");
 198                 return -1;
 199         }
 200
 201         return 0;
 202 }
 203
 204 int fsl_qman_fq_portal_destroy(struct qman_portal *qp)
 205 {
 206         const struct qm_portal_config *cfg;
 207         struct dpaa_portal_map addr;
 208         int ret;
 209
 210         cfg = qman_destroy_affine_portal(qp);
 211
 212         ret = qman_free_global_portal(qp);
 213         if (ret)
 214                 pr_err("qman_free_global_portal() (%d)\n", ret);
 215
 216         kfree(qp);
 217
 218         process_portal_irq_unmap(cfg->irq);
 219
 220         addr.cena = cfg->addr_virt[DPAA_PORTAL_CE];
 221         addr.cinh = cfg->addr_virt[DPAA_PORTAL_CI];
 222
 223         ret = process_portal_unmap(&addr);
 224         if (ret)
 225                 pr_err("process_portal_unmap() (%d)\n", ret);
 226
 227         kfree((void *)cfg);
 228
 229         return ret;
 230 }
 231
 232 int qman_global_init(void)
 233 {
 234         const struct device_node *dt_node;
 235         size_t lenp;
 236         const u32 *chanid;
 237         static int ccsr_map_fd;
 238         const uint32_t *qman_addr;
 239         uint64_t phys_addr;
 240         uint64_t regs_size;
 241         const u32 *clk;
 242
 243         static int done;
 244
 245         if (done)
 246                 return -EBUSY;
 247
 248         /* Use the device-tree to determine IP revision until something better
 249          * is devised.
 250          */
 251         dt_node = of_find_compatible_node(NULL, NULL, "fsl,qman-portal");
 252         if (!dt_node) {
 253                 pr_err("No qman portals available for any CPU\n");
 254                 return -ENODEV;
 255         }
 256         if (of_device_is_compatible(dt_node, "fsl,qman-portal-1.0") ||
 257             of_device_is_compatible(dt_node, "fsl,qman-portal-1.0.0"))
 258                 pr_err("QMan rev1.0 on P4080 rev1 is not supported!\n");
 259         else if (of_device_is_compatible(dt_node, "fsl,qman-portal-1.1") ||
 260                  of_device_is_compatible(dt_node, "fsl,qman-portal-1.1.0"))
 261                 qman_ip_rev = QMAN_REV11;
 262         else if (of_device_is_compatible(dt_node, "fsl,qman-portal-1.2") ||
 263                  of_device_is_compatible(dt_node, "fsl,qman-portal-1.2.0"))
 264                 qman_ip_rev = QMAN_REV12;
 265         else if (of_device_is_compatible(dt_node, "fsl,qman-portal-2.0") ||
 266                  of_device_is_compatible(dt_node, "fsl,qman-portal-2.0.0"))
 267                 qman_ip_rev = QMAN_REV20;
 268         else if (of_device_is_compatible(dt_node, "fsl,qman-portal-3.0.0") ||
 269                  of_device_is_compatible(dt_node, "fsl,qman-portal-3.0.1"))
 270                 qman_ip_rev = QMAN_REV30;
 271         else if (of_device_is_compatible(dt_node, "fsl,qman-portal-3.1.0") ||
 272                  of_device_is_compatible(dt_node, "fsl,qman-portal-3.1.1") ||
 273                 of_device_is_compatible(dt_node, "fsl,qman-portal-3.1.2") ||
 274                 of_device_is_compatible(dt_node, "fsl,qman-portal-3.1.3"))
 275                 qman_ip_rev = QMAN_REV31;
 276         else if (of_device_is_compatible(dt_node, "fsl,qman-portal-3.2.0") ||
 277                  of_device_is_compatible(dt_node, "fsl,qman-portal-3.2.1"))
 278                 qman_ip_rev = QMAN_REV32;
 279         else
 280                 qman_ip_rev = QMAN_REV11;
 281
 282         if (!qman_ip_rev) {
 283                 pr_err("Unknown qman portal version\n");
 284                 return -ENODEV;
 285         }
 286         if ((qman_ip_rev & 0xFF00) >= QMAN_REV30) {
 287                 qm_channel_pool1 = QMAN_CHANNEL_POOL1_REV3;
 288                 qm_channel_caam = QMAN_CHANNEL_CAAM_REV3;
 289                 qm_channel_pme = QMAN_CHANNEL_PME_REV3;
 290         }
 291
 292         dt_node = of_find_compatible_node(NULL, NULL, "fsl,pool-channel-range");
 293         if (!dt_node) {
 294                 pr_err("No qman pool channel range available\n");
 295                 return -ENODEV;
 296         }
 297         chanid = of_get_property(dt_node, "fsl,pool-channel-range", &lenp);
 298         if (!chanid) {
 299                 pr_err("Can not get pool-channel-range property\n");
 300                 return -EINVAL;
 301         }
 302
 303         /* get ccsr base */
 304         dt_node = of_find_compatible_node(NULL, NULL, "fsl,qman");
 305         if (!dt_node) {
 306                 pr_err("No qman device node available\n");
 307                 return -ENODEV;
 308         }
 309         qman_addr = of_get_address(dt_node, 0, &regs_size, NULL);
 310         if (!qman_addr) {
 311                 pr_err("of_get_address cannot return qman address\n");
 312                 return -EINVAL;
 313         }
 314         phys_addr = of_translate_address(dt_node, qman_addr);
 315         if (!phys_addr) {
 316                 pr_err("of_translate_address failed\n");
 317                 return -EINVAL;
 318         }
 319
 320         ccsr_map_fd = open("/dev/mem", O_RDWR);
 321         if (unlikely(ccsr_map_fd < 0)) {
 322                 pr_err("Can not open /dev/mem for qman ccsr map\n");
 323                 return ccsr_map_fd;
 324         }
 325
 326         qman_ccsr_map = mmap(NULL, regs_size, PROT_READ | PROT_WRITE,
 327                              MAP_SHARED, ccsr_map_fd, phys_addr);
 328         if (qman_ccsr_map == MAP_FAILED) {
 329                 pr_err("Can not map qman ccsr base\n");
 330                 return -EINVAL;
 331         }
 332
 333         clk = of_get_property(dt_node, "clock-frequency", NULL);
 334         if (!clk)
 335                 pr_warn("Can't find Qman clock frequency\n");
 336         else
 337                 qman_clk = be32_to_cpu(*clk);
 338
 339 #ifdef CONFIG_FSL_QMAN_FQ_LOOKUP
 340         return qman_setup_fq_lookup_table(CONFIG_FSL_QMAN_FQ_LOOKUP_MAX);
 341 #endif
 342         return 0;
 343 }