sys/dev/ice/ice_iflib_recovery_txrx.c

   1 /* SPDX-License-Identifier: BSD-3-Clause */
   2 /*  Copyright (c) 2021, Intel Corporation
   3  *  All rights reserved.
   4  *
   5  *  Redistribution and use in source and binary forms, with or without
   6  *  modification, are permitted provided that the following conditions are met:
   7  *
   8  *   1. Redistributions of source code must retain the above copyright notice,
   9  *      this list of conditions and the following disclaimer.
  10  *
  11  *   2. Redistributions in binary form must reproduce the above copyright
  12  *      notice, this list of conditions and the following disclaimer in the
  13  *      documentation and/or other materials provided with the distribution.
  14  *
  15  *   3. Neither the name of the Intel Corporation nor the names of its
  16  *      contributors may be used to endorse or promote products derived from
  17  *      this software without specific prior written permission.
  18  *
  19  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  *  POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 /*$FreeBSD$*/
  32
  33 /**
  34  * @file ice_iflib_recovery_txrx.c
  35  * @brief iflib Tx/Rx ops for recovery mode
  36  *
  37  * Contains the if_txrx structure of operations used when the driver detects
  38  * that the firmware is in recovery mode. These ops essentially do nothing and
  39  * exist to prevent any chance that the stack could attempt to transmit or
  40  * receive when the device is in firmware recovery mode.
  41  */
  42
  43 #include "ice_iflib.h"
  44
  45 /*
  46  * iflib txrx methods used when in recovery mode
  47  */
  48 static int ice_recovery_txd_encap(void *arg, if_pkt_info_t pi);
  49 static int ice_recovery_rxd_pkt_get(void *arg, if_rxd_info_t ri);
  50 static void ice_recovery_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);
  51 static int ice_recovery_txd_credits_update(void *arg, uint16_t txqid, bool clear);
  52 static int ice_recovery_rxd_available(void *arg, uint16_t rxqid, qidx_t pidx, qidx_t budget);
  53 static void ice_recovery_rxd_flush(void *arg, uint16_t rxqid, uint8_t flidx, qidx_t pidx);
  54 static void ice_recovery_rxd_refill(void *arg, if_rxd_update_t iru);
  55
  56 /**
  57  * @var ice_recovery_txrx
  58  * @brief Tx/Rx operations for recovery mode
  59  *
  60  * Similar to ice_txrx, but contains pointers to functions which are no-ops.
  61  * Used when the driver is in firmware recovery mode to prevent any attempt to
  62  * transmit or receive packets while the hardware is not initialized.
  63  */
  64 struct if_txrx ice_recovery_txrx = {
  65         .ift_txd_encap = ice_recovery_txd_encap,
  66         .ift_txd_flush = ice_recovery_txd_flush,
  67         .ift_txd_credits_update = ice_recovery_txd_credits_update,
  68         .ift_rxd_available = ice_recovery_rxd_available,
  69         .ift_rxd_pkt_get = ice_recovery_rxd_pkt_get,
  70         .ift_rxd_refill = ice_recovery_rxd_refill,
  71         .ift_rxd_flush = ice_recovery_rxd_flush,
  72 };
  73
  74 /**
  75  * ice_recovery_txd_encap - prepare Tx descriptors for a packet
  76  * @arg: the iflib softc structure pointer
  77  * @pi: packet info
  78  *
  79  * Since the Tx queues are not initialized during recovery mode, this function
  80  * does nothing.
  81  *
  82  * @returns ENOSYS
  83  */
  84 static int
  85 ice_recovery_txd_encap(void __unused *arg, if_pkt_info_t __unused pi)
  86 {
  87         return (ENOSYS);
  88 }
  89
  90 /**
  91  * ice_recovery_txd_flush - Flush Tx descriptors to hardware
  92  * @arg: device specific softc pointer
  93  * @txqid: the Tx queue to flush
  94  * @pidx: descriptor index to advance tail to
  95  *
  96  * Since the Tx queues are not initialized during recovery mode, this function
  97  * does nothing.
  98  */
  99 static void
 100 ice_recovery_txd_flush(void __unused *arg, uint16_t __unused txqid,
 101                        qidx_t __unused pidx)
 102 {
 103         ;
 104 }
 105
 106 /**
 107  * ice_recovery_txd_credits_update - cleanup Tx descriptors
 108  * @arg: device private softc
 109  * @txqid: the Tx queue to update
 110  * @clear: if false, only report, do not actually clean
 111  *
 112  * Since the Tx queues are not initialized during recovery mode, this function
 113  * always reports that no descriptors are ready.
 114  *
 115  * @returns 0
 116  */
 117 static int
 118 ice_recovery_txd_credits_update(void __unused *arg, uint16_t __unused txqid,
 119                                 bool __unused clear)
 120 {
 121         return (0);
 122 }
 123
 124 /**
 125  * ice_recovery_rxd_available - Return number of available Rx packets
 126  * @arg: device private softc
 127  * @rxqid: the Rx queue id
 128  * @pidx: descriptor start point
 129  * @budget: maximum Rx budget
 130  *
 131  * Since the Rx queues are not initialized during recovery mode, this function
 132  * always reports that no packets are ready.
 133  *
 134  * @returns 0
 135  */
 136 static int
 137 ice_recovery_rxd_available(void __unused *arg, uint16_t __unused rxqid,
 138                            qidx_t __unused pidx, qidx_t __unused budget)
 139 {
 140         return (0);
 141 }
 142
 143 /**
 144  * ice_recovery_rxd_pkt_get - Called by iflib to send data to upper layer
 145  * @arg: device specific softc
 146  * @ri: receive packet info
 147  *
 148  * Since the Rx queues are not initialized during recovery mode this function
 149  * always returns an error indicating that nothing could be done.
 150  *
 151  * @returns ENOSYS
 152  */
 153 static int
 154 ice_recovery_rxd_pkt_get(void __unused *arg, if_rxd_info_t __unused ri)
 155 {
 156         return (ENOSYS);
 157 }
 158
 159 /**
 160  * ice_recovery_rxd_refill - Prepare Rx descriptors for re-use by hardware
 161  * @arg: device specific softc structure
 162  * @iru: the Rx descriptor update structure
 163  *
 164  * Since the Rx queues are not initialized during Recovery mode, this function
 165  * does nothing.
 166  */
 167 static void
 168 ice_recovery_rxd_refill(void __unused *arg, if_rxd_update_t __unused iru)
 169 {
 170         ;
 171 }
 172
 173 /**
 174  * ice_recovery_rxd_flush - Flush Rx descriptors to hardware
 175  * @arg: device specific softc pointer
 176  * @rxqid: the Rx queue to flush
 177  * @flidx: unused parameter
 178  * @pidx: descriptor index to advance tail to
 179  *
 180  * Since the Rx queues are not initialized during Recovery mode, this function
 181  * does nothing.
 182  */
 183 static void
 184 ice_recovery_rxd_flush(void __unused *arg, uint16_t __unused rxqid,
 185                        uint8_t flidx __unused, qidx_t __unused pidx)
 186 {
 187         ;
 188 }