drivers/net/liquidio/base/lio_23xx_vf.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Cavium, Inc
   3  */
   4
   5 #include <string.h>
   6
   7 #include <rte_ethdev.h>
   8 #include <rte_cycles.h>
   9 #include <rte_malloc.h>
  10
  11 #include "lio_logs.h"
  12 #include "lio_23xx_vf.h"
  13 #include "lio_23xx_reg.h"
  14 #include "lio_mbox.h"
  15
  16 static int
  17 cn23xx_vf_reset_io_queues(struct lio_device *lio_dev, uint32_t num_queues)
  18 {
  19         uint32_t loop = CN23XX_VF_BUSY_READING_REG_LOOP_COUNT;
  20         uint64_t d64, q_no;
  21         int ret_val = 0;
  22
  23         PMD_INIT_FUNC_TRACE();
  24
  25         for (q_no = 0; q_no < num_queues; q_no++) {
  26                 /* set RST bit to 1. This bit applies to both IQ and OQ */
  27                 d64 = lio_read_csr64(lio_dev,
  28                                      CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
  29                 d64 = d64 | CN23XX_PKT_INPUT_CTL_RST;
  30                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
  31                                 d64);
  32         }
  33
  34         /* wait until the RST bit is clear or the RST and QUIET bits are set */
  35         for (q_no = 0; q_no < num_queues; q_no++) {
  36                 volatile uint64_t reg_val;
  37
  38                 reg_val = lio_read_csr64(lio_dev,
  39                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
  40                 while ((reg_val & CN23XX_PKT_INPUT_CTL_RST) &&
  41                                 !(reg_val & CN23XX_PKT_INPUT_CTL_QUIET) &&
  42                                 loop) {
  43                         reg_val = lio_read_csr64(
  44                                         lio_dev,
  45                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
  46                         loop = loop - 1;
  47                 }
  48
  49                 if (loop == 0) {
  50                         lio_dev_err(lio_dev,
  51                                     "clearing the reset reg failed or setting the quiet reg failed for qno: %lu\n",
  52                                     (unsigned long)q_no);
  53                         return -1;
  54                 }
  55
  56                 reg_val = reg_val & ~CN23XX_PKT_INPUT_CTL_RST;
  57                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
  58                                 reg_val);
  59
  60                 reg_val = lio_read_csr64(
  61                     lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
  62                 if (reg_val & CN23XX_PKT_INPUT_CTL_RST) {
  63                         lio_dev_err(lio_dev,
  64                                     "clearing the reset failed for qno: %lu\n",
  65                                     (unsigned long)q_no);
  66                         ret_val = -1;
  67                 }
  68         }
  69
  70         return ret_val;
  71 }
  72
  73 static int
  74 cn23xx_vf_setup_global_input_regs(struct lio_device *lio_dev)
  75 {
  76         uint64_t q_no;
  77         uint64_t d64;
  78
  79         PMD_INIT_FUNC_TRACE();
  80
  81         if (cn23xx_vf_reset_io_queues(lio_dev,
  82                                       lio_dev->sriov_info.rings_per_vf))
  83                 return -1;
  84
  85         for (q_no = 0; q_no < (lio_dev->sriov_info.rings_per_vf); q_no++) {
  86                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_DOORBELL(q_no),
  87                                 0xFFFFFFFF);
  88
  89                 d64 = lio_read_csr64(lio_dev,
  90                                      CN23XX_SLI_IQ_INSTR_COUNT64(q_no));
  91
  92                 d64 &= 0xEFFFFFFFFFFFFFFFL;
  93
  94                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_INSTR_COUNT64(q_no),
  95                                 d64);
  96
  97                 /* Select ES, RO, NS, RDSIZE,DPTR Fomat#0 for
  98                  * the Input Queues
  99                  */
 100                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
 101                                 CN23XX_PKT_INPUT_CTL_MASK);
 102         }
 103
 104         return 0;
 105 }
 106
 107 static void
 108 cn23xx_vf_setup_global_output_regs(struct lio_device *lio_dev)
 109 {
 110         uint32_t reg_val;
 111         uint32_t q_no;
 112
 113         PMD_INIT_FUNC_TRACE();
 114
 115         for (q_no = 0; q_no < lio_dev->sriov_info.rings_per_vf; q_no++) {
 116                 lio_write_csr(lio_dev, CN23XX_SLI_OQ_PKTS_CREDIT(q_no),
 117                               0xFFFFFFFF);
 118
 119                 reg_val =
 120                     lio_read_csr(lio_dev, CN23XX_SLI_OQ_PKTS_SENT(q_no));
 121
 122                 reg_val &= 0xEFFFFFFFFFFFFFFFL;
 123
 124                 reg_val =
 125                     lio_read_csr(lio_dev, CN23XX_SLI_OQ_PKT_CONTROL(q_no));
 126
 127                 /* set IPTR & DPTR */
 128                 reg_val |=
 129                     (CN23XX_PKT_OUTPUT_CTL_IPTR | CN23XX_PKT_OUTPUT_CTL_DPTR);
 130
 131                 /* reset BMODE */
 132                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_BMODE);
 133
 134                 /* No Relaxed Ordering, No Snoop, 64-bit Byte swap
 135                  * for Output Queue Scatter List
 136                  * reset ROR_P, NSR_P
 137                  */
 138                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ROR_P);
 139                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_NSR_P);
 140
 141 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
 142                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ES_P);
 143 #elif RTE_BYTE_ORDER == RTE_BIG_ENDIAN
 144                 reg_val |= (CN23XX_PKT_OUTPUT_CTL_ES_P);
 145 #endif
 146                 /* No Relaxed Ordering, No Snoop, 64-bit Byte swap
 147                  * for Output Queue Data
 148                  * reset ROR, NSR
 149                  */
 150                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ROR);
 151                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_NSR);
 152                 /* set the ES bit */
 153                 reg_val |= (CN23XX_PKT_OUTPUT_CTL_ES);
 154
 155                 /* write all the selected settings */
 156                 lio_write_csr(lio_dev, CN23XX_SLI_OQ_PKT_CONTROL(q_no),
 157                               reg_val);
 158         }
 159 }
 160
 161 static int
 162 cn23xx_vf_setup_device_regs(struct lio_device *lio_dev)
 163 {
 164         PMD_INIT_FUNC_TRACE();
 165
 166         if (cn23xx_vf_setup_global_input_regs(lio_dev))
 167                 return -1;
 168
 169         cn23xx_vf_setup_global_output_regs(lio_dev);
 170
 171         return 0;
 172 }
 173
 174 static void
 175 cn23xx_vf_setup_iq_regs(struct lio_device *lio_dev, uint32_t iq_no)
 176 {
 177         struct lio_instr_queue *iq = lio_dev->instr_queue[iq_no];
 178         uint64_t pkt_in_done = 0;
 179
 180         PMD_INIT_FUNC_TRACE();
 181
 182         /* Write the start of the input queue's ring and its size */
 183         lio_write_csr64(lio_dev, CN23XX_SLI_IQ_BASE_ADDR64(iq_no),
 184                         iq->base_addr_dma);
 185         lio_write_csr(lio_dev, CN23XX_SLI_IQ_SIZE(iq_no), iq->max_count);
 186
 187         /* Remember the doorbell & instruction count register addr
 188          * for this queue
 189          */
 190         iq->doorbell_reg = (uint8_t *)lio_dev->hw_addr +
 191                                 CN23XX_SLI_IQ_DOORBELL(iq_no);
 192         iq->inst_cnt_reg = (uint8_t *)lio_dev->hw_addr +
 193                                 CN23XX_SLI_IQ_INSTR_COUNT64(iq_no);
 194         lio_dev_dbg(lio_dev, "InstQ[%d]:dbell reg @ 0x%p instcnt_reg @ 0x%p\n",
 195                     iq_no, iq->doorbell_reg, iq->inst_cnt_reg);
 196
 197         /* Store the current instruction counter (used in flush_iq
 198          * calculation)
 199          */
 200         pkt_in_done = rte_read64(iq->inst_cnt_reg);
 201
 202         /* Clear the count by writing back what we read, but don't
 203          * enable data traffic here
 204          */
 205         rte_write64(pkt_in_done, iq->inst_cnt_reg);
 206 }
 207
 208 static void
 209 cn23xx_vf_setup_oq_regs(struct lio_device *lio_dev, uint32_t oq_no)
 210 {
 211         struct lio_droq *droq = lio_dev->droq[oq_no];
 212
 213         PMD_INIT_FUNC_TRACE();
 214
 215         lio_write_csr64(lio_dev, CN23XX_SLI_OQ_BASE_ADDR64(oq_no),
 216                         droq->desc_ring_dma);
 217         lio_write_csr(lio_dev, CN23XX_SLI_OQ_SIZE(oq_no), droq->max_count);
 218
 219         lio_write_csr(lio_dev, CN23XX_SLI_OQ_BUFF_INFO_SIZE(oq_no),
 220                       (droq->buffer_size | (OCTEON_RH_SIZE << 16)));
 221
 222         /* Get the mapped address of the pkt_sent and pkts_credit regs */
 223         droq->pkts_sent_reg = (uint8_t *)lio_dev->hw_addr +
 224                                         CN23XX_SLI_OQ_PKTS_SENT(oq_no);
 225         droq->pkts_credit_reg = (uint8_t *)lio_dev->hw_addr +
 226                                         CN23XX_SLI_OQ_PKTS_CREDIT(oq_no);
 227 }
 228
 229 static void
 230 cn23xx_vf_free_mbox(struct lio_device *lio_dev)
 231 {
 232         PMD_INIT_FUNC_TRACE();
 233
 234         rte_free(lio_dev->mbox[0]);
 235         lio_dev->mbox[0] = NULL;
 236
 237         rte_free(lio_dev->mbox);
 238         lio_dev->mbox = NULL;
 239 }
 240
 241 static int
 242 cn23xx_vf_setup_mbox(struct lio_device *lio_dev)
 243 {
 244         struct lio_mbox *mbox;
 245
 246         PMD_INIT_FUNC_TRACE();
 247
 248         if (lio_dev->mbox == NULL) {
 249                 lio_dev->mbox = rte_zmalloc(NULL, sizeof(void *), 0);
 250                 if (lio_dev->mbox == NULL)
 251                         return -ENOMEM;
 252         }
 253
 254         mbox = rte_zmalloc(NULL, sizeof(struct lio_mbox), 0);
 255         if (mbox == NULL) {
 256                 rte_free(lio_dev->mbox);
 257                 lio_dev->mbox = NULL;
 258                 return -ENOMEM;
 259         }
 260
 261         rte_spinlock_init(&mbox->lock);
 262
 263         mbox->lio_dev = lio_dev;
 264
 265         mbox->q_no = 0;
 266
 267         mbox->state = LIO_MBOX_STATE_IDLE;
 268
 269         /* VF mbox interrupt reg */
 270         mbox->mbox_int_reg = (uint8_t *)lio_dev->hw_addr +
 271                                 CN23XX_VF_SLI_PKT_MBOX_INT(0);
 272         /* VF reads from SIG0 reg */
 273         mbox->mbox_read_reg = (uint8_t *)lio_dev->hw_addr +
 274                                 CN23XX_SLI_PKT_PF_VF_MBOX_SIG(0, 0);
 275         /* VF writes into SIG1 reg */
 276         mbox->mbox_write_reg = (uint8_t *)lio_dev->hw_addr +
 277                                 CN23XX_SLI_PKT_PF_VF_MBOX_SIG(0, 1);
 278
 279         lio_dev->mbox[0] = mbox;
 280
 281         rte_write64(LIO_PFVFSIG, mbox->mbox_read_reg);
 282
 283         return 0;
 284 }
 285
 286 static int
 287 cn23xx_vf_enable_io_queues(struct lio_device *lio_dev)
 288 {
 289         uint32_t q_no;
 290
 291         PMD_INIT_FUNC_TRACE();
 292
 293         for (q_no = 0; q_no < lio_dev->num_iqs; q_no++) {
 294                 uint64_t reg_val;
 295
 296                 /* set the corresponding IQ IS_64B bit */
 297                 if (lio_dev->io_qmask.iq64B & (1ULL << q_no)) {
 298                         reg_val = lio_read_csr64(
 299                                         lio_dev,
 300                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
 301                         reg_val = reg_val | CN23XX_PKT_INPUT_CTL_IS_64B;
 302                         lio_write_csr64(lio_dev,
 303                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
 304                                         reg_val);
 305                 }
 306
 307                 /* set the corresponding IQ ENB bit */
 308                 if (lio_dev->io_qmask.iq & (1ULL << q_no)) {
 309                         reg_val = lio_read_csr64(
 310                                         lio_dev,
 311                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
 312                         reg_val = reg_val | CN23XX_PKT_INPUT_CTL_RING_ENB;
 313                         lio_write_csr64(lio_dev,
 314                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
 315                                         reg_val);
 316                 }
 317         }
 318         for (q_no = 0; q_no < lio_dev->num_oqs; q_no++) {
 319                 uint32_t reg_val;
 320
 321                 /* set the corresponding OQ ENB bit */
 322                 if (lio_dev->io_qmask.oq & (1ULL << q_no)) {
 323                         reg_val = lio_read_csr(
 324                                         lio_dev,
 325                                         CN23XX_SLI_OQ_PKT_CONTROL(q_no));
 326                         reg_val = reg_val | CN23XX_PKT_OUTPUT_CTL_RING_ENB;
 327                         lio_write_csr(lio_dev,
 328                                       CN23XX_SLI_OQ_PKT_CONTROL(q_no),
 329                                       reg_val);
 330                 }
 331         }
 332
 333         return 0;
 334 }
 335
 336 static void
 337 cn23xx_vf_disable_io_queues(struct lio_device *lio_dev)
 338 {
 339         uint32_t num_queues;
 340
 341         PMD_INIT_FUNC_TRACE();
 342
 343         /* per HRM, rings can only be disabled via reset operation,
 344          * NOT via SLI_PKT()_INPUT/OUTPUT_CONTROL[ENB]
 345          */
 346         num_queues = lio_dev->num_iqs;
 347         if (num_queues < lio_dev->num_oqs)
 348                 num_queues = lio_dev->num_oqs;
 349
 350         cn23xx_vf_reset_io_queues(lio_dev, num_queues);
 351 }
 352
 353 void
 354 cn23xx_vf_ask_pf_to_do_flr(struct lio_device *lio_dev)
 355 {
 356         struct lio_mbox_cmd mbox_cmd;
 357
 358         memset(&mbox_cmd, 0, sizeof(struct lio_mbox_cmd));
 359         mbox_cmd.msg.s.type = LIO_MBOX_REQUEST;
 360         mbox_cmd.msg.s.resp_needed = 0;
 361         mbox_cmd.msg.s.cmd = LIO_VF_FLR_REQUEST;
 362         mbox_cmd.msg.s.len = 1;
 363         mbox_cmd.q_no = 0;
 364         mbox_cmd.recv_len = 0;
 365         mbox_cmd.recv_status = 0;
 366         mbox_cmd.fn = NULL;
 367         mbox_cmd.fn_arg = 0;
 368
 369         lio_mbox_write(lio_dev, &mbox_cmd);
 370 }
 371
 372 static void
 373 cn23xx_pfvf_hs_callback(struct lio_device *lio_dev,
 374                         struct lio_mbox_cmd *cmd, void *arg)
 375 {
 376         uint32_t major = 0;
 377
 378         PMD_INIT_FUNC_TRACE();
 379
 380         rte_memcpy((uint8_t *)&lio_dev->pfvf_hsword, cmd->msg.s.params, 6);
 381         if (cmd->recv_len > 1) {
 382                 struct lio_version *lio_ver = (struct lio_version *)cmd->data;
 383
 384                 major = lio_ver->major;
 385                 major = major << 16;
 386         }
 387
 388         rte_atomic64_set((rte_atomic64_t *)arg, major | 1);
 389 }
 390
 391 int
 392 cn23xx_pfvf_handshake(struct lio_device *lio_dev)
 393 {
 394         struct lio_mbox_cmd mbox_cmd;
 395         struct lio_version *lio_ver = (struct lio_version *)&mbox_cmd.data[0];
 396         uint32_t q_no, count = 0;
 397         rte_atomic64_t status;
 398         uint32_t pfmajor;
 399         uint32_t vfmajor;
 400         uint32_t ret;
 401
 402         PMD_INIT_FUNC_TRACE();
 403
 404         /* Sending VF_ACTIVE indication to the PF driver */
 405         lio_dev_dbg(lio_dev, "requesting info from PF\n");
 406
 407         mbox_cmd.msg.mbox_msg64 = 0;
 408         mbox_cmd.msg.s.type = LIO_MBOX_REQUEST;
 409         mbox_cmd.msg.s.resp_needed = 1;
 410         mbox_cmd.msg.s.cmd = LIO_VF_ACTIVE;
 411         mbox_cmd.msg.s.len = 2;
 412         mbox_cmd.data[0] = 0;
 413         lio_ver->major = LIO_BASE_MAJOR_VERSION;
 414         lio_ver->minor = LIO_BASE_MINOR_VERSION;
 415         lio_ver->micro = LIO_BASE_MICRO_VERSION;
 416         mbox_cmd.q_no = 0;
 417         mbox_cmd.recv_len = 0;
 418         mbox_cmd.recv_status = 0;
 419         mbox_cmd.fn = (lio_mbox_callback)cn23xx_pfvf_hs_callback;
 420         mbox_cmd.fn_arg = (void *)&status;
 421
 422         if (lio_mbox_write(lio_dev, &mbox_cmd)) {
 423                 lio_dev_err(lio_dev, "Write to mailbox failed\n");
 424                 return -1;
 425         }
 426
 427         rte_atomic64_set(&status, 0);
 428
 429         do {
 430                 rte_delay_ms(1);
 431         } while ((rte_atomic64_read(&status) == 0) && (count++ < 10000));
 432
 433         ret = rte_atomic64_read(&status);
 434         if (ret == 0) {
 435                 lio_dev_err(lio_dev, "cn23xx_pfvf_handshake timeout\n");
 436                 return -1;
 437         }
 438
 439         for (q_no = 0; q_no < lio_dev->num_iqs; q_no++)
 440                 lio_dev->instr_queue[q_no]->txpciq.s.pkind =
 441                                                 lio_dev->pfvf_hsword.pkind;
 442
 443         vfmajor = LIO_BASE_MAJOR_VERSION;
 444         pfmajor = ret >> 16;
 445         if (pfmajor != vfmajor) {
 446                 lio_dev_err(lio_dev,
 447                             "VF LiquidIO driver (major version %d) is not compatible with LiquidIO PF driver (major version %d)\n",
 448                             vfmajor, pfmajor);
 449                 ret = -EPERM;
 450         } else {
 451                 lio_dev_dbg(lio_dev,
 452                             "VF LiquidIO driver (major version %d), LiquidIO PF driver (major version %d)\n",
 453                             vfmajor, pfmajor);
 454                 ret = 0;
 455         }
 456
 457         lio_dev_dbg(lio_dev, "got data from PF pkind is %d\n",
 458                     lio_dev->pfvf_hsword.pkind);
 459
 460         return ret;
 461 }
 462
 463 void
 464 cn23xx_vf_handle_mbox(struct lio_device *lio_dev)
 465 {
 466         uint64_t mbox_int_val;
 467
 468         /* read and clear by writing 1 */
 469         mbox_int_val = rte_read64(lio_dev->mbox[0]->mbox_int_reg);
 470         rte_write64(mbox_int_val, lio_dev->mbox[0]->mbox_int_reg);
 471         if (lio_mbox_read(lio_dev->mbox[0]))
 472                 lio_mbox_process_message(lio_dev->mbox[0]);
 473 }
 474
 475 int
 476 cn23xx_vf_setup_device(struct lio_device *lio_dev)
 477 {
 478         uint64_t reg_val;
 479
 480         PMD_INIT_FUNC_TRACE();
 481
 482         /* INPUT_CONTROL[RPVF] gives the VF IOq count */
 483         reg_val = lio_read_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(0));
 484
 485         lio_dev->pf_num = (reg_val >> CN23XX_PKT_INPUT_CTL_PF_NUM_POS) &
 486                                 CN23XX_PKT_INPUT_CTL_PF_NUM_MASK;
 487         lio_dev->vf_num = (reg_val >> CN23XX_PKT_INPUT_CTL_VF_NUM_POS) &
 488                                 CN23XX_PKT_INPUT_CTL_VF_NUM_MASK;
 489
 490         reg_val = reg_val >> CN23XX_PKT_INPUT_CTL_RPVF_POS;
 491
 492         lio_dev->sriov_info.rings_per_vf =
 493                                 reg_val & CN23XX_PKT_INPUT_CTL_RPVF_MASK;
 494
 495         lio_dev->default_config = lio_get_conf(lio_dev);
 496         if (lio_dev->default_config == NULL)
 497                 return -1;
 498
 499         lio_dev->fn_list.setup_iq_regs          = cn23xx_vf_setup_iq_regs;
 500         lio_dev->fn_list.setup_oq_regs          = cn23xx_vf_setup_oq_regs;
 501         lio_dev->fn_list.setup_mbox             = cn23xx_vf_setup_mbox;
 502         lio_dev->fn_list.free_mbox              = cn23xx_vf_free_mbox;
 503
 504         lio_dev->fn_list.setup_device_regs      = cn23xx_vf_setup_device_regs;
 505
 506         lio_dev->fn_list.enable_io_queues       = cn23xx_vf_enable_io_queues;
 507         lio_dev->fn_list.disable_io_queues      = cn23xx_vf_disable_io_queues;
 508
 509         return 0;
 510 }
 511
 512 int
 513 cn23xx_vf_set_io_queues_off(struct lio_device *lio_dev)
 514 {
 515         uint32_t loop = CN23XX_VF_BUSY_READING_REG_LOOP_COUNT;
 516         uint64_t q_no;
 517
 518         /* Disable the i/p and o/p queues for this Octeon.
 519          * IOQs will already be in reset.
 520          * If RST bit is set, wait for Quiet bit to be set
 521          * Once Quiet bit is set, clear the RST bit
 522          */
 523         PMD_INIT_FUNC_TRACE();
 524
 525         for (q_no = 0; q_no < lio_dev->sriov_info.rings_per_vf; q_no++) {
 526                 volatile uint64_t reg_val;
 527
 528                 reg_val = lio_read_csr64(lio_dev,
 529                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
 530                 while ((reg_val & CN23XX_PKT_INPUT_CTL_RST) && !(reg_val &
 531                                          CN23XX_PKT_INPUT_CTL_QUIET) && loop) {
 532                         reg_val = lio_read_csr64(
 533                                         lio_dev,
 534                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
 535                         loop = loop - 1;
 536                 }
 537
 538                 if (loop == 0) {
 539                         lio_dev_err(lio_dev,
 540                                     "clearing the reset reg failed or setting the quiet reg failed for qno %lu\n",
 541                                     (unsigned long)q_no);
 542                         return -1;
 543                 }
 544
 545                 reg_val = reg_val & ~CN23XX_PKT_INPUT_CTL_RST;
 546                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
 547                                 reg_val);
 548
 549                 reg_val = lio_read_csr64(lio_dev,
 550                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
 551                 if (reg_val & CN23XX_PKT_INPUT_CTL_RST) {
 552                         lio_dev_err(lio_dev, "unable to reset qno %lu\n",
 553                                     (unsigned long)q_no);
 554                         return -1;
 555                 }
 556         }
 557
 558         return 0;
 559 }