drivers/net/liquidio/base/lio_23xx_vf.c

   1 /*
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2017 Cavium, Inc.. All rights reserved.
   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  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Cavium, Inc. nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <rte_ethdev.h>
  35 #include <rte_cycles.h>
  36 #include <rte_malloc.h>
  37
  38 #include "lio_logs.h"
  39 #include "lio_23xx_vf.h"
  40 #include "lio_23xx_reg.h"
  41
  42 static int
  43 cn23xx_vf_reset_io_queues(struct lio_device *lio_dev, uint32_t num_queues)
  44 {
  45         uint32_t loop = CN23XX_VF_BUSY_READING_REG_LOOP_COUNT;
  46         uint64_t d64, q_no;
  47         int ret_val = 0;
  48
  49         PMD_INIT_FUNC_TRACE();
  50
  51         for (q_no = 0; q_no < num_queues; q_no++) {
  52                 /* set RST bit to 1. This bit applies to both IQ and OQ */
  53                 d64 = lio_read_csr64(lio_dev,
  54                                      CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
  55                 d64 = d64 | CN23XX_PKT_INPUT_CTL_RST;
  56                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
  57                                 d64);
  58         }
  59
  60         /* wait until the RST bit is clear or the RST and QUIET bits are set */
  61         for (q_no = 0; q_no < num_queues; q_no++) {
  62                 volatile uint64_t reg_val;
  63
  64                 reg_val = lio_read_csr64(lio_dev,
  65                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
  66                 while ((reg_val & CN23XX_PKT_INPUT_CTL_RST) &&
  67                                 !(reg_val & CN23XX_PKT_INPUT_CTL_QUIET) &&
  68                                 loop) {
  69                         reg_val = lio_read_csr64(
  70                                         lio_dev,
  71                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
  72                         loop = loop - 1;
  73                 }
  74
  75                 if (loop == 0) {
  76                         lio_dev_err(lio_dev,
  77                                     "clearing the reset reg failed or setting the quiet reg failed for qno: %lu\n",
  78                                     (unsigned long)q_no);
  79                         return -1;
  80                 }
  81
  82                 reg_val = reg_val & ~CN23XX_PKT_INPUT_CTL_RST;
  83                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
  84                                 reg_val);
  85
  86                 reg_val = lio_read_csr64(
  87                     lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
  88                 if (reg_val & CN23XX_PKT_INPUT_CTL_RST) {
  89                         lio_dev_err(lio_dev,
  90                                     "clearing the reset failed for qno: %lu\n",
  91                                     (unsigned long)q_no);
  92                         ret_val = -1;
  93                 }
  94         }
  95
  96         return ret_val;
  97 }
  98
  99 static int
 100 cn23xx_vf_setup_global_input_regs(struct lio_device *lio_dev)
 101 {
 102         uint64_t q_no;
 103         uint64_t d64;
 104
 105         PMD_INIT_FUNC_TRACE();
 106
 107         if (cn23xx_vf_reset_io_queues(lio_dev,
 108                                       lio_dev->sriov_info.rings_per_vf))
 109                 return -1;
 110
 111         for (q_no = 0; q_no < (lio_dev->sriov_info.rings_per_vf); q_no++) {
 112                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_DOORBELL(q_no),
 113                                 0xFFFFFFFF);
 114
 115                 d64 = lio_read_csr64(lio_dev,
 116                                      CN23XX_SLI_IQ_INSTR_COUNT64(q_no));
 117
 118                 d64 &= 0xEFFFFFFFFFFFFFFFL;
 119
 120                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_INSTR_COUNT64(q_no),
 121                                 d64);
 122
 123                 /* Select ES, RO, NS, RDSIZE,DPTR Fomat#0 for
 124                  * the Input Queues
 125                  */
 126                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
 127                                 CN23XX_PKT_INPUT_CTL_MASK);
 128         }
 129
 130         return 0;
 131 }
 132
 133 static void
 134 cn23xx_vf_setup_global_output_regs(struct lio_device *lio_dev)
 135 {
 136         uint32_t reg_val;
 137         uint32_t q_no;
 138
 139         PMD_INIT_FUNC_TRACE();
 140
 141         for (q_no = 0; q_no < lio_dev->sriov_info.rings_per_vf; q_no++) {
 142                 lio_write_csr(lio_dev, CN23XX_SLI_OQ_PKTS_CREDIT(q_no),
 143                               0xFFFFFFFF);
 144
 145                 reg_val =
 146                     lio_read_csr(lio_dev, CN23XX_SLI_OQ_PKTS_SENT(q_no));
 147
 148                 reg_val &= 0xEFFFFFFFFFFFFFFFL;
 149
 150                 reg_val =
 151                     lio_read_csr(lio_dev, CN23XX_SLI_OQ_PKT_CONTROL(q_no));
 152
 153                 /* set IPTR & DPTR */
 154                 reg_val |=
 155                     (CN23XX_PKT_OUTPUT_CTL_IPTR | CN23XX_PKT_OUTPUT_CTL_DPTR);
 156
 157                 /* reset BMODE */
 158                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_BMODE);
 159
 160                 /* No Relaxed Ordering, No Snoop, 64-bit Byte swap
 161                  * for Output Queue Scatter List
 162                  * reset ROR_P, NSR_P
 163                  */
 164                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ROR_P);
 165                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_NSR_P);
 166
 167 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
 168                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ES_P);
 169 #elif RTE_BYTE_ORDER == RTE_BIG_ENDIAN
 170                 reg_val |= (CN23XX_PKT_OUTPUT_CTL_ES_P);
 171 #endif
 172                 /* No Relaxed Ordering, No Snoop, 64-bit Byte swap
 173                  * for Output Queue Data
 174                  * reset ROR, NSR
 175                  */
 176                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ROR);
 177                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_NSR);
 178                 /* set the ES bit */
 179                 reg_val |= (CN23XX_PKT_OUTPUT_CTL_ES);
 180
 181                 /* write all the selected settings */
 182                 lio_write_csr(lio_dev, CN23XX_SLI_OQ_PKT_CONTROL(q_no),
 183                               reg_val);
 184         }
 185 }
 186
 187 static int
 188 cn23xx_vf_setup_device_regs(struct lio_device *lio_dev)
 189 {
 190         PMD_INIT_FUNC_TRACE();
 191
 192         if (cn23xx_vf_setup_global_input_regs(lio_dev))
 193                 return -1;
 194
 195         cn23xx_vf_setup_global_output_regs(lio_dev);
 196
 197         return 0;
 198 }
 199
 200 int
 201 cn23xx_vf_setup_device(struct lio_device *lio_dev)
 202 {
 203         uint64_t reg_val;
 204
 205         PMD_INIT_FUNC_TRACE();
 206
 207         /* INPUT_CONTROL[RPVF] gives the VF IOq count */
 208         reg_val = lio_read_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(0));
 209
 210         lio_dev->pf_num = (reg_val >> CN23XX_PKT_INPUT_CTL_PF_NUM_POS) &
 211                                 CN23XX_PKT_INPUT_CTL_PF_NUM_MASK;
 212         lio_dev->vf_num = (reg_val >> CN23XX_PKT_INPUT_CTL_VF_NUM_POS) &
 213                                 CN23XX_PKT_INPUT_CTL_VF_NUM_MASK;
 214
 215         reg_val = reg_val >> CN23XX_PKT_INPUT_CTL_RPVF_POS;
 216
 217         lio_dev->sriov_info.rings_per_vf =
 218                                 reg_val & CN23XX_PKT_INPUT_CTL_RPVF_MASK;
 219
 220         lio_dev->default_config = lio_get_conf(lio_dev);
 221         if (lio_dev->default_config == NULL)
 222                 return -1;
 223
 224         lio_dev->fn_list.setup_device_regs      = cn23xx_vf_setup_device_regs;
 225
 226         return 0;
 227 }
 228
 229 int
 230 cn23xx_vf_set_io_queues_off(struct lio_device *lio_dev)
 231 {
 232         uint32_t loop = CN23XX_VF_BUSY_READING_REG_LOOP_COUNT;
 233         uint64_t q_no;
 234
 235         /* Disable the i/p and o/p queues for this Octeon.
 236          * IOQs will already be in reset.
 237          * If RST bit is set, wait for Quiet bit to be set
 238          * Once Quiet bit is set, clear the RST bit
 239          */
 240         PMD_INIT_FUNC_TRACE();
 241
 242         for (q_no = 0; q_no < lio_dev->sriov_info.rings_per_vf; q_no++) {
 243                 volatile uint64_t reg_val;
 244
 245                 reg_val = lio_read_csr64(lio_dev,
 246                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
 247                 while ((reg_val & CN23XX_PKT_INPUT_CTL_RST) && !(reg_val &
 248                                          CN23XX_PKT_INPUT_CTL_QUIET) && loop) {
 249                         reg_val = lio_read_csr64(
 250                                         lio_dev,
 251                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
 252                         loop = loop - 1;
 253                 }
 254
 255                 if (loop == 0) {
 256                         lio_dev_err(lio_dev,
 257                                     "clearing the reset reg failed or setting the quiet reg failed for qno %lu\n",
 258                                     (unsigned long)q_no);
 259                         return -1;
 260                 }
 261
 262                 reg_val = reg_val & ~CN23XX_PKT_INPUT_CTL_RST;
 263                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
 264                                 reg_val);
 265
 266                 reg_val = lio_read_csr64(lio_dev,
 267                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
 268                 if (reg_val & CN23XX_PKT_INPUT_CTL_RST) {
 269                         lio_dev_err(lio_dev, "unable to reset qno %lu\n",
 270                                     (unsigned long)q_no);
 271                         return -1;
 272                 }
 273         }
 274
 275         return 0;
 276 }