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

   1 /*-
   2  * This file is provided under a dual BSD/GPLv2 license. When using or
   3  * redistributing this file, you may do so under either license.
   4  *
   5  *   BSD LICENSE
   6  *
   7  * Copyright 2008-2016 Freescale Semiconductor Inc.
   8  * Copyright 2017 NXP.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are met:
  12  * * Redistributions of source code must retain the above copyright
  13  * notice, this list of conditions and the following disclaimer.
  14  * * Redistributions in binary form must reproduce the above copyright
  15  * notice, this list of conditions and the following disclaimer in the
  16  * documentation and/or other materials provided with the distribution.
  17  * * Neither the name of the above-listed copyright holders nor the
  18  * names of any contributors may be used to endorse or promote products
  19  * derived from this software without specific prior written permission.
  20  *
  21  *   GPL LICENSE SUMMARY
  22  *
  23  * ALTERNATIVELY, this software may be distributed under the terms of the
  24  * GNU General Public License ("GPL") as published by the Free Software
  25  * Foundation, either version 2 of that License or (at your option) any
  26  * later version.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  29  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40
  41 #include <rte_branch_prediction.h>
  42
  43 #include <fsl_usd.h>
  44 #include <process.h>
  45 #include "bman_priv.h"
  46 #include <sys/ioctl.h>
  47
  48 /*
  49  * Global variables of the max portal/pool number this bman version supported
  50  */
  51 u16 bman_ip_rev;
  52 u16 bman_pool_max;
  53 void *bman_ccsr_map;
  54
  55 /*****************/
  56 /* Portal driver */
  57 /*****************/
  58
  59 static __thread int fd = -1;
  60 static __thread struct bm_portal_config pcfg;
  61 static __thread struct dpaa_ioctl_portal_map map = {
  62         .type = dpaa_portal_bman
  63 };
  64
  65 static int fsl_bman_portal_init(uint32_t idx, int is_shared)
  66 {
  67         cpu_set_t cpuset;
  68         int loop, ret;
  69         struct dpaa_ioctl_irq_map irq_map;
  70
  71         /* Verify the thread's cpu-affinity */
  72         ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t),
  73                                      &cpuset);
  74         if (ret) {
  75                 error(0, ret, "pthread_getaffinity_np()");
  76                 return ret;
  77         }
  78         pcfg.cpu = -1;
  79         for (loop = 0; loop < CPU_SETSIZE; loop++)
  80                 if (CPU_ISSET(loop, &cpuset)) {
  81                         if (pcfg.cpu != -1) {
  82                                 pr_err("Thread is not affine to 1 cpu");
  83                                 return -EINVAL;
  84                         }
  85                         pcfg.cpu = loop;
  86                 }
  87         if (pcfg.cpu == -1) {
  88                 pr_err("Bug in getaffinity handling!");
  89                 return -EINVAL;
  90         }
  91         /* Allocate and map a bman portal */
  92         map.index = idx;
  93         ret = process_portal_map(&map);
  94         if (ret) {
  95                 error(0, ret, "process_portal_map()");
  96                 return ret;
  97         }
  98         /* Make the portal's cache-[enabled|inhibited] regions */
  99         pcfg.addr_virt[DPAA_PORTAL_CE] = map.addr.cena;
 100         pcfg.addr_virt[DPAA_PORTAL_CI] = map.addr.cinh;
 101         pcfg.is_shared = is_shared;
 102         pcfg.index = map.index;
 103         bman_depletion_fill(&pcfg.mask);
 104
 105         fd = open(BMAN_PORTAL_IRQ_PATH, O_RDONLY);
 106         if (fd == -1) {
 107                 pr_err("BMan irq init failed");
 108                 process_portal_unmap(&map.addr);
 109                 return -EBUSY;
 110         }
 111         /* Use the IRQ FD as a unique IRQ number */
 112         pcfg.irq = fd;
 113
 114         /* Set the IRQ number */
 115         irq_map.type = dpaa_portal_bman;
 116         irq_map.portal_cinh = map.addr.cinh;
 117         process_portal_irq_map(fd, &irq_map);
 118         return 0;
 119 }
 120
 121 static int fsl_bman_portal_finish(void)
 122 {
 123         int ret;
 124
 125         process_portal_irq_unmap(fd);
 126
 127         ret = process_portal_unmap(&map.addr);
 128         if (ret)
 129                 error(0, ret, "process_portal_unmap()");
 130         return ret;
 131 }
 132
 133 int bman_thread_init(void)
 134 {
 135         /* Convert from contiguous/virtual cpu numbering to real cpu when
 136          * calling into the code that is dependent on the device naming.
 137          */
 138         return fsl_bman_portal_init(QBMAN_ANY_PORTAL_IDX, 0);
 139 }
 140
 141 int bman_thread_finish(void)
 142 {
 143         return fsl_bman_portal_finish();
 144 }
 145
 146 void bman_thread_irq(void)
 147 {
 148         qbman_invoke_irq(pcfg.irq);
 149         /* Now we need to uninhibit interrupts. This is the only code outside
 150          * the regular portal driver that manipulates any portal register, so
 151          * rather than breaking that encapsulation I am simply hard-coding the
 152          * offset to the inhibit register here.
 153          */
 154         out_be32(pcfg.addr_virt[DPAA_PORTAL_CI] + 0xe0c, 0);
 155 }
 156
 157 int bman_init_ccsr(const struct device_node *node)
 158 {
 159         static int ccsr_map_fd;
 160         uint64_t phys_addr;
 161         const uint32_t *bman_addr;
 162         uint64_t regs_size;
 163
 164         bman_addr = of_get_address(node, 0, &regs_size, NULL);
 165         if (!bman_addr) {
 166                 pr_err("of_get_address cannot return BMan address");
 167                 return -EINVAL;
 168         }
 169         phys_addr = of_translate_address(node, bman_addr);
 170         if (!phys_addr) {
 171                 pr_err("of_translate_address failed");
 172                 return -EINVAL;
 173         }
 174
 175         ccsr_map_fd = open(BMAN_CCSR_MAP, O_RDWR);
 176         if (unlikely(ccsr_map_fd < 0)) {
 177                 pr_err("Can not open /dev/mem for BMan CCSR map");
 178                 return ccsr_map_fd;
 179         }
 180
 181         bman_ccsr_map = mmap(NULL, regs_size, PROT_READ |
 182                              PROT_WRITE, MAP_SHARED, ccsr_map_fd, phys_addr);
 183         if (bman_ccsr_map == MAP_FAILED) {
 184                 pr_err("Can not map BMan CCSR base Bman: "
 185                        "0x%x Phys: 0x%lx size 0x%lx",
 186                        *bman_addr, phys_addr, regs_size);
 187                 return -EINVAL;
 188         }
 189
 190         return 0;
 191 }
 192
 193 int bman_global_init(void)
 194 {
 195         const struct device_node *dt_node;
 196         static int done;
 197
 198         if (done)
 199                 return -EBUSY;
 200         /* Use the device-tree to determine IP revision until something better
 201          * is devised.
 202          */
 203         dt_node = of_find_compatible_node(NULL, NULL, "fsl,bman-portal");
 204         if (!dt_node) {
 205                 pr_err("No bman portals available for any CPU\n");
 206                 return -ENODEV;
 207         }
 208         if (of_device_is_compatible(dt_node, "fsl,bman-portal-1.0") ||
 209             of_device_is_compatible(dt_node, "fsl,bman-portal-1.0.0")) {
 210                 bman_ip_rev = BMAN_REV10;
 211                 bman_pool_max = 64;
 212         } else if (of_device_is_compatible(dt_node, "fsl,bman-portal-2.0") ||
 213                 of_device_is_compatible(dt_node, "fsl,bman-portal-2.0.8")) {
 214                 bman_ip_rev = BMAN_REV20;
 215                 bman_pool_max = 8;
 216         } else if (of_device_is_compatible(dt_node, "fsl,bman-portal-2.1.0") ||
 217                 of_device_is_compatible(dt_node, "fsl,bman-portal-2.1.1") ||
 218                 of_device_is_compatible(dt_node, "fsl,bman-portal-2.1.2") ||
 219                 of_device_is_compatible(dt_node, "fsl,bman-portal-2.1.3")) {
 220                 bman_ip_rev = BMAN_REV21;
 221                 bman_pool_max = 64;
 222         } else {
 223                 pr_warn("unknown BMan version in portal node,default "
 224                         "to rev1.0");
 225                 bman_ip_rev = BMAN_REV10;
 226                 bman_pool_max = 64;
 227         }
 228
 229         if (!bman_ip_rev) {
 230                 pr_err("Unknown bman portal version\n");
 231                 return -ENODEV;
 232         }
 233         {
 234                 const struct device_node *dn = of_find_compatible_node(NULL,
 235                                                         NULL, "fsl,bman");
 236                 if (!dn)
 237                         pr_err("No bman device node available");
 238
 239                 if (bman_init_ccsr(dn))
 240                         pr_err("BMan CCSR map failed.");
 241         }
 242
 243         done = 1;
 244         return 0;
 245 }
 246
 247 #define BMAN_POOL_CONTENT(n) (0x0600 + ((n) * 0x04))
 248 u32 bm_pool_free_buffers(u32 bpid)
 249 {
 250         return in_be32(bman_ccsr_map + BMAN_POOL_CONTENT(bpid));
 251 }
 252
 253 static u32 __generate_thresh(u32 val, int roundup)
 254 {
 255         u32 e = 0;      /* co-efficient, exponent */
 256         int oddbit = 0;
 257
 258         while (val > 0xff) {
 259                 oddbit = val & 1;
 260                 val >>= 1;
 261                 e++;
 262                 if (roundup && oddbit)
 263                         val++;
 264         }
 265         DPAA_ASSERT(e < 0x10);
 266         return (val | (e << 8));
 267 }
 268
 269 #define POOL_SWDET(n)       (0x0000 + ((n) * 0x04))
 270 #define POOL_HWDET(n)       (0x0100 + ((n) * 0x04))
 271 #define POOL_SWDXT(n)       (0x0200 + ((n) * 0x04))
 272 #define POOL_HWDXT(n)       (0x0300 + ((n) * 0x04))
 273 int bm_pool_set(u32 bpid, const u32 *thresholds)
 274 {
 275         if (!bman_ccsr_map)
 276                 return -ENODEV;
 277         if (bpid >= bman_pool_max)
 278                 return -EINVAL;
 279         out_be32(bman_ccsr_map + POOL_SWDET(bpid),
 280                  __generate_thresh(thresholds[0], 0));
 281         out_be32(bman_ccsr_map + POOL_SWDXT(bpid),
 282                  __generate_thresh(thresholds[1], 1));
 283         out_be32(bman_ccsr_map + POOL_HWDET(bpid),
 284                  __generate_thresh(thresholds[2], 0));
 285         out_be32(bman_ccsr_map + POOL_HWDXT(bpid),
 286                  __generate_thresh(thresholds[3], 1));
 287         return 0;
 288 }
 289
 290 #define BMAN_LOW_DEFAULT_THRESH         0x40
 291 #define BMAN_HIGH_DEFAULT_THRESH                0x80
 292 int bm_pool_set_hw_threshold(u32 bpid, const u32 low_thresh,
 293                              const u32 high_thresh)
 294 {
 295         if (!bman_ccsr_map)
 296                 return -ENODEV;
 297         if (bpid >= bman_pool_max)
 298                 return -EINVAL;
 299         if (low_thresh && high_thresh) {
 300                 out_be32(bman_ccsr_map + POOL_HWDET(bpid),
 301                          __generate_thresh(low_thresh, 0));
 302                 out_be32(bman_ccsr_map + POOL_HWDXT(bpid),
 303                          __generate_thresh(high_thresh, 1));
 304         } else {
 305                 out_be32(bman_ccsr_map + POOL_HWDET(bpid),
 306                          __generate_thresh(BMAN_LOW_DEFAULT_THRESH, 0));
 307                 out_be32(bman_ccsr_map + POOL_HWDXT(bpid),
 308                          __generate_thresh(BMAN_HIGH_DEFAULT_THRESH, 1));
 309         }
 310         return 0;
 311 }