drivers/net/i40e/base/i40e_common.c

   1 /*******************************************************************************
   2
   3 Copyright (c) 2013 - 2015, Intel Corporation
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions are met:
   8
   9  1. Redistributions of source code must retain the above copyright notice,
  10     this list of conditions and the following disclaimer.
  11
  12  2. Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in the
  14     documentation and/or other materials provided with the distribution.
  15
  16  3. Neither the name of the Intel Corporation nor the names of its
  17     contributors may be used to endorse or promote products derived from
  18     this software without specific prior written permission.
  19
  20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 ***************************************************************************/
  33
  34 #include "i40e_type.h"
  35 #include "i40e_adminq.h"
  36 #include "i40e_prototype.h"
  37 #include "i40e_virtchnl.h"
  38
  39
  40 /**
  41  * i40e_set_mac_type - Sets MAC type
  42  * @hw: pointer to the HW structure
  43  *
  44  * This function sets the mac type of the adapter based on the
  45  * vendor ID and device ID stored in the hw structure.
  46  **/
  47 #if defined(INTEGRATED_VF) || defined(VF_DRIVER)
  48 enum i40e_status_code i40e_set_mac_type(struct i40e_hw *hw)
  49 #else
  50 STATIC enum i40e_status_code i40e_set_mac_type(struct i40e_hw *hw)
  51 #endif
  52 {
  53         enum i40e_status_code status = I40E_SUCCESS;
  54
  55         DEBUGFUNC("i40e_set_mac_type\n");
  56
  57         if (hw->vendor_id == I40E_INTEL_VENDOR_ID) {
  58                 switch (hw->device_id) {
  59                 case I40E_DEV_ID_SFP_XL710:
  60                 case I40E_DEV_ID_QEMU:
  61                 case I40E_DEV_ID_KX_A:
  62                 case I40E_DEV_ID_KX_B:
  63                 case I40E_DEV_ID_KX_C:
  64                 case I40E_DEV_ID_QSFP_A:
  65                 case I40E_DEV_ID_QSFP_B:
  66                 case I40E_DEV_ID_QSFP_C:
  67                 case I40E_DEV_ID_10G_BASE_T:
  68                 case I40E_DEV_ID_10G_BASE_T4:
  69                 case I40E_DEV_ID_20G_KR2:
  70                 case I40E_DEV_ID_20G_KR2_A:
  71                         hw->mac.type = I40E_MAC_XL710;
  72                         break;
  73                 case I40E_DEV_ID_VF:
  74                 case I40E_DEV_ID_VF_HV:
  75                         hw->mac.type = I40E_MAC_VF;
  76                         break;
  77                 default:
  78                         hw->mac.type = I40E_MAC_GENERIC;
  79                         break;
  80                 }
  81         } else {
  82                 status = I40E_ERR_DEVICE_NOT_SUPPORTED;
  83         }
  84
  85         DEBUGOUT2("i40e_set_mac_type found mac: %d, returns: %d\n",
  86                   hw->mac.type, status);
  87         return status;
  88 }
  89
  90 #ifndef I40E_NDIS_SUPPORT
  91 /**
  92  * i40e_aq_str - convert AQ err code to a string
  93  * @hw: pointer to the HW structure
  94  * @aq_err: the AQ error code to convert
  95  **/
  96 const char *i40e_aq_str(struct i40e_hw *hw, enum i40e_admin_queue_err aq_err)
  97 {
  98         switch (aq_err) {
  99         case I40E_AQ_RC_OK:
 100                 return "OK";
 101         case I40E_AQ_RC_EPERM:
 102                 return "I40E_AQ_RC_EPERM";
 103         case I40E_AQ_RC_ENOENT:
 104                 return "I40E_AQ_RC_ENOENT";
 105         case I40E_AQ_RC_ESRCH:
 106                 return "I40E_AQ_RC_ESRCH";
 107         case I40E_AQ_RC_EINTR:
 108                 return "I40E_AQ_RC_EINTR";
 109         case I40E_AQ_RC_EIO:
 110                 return "I40E_AQ_RC_EIO";
 111         case I40E_AQ_RC_ENXIO:
 112                 return "I40E_AQ_RC_ENXIO";
 113         case I40E_AQ_RC_E2BIG:
 114                 return "I40E_AQ_RC_E2BIG";
 115         case I40E_AQ_RC_EAGAIN:
 116                 return "I40E_AQ_RC_EAGAIN";
 117         case I40E_AQ_RC_ENOMEM:
 118                 return "I40E_AQ_RC_ENOMEM";
 119         case I40E_AQ_RC_EACCES:
 120                 return "I40E_AQ_RC_EACCES";
 121         case I40E_AQ_RC_EFAULT:
 122                 return "I40E_AQ_RC_EFAULT";
 123         case I40E_AQ_RC_EBUSY:
 124                 return "I40E_AQ_RC_EBUSY";
 125         case I40E_AQ_RC_EEXIST:
 126                 return "I40E_AQ_RC_EEXIST";
 127         case I40E_AQ_RC_EINVAL:
 128                 return "I40E_AQ_RC_EINVAL";
 129         case I40E_AQ_RC_ENOTTY:
 130                 return "I40E_AQ_RC_ENOTTY";
 131         case I40E_AQ_RC_ENOSPC:
 132                 return "I40E_AQ_RC_ENOSPC";
 133         case I40E_AQ_RC_ENOSYS:
 134                 return "I40E_AQ_RC_ENOSYS";
 135         case I40E_AQ_RC_ERANGE:
 136                 return "I40E_AQ_RC_ERANGE";
 137         case I40E_AQ_RC_EFLUSHED:
 138                 return "I40E_AQ_RC_EFLUSHED";
 139         case I40E_AQ_RC_BAD_ADDR:
 140                 return "I40E_AQ_RC_BAD_ADDR";
 141         case I40E_AQ_RC_EMODE:
 142                 return "I40E_AQ_RC_EMODE";
 143         case I40E_AQ_RC_EFBIG:
 144                 return "I40E_AQ_RC_EFBIG";
 145         }
 146
 147         snprintf(hw->err_str, sizeof(hw->err_str), "%d", aq_err);
 148         return hw->err_str;
 149 }
 150
 151 /**
 152  * i40e_stat_str - convert status err code to a string
 153  * @hw: pointer to the HW structure
 154  * @stat_err: the status error code to convert
 155  **/
 156 const char *i40e_stat_str(struct i40e_hw *hw, enum i40e_status_code stat_err)
 157 {
 158         switch (stat_err) {
 159         case I40E_SUCCESS:
 160                 return "OK";
 161         case I40E_ERR_NVM:
 162                 return "I40E_ERR_NVM";
 163         case I40E_ERR_NVM_CHECKSUM:
 164                 return "I40E_ERR_NVM_CHECKSUM";
 165         case I40E_ERR_PHY:
 166                 return "I40E_ERR_PHY";
 167         case I40E_ERR_CONFIG:
 168                 return "I40E_ERR_CONFIG";
 169         case I40E_ERR_PARAM:
 170                 return "I40E_ERR_PARAM";
 171         case I40E_ERR_MAC_TYPE:
 172                 return "I40E_ERR_MAC_TYPE";
 173         case I40E_ERR_UNKNOWN_PHY:
 174                 return "I40E_ERR_UNKNOWN_PHY";
 175         case I40E_ERR_LINK_SETUP:
 176                 return "I40E_ERR_LINK_SETUP";
 177         case I40E_ERR_ADAPTER_STOPPED:
 178                 return "I40E_ERR_ADAPTER_STOPPED";
 179         case I40E_ERR_INVALID_MAC_ADDR:
 180                 return "I40E_ERR_INVALID_MAC_ADDR";
 181         case I40E_ERR_DEVICE_NOT_SUPPORTED:
 182                 return "I40E_ERR_DEVICE_NOT_SUPPORTED";
 183         case I40E_ERR_MASTER_REQUESTS_PENDING:
 184                 return "I40E_ERR_MASTER_REQUESTS_PENDING";
 185         case I40E_ERR_INVALID_LINK_SETTINGS:
 186                 return "I40E_ERR_INVALID_LINK_SETTINGS";
 187         case I40E_ERR_AUTONEG_NOT_COMPLETE:
 188                 return "I40E_ERR_AUTONEG_NOT_COMPLETE";
 189         case I40E_ERR_RESET_FAILED:
 190                 return "I40E_ERR_RESET_FAILED";
 191         case I40E_ERR_SWFW_SYNC:
 192                 return "I40E_ERR_SWFW_SYNC";
 193         case I40E_ERR_NO_AVAILABLE_VSI:
 194                 return "I40E_ERR_NO_AVAILABLE_VSI";
 195         case I40E_ERR_NO_MEMORY:
 196                 return "I40E_ERR_NO_MEMORY";
 197         case I40E_ERR_BAD_PTR:
 198                 return "I40E_ERR_BAD_PTR";
 199         case I40E_ERR_RING_FULL:
 200                 return "I40E_ERR_RING_FULL";
 201         case I40E_ERR_INVALID_PD_ID:
 202                 return "I40E_ERR_INVALID_PD_ID";
 203         case I40E_ERR_INVALID_QP_ID:
 204                 return "I40E_ERR_INVALID_QP_ID";
 205         case I40E_ERR_INVALID_CQ_ID:
 206                 return "I40E_ERR_INVALID_CQ_ID";
 207         case I40E_ERR_INVALID_CEQ_ID:
 208                 return "I40E_ERR_INVALID_CEQ_ID";
 209         case I40E_ERR_INVALID_AEQ_ID:
 210                 return "I40E_ERR_INVALID_AEQ_ID";
 211         case I40E_ERR_INVALID_SIZE:
 212                 return "I40E_ERR_INVALID_SIZE";
 213         case I40E_ERR_INVALID_ARP_INDEX:
 214                 return "I40E_ERR_INVALID_ARP_INDEX";
 215         case I40E_ERR_INVALID_FPM_FUNC_ID:
 216                 return "I40E_ERR_INVALID_FPM_FUNC_ID";
 217         case I40E_ERR_QP_INVALID_MSG_SIZE:
 218                 return "I40E_ERR_QP_INVALID_MSG_SIZE";
 219         case I40E_ERR_QP_TOOMANY_WRS_POSTED:
 220                 return "I40E_ERR_QP_TOOMANY_WRS_POSTED";
 221         case I40E_ERR_INVALID_FRAG_COUNT:
 222                 return "I40E_ERR_INVALID_FRAG_COUNT";
 223         case I40E_ERR_QUEUE_EMPTY:
 224                 return "I40E_ERR_QUEUE_EMPTY";
 225         case I40E_ERR_INVALID_ALIGNMENT:
 226                 return "I40E_ERR_INVALID_ALIGNMENT";
 227         case I40E_ERR_FLUSHED_QUEUE:
 228                 return "I40E_ERR_FLUSHED_QUEUE";
 229         case I40E_ERR_INVALID_PUSH_PAGE_INDEX:
 230                 return "I40E_ERR_INVALID_PUSH_PAGE_INDEX";
 231         case I40E_ERR_INVALID_IMM_DATA_SIZE:
 232                 return "I40E_ERR_INVALID_IMM_DATA_SIZE";
 233         case I40E_ERR_TIMEOUT:
 234                 return "I40E_ERR_TIMEOUT";
 235         case I40E_ERR_OPCODE_MISMATCH:
 236                 return "I40E_ERR_OPCODE_MISMATCH";
 237         case I40E_ERR_CQP_COMPL_ERROR:
 238                 return "I40E_ERR_CQP_COMPL_ERROR";
 239         case I40E_ERR_INVALID_VF_ID:
 240                 return "I40E_ERR_INVALID_VF_ID";
 241         case I40E_ERR_INVALID_HMCFN_ID:
 242                 return "I40E_ERR_INVALID_HMCFN_ID";
 243         case I40E_ERR_BACKING_PAGE_ERROR:
 244                 return "I40E_ERR_BACKING_PAGE_ERROR";
 245         case I40E_ERR_NO_PBLCHUNKS_AVAILABLE:
 246                 return "I40E_ERR_NO_PBLCHUNKS_AVAILABLE";
 247         case I40E_ERR_INVALID_PBLE_INDEX:
 248                 return "I40E_ERR_INVALID_PBLE_INDEX";
 249         case I40E_ERR_INVALID_SD_INDEX:
 250                 return "I40E_ERR_INVALID_SD_INDEX";
 251         case I40E_ERR_INVALID_PAGE_DESC_INDEX:
 252                 return "I40E_ERR_INVALID_PAGE_DESC_INDEX";
 253         case I40E_ERR_INVALID_SD_TYPE:
 254                 return "I40E_ERR_INVALID_SD_TYPE";
 255         case I40E_ERR_MEMCPY_FAILED:
 256                 return "I40E_ERR_MEMCPY_FAILED";
 257         case I40E_ERR_INVALID_HMC_OBJ_INDEX:
 258                 return "I40E_ERR_INVALID_HMC_OBJ_INDEX";
 259         case I40E_ERR_INVALID_HMC_OBJ_COUNT:
 260                 return "I40E_ERR_INVALID_HMC_OBJ_COUNT";
 261         case I40E_ERR_INVALID_SRQ_ARM_LIMIT:
 262                 return "I40E_ERR_INVALID_SRQ_ARM_LIMIT";
 263         case I40E_ERR_SRQ_ENABLED:
 264                 return "I40E_ERR_SRQ_ENABLED";
 265         case I40E_ERR_ADMIN_QUEUE_ERROR:
 266                 return "I40E_ERR_ADMIN_QUEUE_ERROR";
 267         case I40E_ERR_ADMIN_QUEUE_TIMEOUT:
 268                 return "I40E_ERR_ADMIN_QUEUE_TIMEOUT";
 269         case I40E_ERR_BUF_TOO_SHORT:
 270                 return "I40E_ERR_BUF_TOO_SHORT";
 271         case I40E_ERR_ADMIN_QUEUE_FULL:
 272                 return "I40E_ERR_ADMIN_QUEUE_FULL";
 273         case I40E_ERR_ADMIN_QUEUE_NO_WORK:
 274                 return "I40E_ERR_ADMIN_QUEUE_NO_WORK";
 275         case I40E_ERR_BAD_IWARP_CQE:
 276                 return "I40E_ERR_BAD_IWARP_CQE";
 277         case I40E_ERR_NVM_BLANK_MODE:
 278                 return "I40E_ERR_NVM_BLANK_MODE";
 279         case I40E_ERR_NOT_IMPLEMENTED:
 280                 return "I40E_ERR_NOT_IMPLEMENTED";
 281         case I40E_ERR_PE_DOORBELL_NOT_ENABLED:
 282                 return "I40E_ERR_PE_DOORBELL_NOT_ENABLED";
 283         case I40E_ERR_DIAG_TEST_FAILED:
 284                 return "I40E_ERR_DIAG_TEST_FAILED";
 285         case I40E_ERR_NOT_READY:
 286                 return "I40E_ERR_NOT_READY";
 287         case I40E_NOT_SUPPORTED:
 288                 return "I40E_NOT_SUPPORTED";
 289         case I40E_ERR_FIRMWARE_API_VERSION:
 290                 return "I40E_ERR_FIRMWARE_API_VERSION";
 291         }
 292
 293         snprintf(hw->err_str, sizeof(hw->err_str), "%d", stat_err);
 294         return hw->err_str;
 295 }
 296
 297 #endif /* I40E_NDIS_SUPPORT */
 298 /**
 299  * i40e_debug_aq
 300  * @hw: debug mask related to admin queue
 301  * @mask: debug mask
 302  * @desc: pointer to admin queue descriptor
 303  * @buffer: pointer to command buffer
 304  * @buf_len: max length of buffer
 305  *
 306  * Dumps debug log about adminq command with descriptor contents.
 307  **/
 308 void i40e_debug_aq(struct i40e_hw *hw, enum i40e_debug_mask mask, void *desc,
 309                    void *buffer, u16 buf_len)
 310 {
 311         struct i40e_aq_desc *aq_desc = (struct i40e_aq_desc *)desc;
 312         u16 len = LE16_TO_CPU(aq_desc->datalen);
 313         u8 *buf = (u8 *)buffer;
 314         u16 i = 0;
 315
 316         if ((!(mask & hw->debug_mask)) || (desc == NULL))
 317                 return;
 318
 319         i40e_debug(hw, mask,
 320                    "AQ CMD: opcode 0x%04X, flags 0x%04X, datalen 0x%04X, retval 0x%04X\n",
 321                    LE16_TO_CPU(aq_desc->opcode),
 322                    LE16_TO_CPU(aq_desc->flags),
 323                    LE16_TO_CPU(aq_desc->datalen),
 324                    LE16_TO_CPU(aq_desc->retval));
 325         i40e_debug(hw, mask, "\tcookie (h,l) 0x%08X 0x%08X\n",
 326                    LE32_TO_CPU(aq_desc->cookie_high),
 327                    LE32_TO_CPU(aq_desc->cookie_low));
 328         i40e_debug(hw, mask, "\tparam (0,1)  0x%08X 0x%08X\n",
 329                    LE32_TO_CPU(aq_desc->params.internal.param0),
 330                    LE32_TO_CPU(aq_desc->params.internal.param1));
 331         i40e_debug(hw, mask, "\taddr (h,l)   0x%08X 0x%08X\n",
 332                    LE32_TO_CPU(aq_desc->params.external.addr_high),
 333                    LE32_TO_CPU(aq_desc->params.external.addr_low));
 334
 335         if ((buffer != NULL) && (aq_desc->datalen != 0)) {
 336                 i40e_debug(hw, mask, "AQ CMD Buffer:\n");
 337                 if (buf_len < len)
 338                         len = buf_len;
 339                 /* write the full 16-byte chunks */
 340                 for (i = 0; i < (len - 16); i += 16)
 341                         i40e_debug(hw, mask,
 342                                    "\t0x%04X  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
 343                                    i, buf[i], buf[i+1], buf[i+2], buf[i+3],
 344                                    buf[i+4], buf[i+5], buf[i+6], buf[i+7],
 345                                    buf[i+8], buf[i+9], buf[i+10], buf[i+11],
 346                                    buf[i+12], buf[i+13], buf[i+14], buf[i+15]);
 347                 /* the most we could have left is 16 bytes, pad with zeros */
 348                 if (i < len) {
 349                         char d_buf[16];
 350                         int j;
 351
 352                         memset(d_buf, 0, sizeof(d_buf));
 353                         for (j = 0; i < len; j++, i++)
 354                                 d_buf[j] = buf[i];
 355                         i40e_debug(hw, mask,
 356                                    "\t0x%04X  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
 357                                    i, d_buf[0], d_buf[1], d_buf[2], d_buf[3],
 358                                    d_buf[4], d_buf[5], d_buf[6], d_buf[7],
 359                                    d_buf[8], d_buf[9], d_buf[10], d_buf[11],
 360                                    d_buf[12], d_buf[13], d_buf[14], d_buf[15]);
 361                 }
 362         }
 363 }
 364
 365 /**
 366  * i40e_check_asq_alive
 367  * @hw: pointer to the hw struct
 368  *
 369  * Returns true if Queue is enabled else false.
 370  **/
 371 bool i40e_check_asq_alive(struct i40e_hw *hw)
 372 {
 373         if (hw->aq.asq.len)
 374                 return !!(rd32(hw, hw->aq.asq.len) & I40E_PF_ATQLEN_ATQENABLE_MASK);
 375         else
 376                 return false;
 377 }
 378
 379 /**
 380  * i40e_aq_queue_shutdown
 381  * @hw: pointer to the hw struct
 382  * @unloading: is the driver unloading itself
 383  *
 384  * Tell the Firmware that we're shutting down the AdminQ and whether
 385  * or not the driver is unloading as well.
 386  **/
 387 enum i40e_status_code i40e_aq_queue_shutdown(struct i40e_hw *hw,
 388                                              bool unloading)
 389 {
 390         struct i40e_aq_desc desc;
 391         struct i40e_aqc_queue_shutdown *cmd =
 392                 (struct i40e_aqc_queue_shutdown *)&desc.params.raw;
 393         enum i40e_status_code status;
 394
 395         i40e_fill_default_direct_cmd_desc(&desc,
 396                                           i40e_aqc_opc_queue_shutdown);
 397
 398         if (unloading)
 399                 cmd->driver_unloading = CPU_TO_LE32(I40E_AQ_DRIVER_UNLOADING);
 400         status = i40e_asq_send_command(hw, &desc, NULL, 0, NULL);
 401
 402         return status;
 403 }
 404
 405 /* The i40e_ptype_lookup table is used to convert from the 8-bit ptype in the
 406  * hardware to a bit-field that can be used by SW to more easily determine the
 407  * packet type.
 408  *
 409  * Macros are used to shorten the table lines and make this table human
 410  * readable.
 411  *
 412  * We store the PTYPE in the top byte of the bit field - this is just so that
 413  * we can check that the table doesn't have a row missing, as the index into
 414  * the table should be the PTYPE.
 415  *
 416  * Typical work flow:
 417  *
 418  * IF NOT i40e_ptype_lookup[ptype].known
 419  * THEN
 420  *      Packet is unknown
 421  * ELSE IF i40e_ptype_lookup[ptype].outer_ip == I40E_RX_PTYPE_OUTER_IP
 422  *      Use the rest of the fields to look at the tunnels, inner protocols, etc
 423  * ELSE
 424  *      Use the enum i40e_rx_l2_ptype to decode the packet type
 425  * ENDIF
 426  */
 427
 428 /* macro to make the table lines short */
 429 #define I40E_PTT(PTYPE, OUTER_IP, OUTER_IP_VER, OUTER_FRAG, T, TE, TEF, I, PL)\
 430         {       PTYPE, \
 431                 1, \
 432                 I40E_RX_PTYPE_OUTER_##OUTER_IP, \
 433                 I40E_RX_PTYPE_OUTER_##OUTER_IP_VER, \
 434                 I40E_RX_PTYPE_##OUTER_FRAG, \
 435                 I40E_RX_PTYPE_TUNNEL_##T, \
 436                 I40E_RX_PTYPE_TUNNEL_END_##TE, \
 437                 I40E_RX_PTYPE_##TEF, \
 438                 I40E_RX_PTYPE_INNER_PROT_##I, \
 439                 I40E_RX_PTYPE_PAYLOAD_LAYER_##PL }
 440
 441 #define I40E_PTT_UNUSED_ENTRY(PTYPE) \
 442                 { PTYPE, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 443
 444 /* shorter macros makes the table fit but are terse */
 445 #define I40E_RX_PTYPE_NOF               I40E_RX_PTYPE_NOT_FRAG
 446 #define I40E_RX_PTYPE_FRG               I40E_RX_PTYPE_FRAG
 447 #define I40E_RX_PTYPE_INNER_PROT_TS     I40E_RX_PTYPE_INNER_PROT_TIMESYNC
 448
 449 /* Lookup table mapping the HW PTYPE to the bit field for decoding */
 450 struct i40e_rx_ptype_decoded i40e_ptype_lookup[] = {
 451         /* L2 Packet types */
 452         I40E_PTT_UNUSED_ENTRY(0),
 453         I40E_PTT(1,  L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
 454         I40E_PTT(2,  L2, NONE, NOF, NONE, NONE, NOF, TS,   PAY2),
 455         I40E_PTT(3,  L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
 456         I40E_PTT_UNUSED_ENTRY(4),
 457         I40E_PTT_UNUSED_ENTRY(5),
 458         I40E_PTT(6,  L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
 459         I40E_PTT(7,  L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
 460         I40E_PTT_UNUSED_ENTRY(8),
 461         I40E_PTT_UNUSED_ENTRY(9),
 462         I40E_PTT(10, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2),
 463         I40E_PTT(11, L2, NONE, NOF, NONE, NONE, NOF, NONE, NONE),
 464         I40E_PTT(12, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 465         I40E_PTT(13, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 466         I40E_PTT(14, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 467         I40E_PTT(15, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 468         I40E_PTT(16, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 469         I40E_PTT(17, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 470         I40E_PTT(18, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 471         I40E_PTT(19, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 472         I40E_PTT(20, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 473         I40E_PTT(21, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY3),
 474
 475         /* Non Tunneled IPv4 */
 476         I40E_PTT(22, IP, IPV4, FRG, NONE, NONE, NOF, NONE, PAY3),
 477         I40E_PTT(23, IP, IPV4, NOF, NONE, NONE, NOF, NONE, PAY3),
 478         I40E_PTT(24, IP, IPV4, NOF, NONE, NONE, NOF, UDP,  PAY4),
 479         I40E_PTT_UNUSED_ENTRY(25),
 480         I40E_PTT(26, IP, IPV4, NOF, NONE, NONE, NOF, TCP,  PAY4),
 481         I40E_PTT(27, IP, IPV4, NOF, NONE, NONE, NOF, SCTP, PAY4),
 482         I40E_PTT(28, IP, IPV4, NOF, NONE, NONE, NOF, ICMP, PAY4),
 483
 484         /* IPv4 --> IPv4 */
 485         I40E_PTT(29, IP, IPV4, NOF, IP_IP, IPV4, FRG, NONE, PAY3),
 486         I40E_PTT(30, IP, IPV4, NOF, IP_IP, IPV4, NOF, NONE, PAY3),
 487         I40E_PTT(31, IP, IPV4, NOF, IP_IP, IPV4, NOF, UDP,  PAY4),
 488         I40E_PTT_UNUSED_ENTRY(32),
 489         I40E_PTT(33, IP, IPV4, NOF, IP_IP, IPV4, NOF, TCP,  PAY4),
 490         I40E_PTT(34, IP, IPV4, NOF, IP_IP, IPV4, NOF, SCTP, PAY4),
 491         I40E_PTT(35, IP, IPV4, NOF, IP_IP, IPV4, NOF, ICMP, PAY4),
 492
 493         /* IPv4 --> IPv6 */
 494         I40E_PTT(36, IP, IPV4, NOF, IP_IP, IPV6, FRG, NONE, PAY3),
 495         I40E_PTT(37, IP, IPV4, NOF, IP_IP, IPV6, NOF, NONE, PAY3),
 496         I40E_PTT(38, IP, IPV4, NOF, IP_IP, IPV6, NOF, UDP,  PAY4),
 497         I40E_PTT_UNUSED_ENTRY(39),
 498         I40E_PTT(40, IP, IPV4, NOF, IP_IP, IPV6, NOF, TCP,  PAY4),
 499         I40E_PTT(41, IP, IPV4, NOF, IP_IP, IPV6, NOF, SCTP, PAY4),
 500         I40E_PTT(42, IP, IPV4, NOF, IP_IP, IPV6, NOF, ICMP, PAY4),
 501
 502         /* IPv4 --> GRE/NAT */
 503         I40E_PTT(43, IP, IPV4, NOF, IP_GRENAT, NONE, NOF, NONE, PAY3),
 504
 505         /* IPv4 --> GRE/NAT --> IPv4 */
 506         I40E_PTT(44, IP, IPV4, NOF, IP_GRENAT, IPV4, FRG, NONE, PAY3),
 507         I40E_PTT(45, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, NONE, PAY3),
 508         I40E_PTT(46, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, UDP,  PAY4),
 509         I40E_PTT_UNUSED_ENTRY(47),
 510         I40E_PTT(48, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, TCP,  PAY4),
 511         I40E_PTT(49, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, SCTP, PAY4),
 512         I40E_PTT(50, IP, IPV4, NOF, IP_GRENAT, IPV4, NOF, ICMP, PAY4),
 513
 514         /* IPv4 --> GRE/NAT --> IPv6 */
 515         I40E_PTT(51, IP, IPV4, NOF, IP_GRENAT, IPV6, FRG, NONE, PAY3),
 516         I40E_PTT(52, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, NONE, PAY3),
 517         I40E_PTT(53, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, UDP,  PAY4),
 518         I40E_PTT_UNUSED_ENTRY(54),
 519         I40E_PTT(55, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, TCP,  PAY4),
 520         I40E_PTT(56, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, SCTP, PAY4),
 521         I40E_PTT(57, IP, IPV4, NOF, IP_GRENAT, IPV6, NOF, ICMP, PAY4),
 522
 523         /* IPv4 --> GRE/NAT --> MAC */
 524         I40E_PTT(58, IP, IPV4, NOF, IP_GRENAT_MAC, NONE, NOF, NONE, PAY3),
 525
 526         /* IPv4 --> GRE/NAT --> MAC --> IPv4 */
 527         I40E_PTT(59, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, FRG, NONE, PAY3),
 528         I40E_PTT(60, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, NONE, PAY3),
 529         I40E_PTT(61, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, UDP,  PAY4),
 530         I40E_PTT_UNUSED_ENTRY(62),
 531         I40E_PTT(63, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, TCP,  PAY4),
 532         I40E_PTT(64, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, SCTP, PAY4),
 533         I40E_PTT(65, IP, IPV4, NOF, IP_GRENAT_MAC, IPV4, NOF, ICMP, PAY4),
 534
 535         /* IPv4 --> GRE/NAT -> MAC --> IPv6 */
 536         I40E_PTT(66, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, FRG, NONE, PAY3),
 537         I40E_PTT(67, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, NONE, PAY3),
 538         I40E_PTT(68, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, UDP,  PAY4),
 539         I40E_PTT_UNUSED_ENTRY(69),
 540         I40E_PTT(70, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, TCP,  PAY4),
 541         I40E_PTT(71, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, SCTP, PAY4),
 542         I40E_PTT(72, IP, IPV4, NOF, IP_GRENAT_MAC, IPV6, NOF, ICMP, PAY4),
 543
 544         /* IPv4 --> GRE/NAT --> MAC/VLAN */
 545         I40E_PTT(73, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, NONE, NOF, NONE, PAY3),
 546
 547         /* IPv4 ---> GRE/NAT -> MAC/VLAN --> IPv4 */
 548         I40E_PTT(74, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, FRG, NONE, PAY3),
 549         I40E_PTT(75, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, NONE, PAY3),
 550         I40E_PTT(76, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, UDP,  PAY4),
 551         I40E_PTT_UNUSED_ENTRY(77),
 552         I40E_PTT(78, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, TCP,  PAY4),
 553         I40E_PTT(79, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, SCTP, PAY4),
 554         I40E_PTT(80, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, ICMP, PAY4),
 555
 556         /* IPv4 -> GRE/NAT -> MAC/VLAN --> IPv6 */
 557         I40E_PTT(81, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, FRG, NONE, PAY3),
 558         I40E_PTT(82, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, NONE, PAY3),
 559         I40E_PTT(83, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, UDP,  PAY4),
 560         I40E_PTT_UNUSED_ENTRY(84),
 561         I40E_PTT(85, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, TCP,  PAY4),
 562         I40E_PTT(86, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, SCTP, PAY4),
 563         I40E_PTT(87, IP, IPV4, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, ICMP, PAY4),
 564
 565         /* Non Tunneled IPv6 */
 566         I40E_PTT(88, IP, IPV6, FRG, NONE, NONE, NOF, NONE, PAY3),
 567         I40E_PTT(89, IP, IPV6, NOF, NONE, NONE, NOF, NONE, PAY3),
 568         I40E_PTT(90, IP, IPV6, NOF, NONE, NONE, NOF, UDP,  PAY3),
 569         I40E_PTT_UNUSED_ENTRY(91),
 570         I40E_PTT(92, IP, IPV6, NOF, NONE, NONE, NOF, TCP,  PAY4),
 571         I40E_PTT(93, IP, IPV6, NOF, NONE, NONE, NOF, SCTP, PAY4),
 572         I40E_PTT(94, IP, IPV6, NOF, NONE, NONE, NOF, ICMP, PAY4),
 573
 574         /* IPv6 --> IPv4 */
 575         I40E_PTT(95,  IP, IPV6, NOF, IP_IP, IPV4, FRG, NONE, PAY3),
 576         I40E_PTT(96,  IP, IPV6, NOF, IP_IP, IPV4, NOF, NONE, PAY3),
 577         I40E_PTT(97,  IP, IPV6, NOF, IP_IP, IPV4, NOF, UDP,  PAY4),
 578         I40E_PTT_UNUSED_ENTRY(98),
 579         I40E_PTT(99,  IP, IPV6, NOF, IP_IP, IPV4, NOF, TCP,  PAY4),
 580         I40E_PTT(100, IP, IPV6, NOF, IP_IP, IPV4, NOF, SCTP, PAY4),
 581         I40E_PTT(101, IP, IPV6, NOF, IP_IP, IPV4, NOF, ICMP, PAY4),
 582
 583         /* IPv6 --> IPv6 */
 584         I40E_PTT(102, IP, IPV6, NOF, IP_IP, IPV6, FRG, NONE, PAY3),
 585         I40E_PTT(103, IP, IPV6, NOF, IP_IP, IPV6, NOF, NONE, PAY3),
 586         I40E_PTT(104, IP, IPV6, NOF, IP_IP, IPV6, NOF, UDP,  PAY4),
 587         I40E_PTT_UNUSED_ENTRY(105),
 588         I40E_PTT(106, IP, IPV6, NOF, IP_IP, IPV6, NOF, TCP,  PAY4),
 589         I40E_PTT(107, IP, IPV6, NOF, IP_IP, IPV6, NOF, SCTP, PAY4),
 590         I40E_PTT(108, IP, IPV6, NOF, IP_IP, IPV6, NOF, ICMP, PAY4),
 591
 592         /* IPv6 --> GRE/NAT */
 593         I40E_PTT(109, IP, IPV6, NOF, IP_GRENAT, NONE, NOF, NONE, PAY3),
 594
 595         /* IPv6 --> GRE/NAT -> IPv4 */
 596         I40E_PTT(110, IP, IPV6, NOF, IP_GRENAT, IPV4, FRG, NONE, PAY3),
 597         I40E_PTT(111, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, NONE, PAY3),
 598         I40E_PTT(112, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, UDP,  PAY4),
 599         I40E_PTT_UNUSED_ENTRY(113),
 600         I40E_PTT(114, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, TCP,  PAY4),
 601         I40E_PTT(115, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, SCTP, PAY4),
 602         I40E_PTT(116, IP, IPV6, NOF, IP_GRENAT, IPV4, NOF, ICMP, PAY4),
 603
 604         /* IPv6 --> GRE/NAT -> IPv6 */
 605         I40E_PTT(117, IP, IPV6, NOF, IP_GRENAT, IPV6, FRG, NONE, PAY3),
 606         I40E_PTT(118, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, NONE, PAY3),
 607         I40E_PTT(119, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, UDP,  PAY4),
 608         I40E_PTT_UNUSED_ENTRY(120),
 609         I40E_PTT(121, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, TCP,  PAY4),
 610         I40E_PTT(122, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, SCTP, PAY4),
 611         I40E_PTT(123, IP, IPV6, NOF, IP_GRENAT, IPV6, NOF, ICMP, PAY4),
 612
 613         /* IPv6 --> GRE/NAT -> MAC */
 614         I40E_PTT(124, IP, IPV6, NOF, IP_GRENAT_MAC, NONE, NOF, NONE, PAY3),
 615
 616         /* IPv6 --> GRE/NAT -> MAC -> IPv4 */
 617         I40E_PTT(125, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, FRG, NONE, PAY3),
 618         I40E_PTT(126, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, NONE, PAY3),
 619         I40E_PTT(127, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, UDP,  PAY4),
 620         I40E_PTT_UNUSED_ENTRY(128),
 621         I40E_PTT(129, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, TCP,  PAY4),
 622         I40E_PTT(130, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, SCTP, PAY4),
 623         I40E_PTT(131, IP, IPV6, NOF, IP_GRENAT_MAC, IPV4, NOF, ICMP, PAY4),
 624
 625         /* IPv6 --> GRE/NAT -> MAC -> IPv6 */
 626         I40E_PTT(132, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, FRG, NONE, PAY3),
 627         I40E_PTT(133, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, NONE, PAY3),
 628         I40E_PTT(134, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, UDP,  PAY4),
 629         I40E_PTT_UNUSED_ENTRY(135),
 630         I40E_PTT(136, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, TCP,  PAY4),
 631         I40E_PTT(137, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, SCTP, PAY4),
 632         I40E_PTT(138, IP, IPV6, NOF, IP_GRENAT_MAC, IPV6, NOF, ICMP, PAY4),
 633
 634         /* IPv6 --> GRE/NAT -> MAC/VLAN */
 635         I40E_PTT(139, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, NONE, NOF, NONE, PAY3),
 636
 637         /* IPv6 --> GRE/NAT -> MAC/VLAN --> IPv4 */
 638         I40E_PTT(140, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, FRG, NONE, PAY3),
 639         I40E_PTT(141, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, NONE, PAY3),
 640         I40E_PTT(142, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, UDP,  PAY4),
 641         I40E_PTT_UNUSED_ENTRY(143),
 642         I40E_PTT(144, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, TCP,  PAY4),
 643         I40E_PTT(145, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, SCTP, PAY4),
 644         I40E_PTT(146, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV4, NOF, ICMP, PAY4),
 645
 646         /* IPv6 --> GRE/NAT -> MAC/VLAN --> IPv6 */
 647         I40E_PTT(147, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, FRG, NONE, PAY3),
 648         I40E_PTT(148, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, NONE, PAY3),
 649         I40E_PTT(149, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, UDP,  PAY4),
 650         I40E_PTT_UNUSED_ENTRY(150),
 651         I40E_PTT(151, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, TCP,  PAY4),
 652         I40E_PTT(152, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, SCTP, PAY4),
 653         I40E_PTT(153, IP, IPV6, NOF, IP_GRENAT_MAC_VLAN, IPV6, NOF, ICMP, PAY4),
 654
 655         /* unused entries */
 656         I40E_PTT_UNUSED_ENTRY(154),
 657         I40E_PTT_UNUSED_ENTRY(155),
 658         I40E_PTT_UNUSED_ENTRY(156),
 659         I40E_PTT_UNUSED_ENTRY(157),
 660         I40E_PTT_UNUSED_ENTRY(158),
 661         I40E_PTT_UNUSED_ENTRY(159),
 662
 663         I40E_PTT_UNUSED_ENTRY(160),
 664         I40E_PTT_UNUSED_ENTRY(161),
 665         I40E_PTT_UNUSED_ENTRY(162),
 666         I40E_PTT_UNUSED_ENTRY(163),
 667         I40E_PTT_UNUSED_ENTRY(164),
 668         I40E_PTT_UNUSED_ENTRY(165),
 669         I40E_PTT_UNUSED_ENTRY(166),
 670         I40E_PTT_UNUSED_ENTRY(167),
 671         I40E_PTT_UNUSED_ENTRY(168),
 672         I40E_PTT_UNUSED_ENTRY(169),
 673
 674         I40E_PTT_UNUSED_ENTRY(170),
 675         I40E_PTT_UNUSED_ENTRY(171),
 676         I40E_PTT_UNUSED_ENTRY(172),
 677         I40E_PTT_UNUSED_ENTRY(173),
 678         I40E_PTT_UNUSED_ENTRY(174),
 679         I40E_PTT_UNUSED_ENTRY(175),
 680         I40E_PTT_UNUSED_ENTRY(176),
 681         I40E_PTT_UNUSED_ENTRY(177),
 682         I40E_PTT_UNUSED_ENTRY(178),
 683         I40E_PTT_UNUSED_ENTRY(179),
 684
 685         I40E_PTT_UNUSED_ENTRY(180),
 686         I40E_PTT_UNUSED_ENTRY(181),
 687         I40E_PTT_UNUSED_ENTRY(182),
 688         I40E_PTT_UNUSED_ENTRY(183),
 689         I40E_PTT_UNUSED_ENTRY(184),
 690         I40E_PTT_UNUSED_ENTRY(185),
 691         I40E_PTT_UNUSED_ENTRY(186),
 692         I40E_PTT_UNUSED_ENTRY(187),
 693         I40E_PTT_UNUSED_ENTRY(188),
 694         I40E_PTT_UNUSED_ENTRY(189),
 695
 696         I40E_PTT_UNUSED_ENTRY(190),
 697         I40E_PTT_UNUSED_ENTRY(191),
 698         I40E_PTT_UNUSED_ENTRY(192),
 699         I40E_PTT_UNUSED_ENTRY(193),
 700         I40E_PTT_UNUSED_ENTRY(194),
 701         I40E_PTT_UNUSED_ENTRY(195),
 702         I40E_PTT_UNUSED_ENTRY(196),
 703         I40E_PTT_UNUSED_ENTRY(197),
 704         I40E_PTT_UNUSED_ENTRY(198),
 705         I40E_PTT_UNUSED_ENTRY(199),
 706
 707         I40E_PTT_UNUSED_ENTRY(200),
 708         I40E_PTT_UNUSED_ENTRY(201),
 709         I40E_PTT_UNUSED_ENTRY(202),
 710         I40E_PTT_UNUSED_ENTRY(203),
 711         I40E_PTT_UNUSED_ENTRY(204),
 712         I40E_PTT_UNUSED_ENTRY(205),
 713         I40E_PTT_UNUSED_ENTRY(206),
 714         I40E_PTT_UNUSED_ENTRY(207),
 715         I40E_PTT_UNUSED_ENTRY(208),
 716         I40E_PTT_UNUSED_ENTRY(209),
 717
 718         I40E_PTT_UNUSED_ENTRY(210),
 719         I40E_PTT_UNUSED_ENTRY(211),
 720         I40E_PTT_UNUSED_ENTRY(212),
 721         I40E_PTT_UNUSED_ENTRY(213),
 722         I40E_PTT_UNUSED_ENTRY(214),
 723         I40E_PTT_UNUSED_ENTRY(215),
 724         I40E_PTT_UNUSED_ENTRY(216),
 725         I40E_PTT_UNUSED_ENTRY(217),
 726         I40E_PTT_UNUSED_ENTRY(218),
 727         I40E_PTT_UNUSED_ENTRY(219),
 728
 729         I40E_PTT_UNUSED_ENTRY(220),
 730         I40E_PTT_UNUSED_ENTRY(221),
 731         I40E_PTT_UNUSED_ENTRY(222),
 732         I40E_PTT_UNUSED_ENTRY(223),
 733         I40E_PTT_UNUSED_ENTRY(224),
 734         I40E_PTT_UNUSED_ENTRY(225),
 735         I40E_PTT_UNUSED_ENTRY(226),
 736         I40E_PTT_UNUSED_ENTRY(227),
 737         I40E_PTT_UNUSED_ENTRY(228),
 738         I40E_PTT_UNUSED_ENTRY(229),
 739
 740         I40E_PTT_UNUSED_ENTRY(230),
 741         I40E_PTT_UNUSED_ENTRY(231),
 742         I40E_PTT_UNUSED_ENTRY(232),
 743         I40E_PTT_UNUSED_ENTRY(233),
 744         I40E_PTT_UNUSED_ENTRY(234),
 745         I40E_PTT_UNUSED_ENTRY(235),
 746         I40E_PTT_UNUSED_ENTRY(236),
 747         I40E_PTT_UNUSED_ENTRY(237),
 748         I40E_PTT_UNUSED_ENTRY(238),
 749         I40E_PTT_UNUSED_ENTRY(239),
 750
 751         I40E_PTT_UNUSED_ENTRY(240),
 752         I40E_PTT_UNUSED_ENTRY(241),
 753         I40E_PTT_UNUSED_ENTRY(242),
 754         I40E_PTT_UNUSED_ENTRY(243),
 755         I40E_PTT_UNUSED_ENTRY(244),
 756         I40E_PTT_UNUSED_ENTRY(245),
 757         I40E_PTT_UNUSED_ENTRY(246),
 758         I40E_PTT_UNUSED_ENTRY(247),
 759         I40E_PTT_UNUSED_ENTRY(248),
 760         I40E_PTT_UNUSED_ENTRY(249),
 761
 762         I40E_PTT_UNUSED_ENTRY(250),
 763         I40E_PTT_UNUSED_ENTRY(251),
 764         I40E_PTT_UNUSED_ENTRY(252),
 765         I40E_PTT_UNUSED_ENTRY(253),
 766         I40E_PTT_UNUSED_ENTRY(254),
 767         I40E_PTT_UNUSED_ENTRY(255)
 768 };
 769
 770
 771 /**
 772  * i40e_validate_mac_addr - Validate unicast MAC address
 773  * @mac_addr: pointer to MAC address
 774  *
 775  * Tests a MAC address to ensure it is a valid Individual Address
 776  **/
 777 enum i40e_status_code i40e_validate_mac_addr(u8 *mac_addr)
 778 {
 779         enum i40e_status_code status = I40E_SUCCESS;
 780
 781         DEBUGFUNC("i40e_validate_mac_addr");
 782
 783         /* Broadcast addresses ARE multicast addresses
 784          * Make sure it is not a multicast address
 785          * Reject the zero address
 786          */
 787         if (I40E_IS_MULTICAST(mac_addr) ||
 788             (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
 789               mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0))
 790                 status = I40E_ERR_INVALID_MAC_ADDR;
 791
 792         return status;
 793 }
 794 #ifdef PF_DRIVER
 795
 796 /**
 797  * i40e_init_shared_code - Initialize the shared code
 798  * @hw: pointer to hardware structure
 799  *
 800  * This assigns the MAC type and PHY code and inits the NVM.
 801  * Does not touch the hardware. This function must be called prior to any
 802  * other function in the shared code. The i40e_hw structure should be
 803  * memset to 0 prior to calling this function.  The following fields in
 804  * hw structure should be filled in prior to calling this function:
 805  * hw_addr, back, device_id, vendor_id, subsystem_device_id,
 806  * subsystem_vendor_id, and revision_id
 807  **/
 808 enum i40e_status_code i40e_init_shared_code(struct i40e_hw *hw)
 809 {
 810         enum i40e_status_code status = I40E_SUCCESS;
 811         u32 port, ari, func_rid;
 812
 813         DEBUGFUNC("i40e_init_shared_code");
 814
 815         i40e_set_mac_type(hw);
 816
 817         switch (hw->mac.type) {
 818         case I40E_MAC_XL710:
 819                 break;
 820         default:
 821                 return I40E_ERR_DEVICE_NOT_SUPPORTED;
 822         }
 823
 824         hw->phy.get_link_info = true;
 825
 826         /* Determine port number and PF number*/
 827         port = (rd32(hw, I40E_PFGEN_PORTNUM) & I40E_PFGEN_PORTNUM_PORT_NUM_MASK)
 828                                            >> I40E_PFGEN_PORTNUM_PORT_NUM_SHIFT;
 829         hw->port = (u8)port;
 830         ari = (rd32(hw, I40E_GLPCI_CAPSUP) & I40E_GLPCI_CAPSUP_ARI_EN_MASK) >>
 831                                                  I40E_GLPCI_CAPSUP_ARI_EN_SHIFT;
 832         func_rid = rd32(hw, I40E_PF_FUNC_RID);
 833         if (ari)
 834                 hw->pf_id = (u8)(func_rid & 0xff);
 835         else
 836                 hw->pf_id = (u8)(func_rid & 0x7);
 837
 838         status = i40e_init_nvm(hw);
 839         return status;
 840 }
 841
 842 /**
 843  * i40e_aq_mac_address_read - Retrieve the MAC addresses
 844  * @hw: pointer to the hw struct
 845  * @flags: a return indicator of what addresses were added to the addr store
 846  * @addrs: the requestor's mac addr store
 847  * @cmd_details: pointer to command details structure or NULL
 848  **/
 849 STATIC enum i40e_status_code i40e_aq_mac_address_read(struct i40e_hw *hw,
 850                                    u16 *flags,
 851                                    struct i40e_aqc_mac_address_read_data *addrs,
 852                                    struct i40e_asq_cmd_details *cmd_details)
 853 {
 854         struct i40e_aq_desc desc;
 855         struct i40e_aqc_mac_address_read *cmd_data =
 856                 (struct i40e_aqc_mac_address_read *)&desc.params.raw;
 857         enum i40e_status_code status;
 858
 859         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_mac_address_read);
 860         desc.flags |= CPU_TO_LE16(I40E_AQ_FLAG_BUF);
 861
 862         status = i40e_asq_send_command(hw, &desc, addrs,
 863                                        sizeof(*addrs), cmd_details);
 864         *flags = LE16_TO_CPU(cmd_data->command_flags);
 865
 866         return status;
 867 }
 868
 869 /**
 870  * i40e_aq_mac_address_write - Change the MAC addresses
 871  * @hw: pointer to the hw struct
 872  * @flags: indicates which MAC to be written
 873  * @mac_addr: address to write
 874  * @cmd_details: pointer to command details structure or NULL
 875  **/
 876 enum i40e_status_code i40e_aq_mac_address_write(struct i40e_hw *hw,
 877                                     u16 flags, u8 *mac_addr,
 878                                     struct i40e_asq_cmd_details *cmd_details)
 879 {
 880         struct i40e_aq_desc desc;
 881         struct i40e_aqc_mac_address_write *cmd_data =
 882                 (struct i40e_aqc_mac_address_write *)&desc.params.raw;
 883         enum i40e_status_code status;
 884
 885         i40e_fill_default_direct_cmd_desc(&desc,
 886                                           i40e_aqc_opc_mac_address_write);
 887         cmd_data->command_flags = CPU_TO_LE16(flags);
 888         cmd_data->mac_sah = CPU_TO_LE16((u16)mac_addr[0] << 8 | mac_addr[1]);
 889         cmd_data->mac_sal = CPU_TO_LE32(((u32)mac_addr[2] << 24) |
 890                                         ((u32)mac_addr[3] << 16) |
 891                                         ((u32)mac_addr[4] << 8) |
 892                                         mac_addr[5]);
 893
 894         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
 895
 896         return status;
 897 }
 898
 899 /**
 900  * i40e_get_mac_addr - get MAC address
 901  * @hw: pointer to the HW structure
 902  * @mac_addr: pointer to MAC address
 903  *
 904  * Reads the adapter's MAC address from register
 905  **/
 906 enum i40e_status_code i40e_get_mac_addr(struct i40e_hw *hw, u8 *mac_addr)
 907 {
 908         struct i40e_aqc_mac_address_read_data addrs;
 909         enum i40e_status_code status;
 910         u16 flags = 0;
 911
 912         status = i40e_aq_mac_address_read(hw, &flags, &addrs, NULL);
 913
 914         if (flags & I40E_AQC_LAN_ADDR_VALID)
 915                 memcpy(mac_addr, &addrs.pf_lan_mac, sizeof(addrs.pf_lan_mac));
 916
 917         return status;
 918 }
 919
 920 /**
 921  * i40e_get_port_mac_addr - get Port MAC address
 922  * @hw: pointer to the HW structure
 923  * @mac_addr: pointer to Port MAC address
 924  *
 925  * Reads the adapter's Port MAC address
 926  **/
 927 enum i40e_status_code i40e_get_port_mac_addr(struct i40e_hw *hw, u8 *mac_addr)
 928 {
 929         struct i40e_aqc_mac_address_read_data addrs;
 930         enum i40e_status_code status;
 931         u16 flags = 0;
 932
 933         status = i40e_aq_mac_address_read(hw, &flags, &addrs, NULL);
 934         if (status)
 935                 return status;
 936
 937         if (flags & I40E_AQC_PORT_ADDR_VALID)
 938                 memcpy(mac_addr, &addrs.port_mac, sizeof(addrs.port_mac));
 939         else
 940                 status = I40E_ERR_INVALID_MAC_ADDR;
 941
 942         return status;
 943 }
 944
 945 /**
 946  * i40e_pre_tx_queue_cfg - pre tx queue configure
 947  * @hw: pointer to the HW structure
 948  * @queue: target pf queue index
 949  * @enable: state change request
 950  *
 951  * Handles hw requirement to indicate intention to enable
 952  * or disable target queue.
 953  **/
 954 void i40e_pre_tx_queue_cfg(struct i40e_hw *hw, u32 queue, bool enable)
 955 {
 956         u32 abs_queue_idx = hw->func_caps.base_queue + queue;
 957         u32 reg_block = 0;
 958         u32 reg_val;
 959
 960         if (abs_queue_idx >= 128) {
 961                 reg_block = abs_queue_idx / 128;
 962                 abs_queue_idx %= 128;
 963         }
 964
 965         reg_val = rd32(hw, I40E_GLLAN_TXPRE_QDIS(reg_block));
 966         reg_val &= ~I40E_GLLAN_TXPRE_QDIS_QINDX_MASK;
 967         reg_val |= (abs_queue_idx << I40E_GLLAN_TXPRE_QDIS_QINDX_SHIFT);
 968
 969         if (enable)
 970                 reg_val |= I40E_GLLAN_TXPRE_QDIS_CLEAR_QDIS_MASK;
 971         else
 972                 reg_val |= I40E_GLLAN_TXPRE_QDIS_SET_QDIS_MASK;
 973
 974         wr32(hw, I40E_GLLAN_TXPRE_QDIS(reg_block), reg_val);
 975 }
 976
 977 /**
 978  *  i40e_read_pba_string - Reads part number string from EEPROM
 979  *  @hw: pointer to hardware structure
 980  *  @pba_num: stores the part number string from the EEPROM
 981  *  @pba_num_size: part number string buffer length
 982  *
 983  *  Reads the part number string from the EEPROM.
 984  **/
 985 enum i40e_status_code i40e_read_pba_string(struct i40e_hw *hw, u8 *pba_num,
 986                                             u32 pba_num_size)
 987 {
 988         enum i40e_status_code status = I40E_SUCCESS;
 989         u16 pba_word = 0;
 990         u16 pba_size = 0;
 991         u16 pba_ptr = 0;
 992         u16 i = 0;
 993
 994         status = i40e_read_nvm_word(hw, I40E_SR_PBA_FLAGS, &pba_word);
 995         if ((status != I40E_SUCCESS) || (pba_word != 0xFAFA)) {
 996                 DEBUGOUT("Failed to read PBA flags or flag is invalid.\n");
 997                 return status;
 998         }
 999
1000         status = i40e_read_nvm_word(hw, I40E_SR_PBA_BLOCK_PTR, &pba_ptr);
1001         if (status != I40E_SUCCESS) {
1002                 DEBUGOUT("Failed to read PBA Block pointer.\n");
1003                 return status;
1004         }
1005
1006         status = i40e_read_nvm_word(hw, pba_ptr, &pba_size);
1007         if (status != I40E_SUCCESS) {
1008                 DEBUGOUT("Failed to read PBA Block size.\n");
1009                 return status;
1010         }
1011
1012         /* Subtract one to get PBA word count (PBA Size word is included in
1013          * total size)
1014          */
1015         pba_size--;
1016         if (pba_num_size < (((u32)pba_size * 2) + 1)) {
1017                 DEBUGOUT("Buffer to small for PBA data.\n");
1018                 return I40E_ERR_PARAM;
1019         }
1020
1021         for (i = 0; i < pba_size; i++) {
1022                 status = i40e_read_nvm_word(hw, (pba_ptr + 1) + i, &pba_word);
1023                 if (status != I40E_SUCCESS) {
1024                         DEBUGOUT1("Failed to read PBA Block word %d.\n", i);
1025                         return status;
1026                 }
1027
1028                 pba_num[(i * 2)] = (pba_word >> 8) & 0xFF;
1029                 pba_num[(i * 2) + 1] = pba_word & 0xFF;
1030         }
1031         pba_num[(pba_size * 2)] = '\0';
1032
1033         return status;
1034 }
1035
1036 /**
1037  * i40e_get_media_type - Gets media type
1038  * @hw: pointer to the hardware structure
1039  **/
1040 STATIC enum i40e_media_type i40e_get_media_type(struct i40e_hw *hw)
1041 {
1042         enum i40e_media_type media;
1043
1044         switch (hw->phy.link_info.phy_type) {
1045         case I40E_PHY_TYPE_10GBASE_SR:
1046         case I40E_PHY_TYPE_10GBASE_LR:
1047         case I40E_PHY_TYPE_1000BASE_SX:
1048         case I40E_PHY_TYPE_1000BASE_LX:
1049         case I40E_PHY_TYPE_40GBASE_SR4:
1050         case I40E_PHY_TYPE_40GBASE_LR4:
1051                 media = I40E_MEDIA_TYPE_FIBER;
1052                 break;
1053         case I40E_PHY_TYPE_100BASE_TX:
1054         case I40E_PHY_TYPE_1000BASE_T:
1055         case I40E_PHY_TYPE_10GBASE_T:
1056                 media = I40E_MEDIA_TYPE_BASET;
1057                 break;
1058         case I40E_PHY_TYPE_10GBASE_CR1_CU:
1059         case I40E_PHY_TYPE_40GBASE_CR4_CU:
1060         case I40E_PHY_TYPE_10GBASE_CR1:
1061         case I40E_PHY_TYPE_40GBASE_CR4:
1062         case I40E_PHY_TYPE_10GBASE_SFPP_CU:
1063         case I40E_PHY_TYPE_40GBASE_AOC:
1064         case I40E_PHY_TYPE_10GBASE_AOC:
1065                 media = I40E_MEDIA_TYPE_DA;
1066                 break;
1067         case I40E_PHY_TYPE_1000BASE_KX:
1068         case I40E_PHY_TYPE_10GBASE_KX4:
1069         case I40E_PHY_TYPE_10GBASE_KR:
1070         case I40E_PHY_TYPE_40GBASE_KR4:
1071         case I40E_PHY_TYPE_20GBASE_KR2:
1072                 media = I40E_MEDIA_TYPE_BACKPLANE;
1073                 break;
1074         case I40E_PHY_TYPE_SGMII:
1075         case I40E_PHY_TYPE_XAUI:
1076         case I40E_PHY_TYPE_XFI:
1077         case I40E_PHY_TYPE_XLAUI:
1078         case I40E_PHY_TYPE_XLPPI:
1079         default:
1080                 media = I40E_MEDIA_TYPE_UNKNOWN;
1081                 break;
1082         }
1083
1084         return media;
1085 }
1086
1087 #define I40E_PF_RESET_WAIT_COUNT        110
1088 /**
1089  * i40e_pf_reset - Reset the PF
1090  * @hw: pointer to the hardware structure
1091  *
1092  * Assuming someone else has triggered a global reset,
1093  * assure the global reset is complete and then reset the PF
1094  **/
1095 enum i40e_status_code i40e_pf_reset(struct i40e_hw *hw)
1096 {
1097         u32 cnt = 0;
1098         u32 cnt1 = 0;
1099         u32 reg = 0;
1100         u32 grst_del;
1101
1102         /* Poll for Global Reset steady state in case of recent GRST.
1103          * The grst delay value is in 100ms units, and we'll wait a
1104          * couple counts longer to be sure we don't just miss the end.
1105          */
1106         grst_del = (rd32(hw, I40E_GLGEN_RSTCTL) &
1107                         I40E_GLGEN_RSTCTL_GRSTDEL_MASK) >>
1108                         I40E_GLGEN_RSTCTL_GRSTDEL_SHIFT;
1109         for (cnt = 0; cnt < grst_del + 2; cnt++) {
1110                 reg = rd32(hw, I40E_GLGEN_RSTAT);
1111                 if (!(reg & I40E_GLGEN_RSTAT_DEVSTATE_MASK))
1112                         break;
1113                 i40e_msec_delay(100);
1114         }
1115         if (reg & I40E_GLGEN_RSTAT_DEVSTATE_MASK) {
1116                 DEBUGOUT("Global reset polling failed to complete.\n");
1117                 return I40E_ERR_RESET_FAILED;
1118         }
1119
1120         /* Now Wait for the FW to be ready */
1121         for (cnt1 = 0; cnt1 < I40E_PF_RESET_WAIT_COUNT; cnt1++) {
1122                 reg = rd32(hw, I40E_GLNVM_ULD);
1123                 reg &= (I40E_GLNVM_ULD_CONF_CORE_DONE_MASK |
1124                         I40E_GLNVM_ULD_CONF_GLOBAL_DONE_MASK);
1125                 if (reg == (I40E_GLNVM_ULD_CONF_CORE_DONE_MASK |
1126                             I40E_GLNVM_ULD_CONF_GLOBAL_DONE_MASK)) {
1127                         DEBUGOUT1("Core and Global modules ready %d\n", cnt1);
1128                         break;
1129                 }
1130                 i40e_msec_delay(10);
1131         }
1132         if (!(reg & (I40E_GLNVM_ULD_CONF_CORE_DONE_MASK |
1133                      I40E_GLNVM_ULD_CONF_GLOBAL_DONE_MASK))) {
1134                 DEBUGOUT("wait for FW Reset complete timedout\n");
1135                 DEBUGOUT1("I40E_GLNVM_ULD = 0x%x\n", reg);
1136                 return I40E_ERR_RESET_FAILED;
1137         }
1138
1139         /* If there was a Global Reset in progress when we got here,
1140          * we don't need to do the PF Reset
1141          */
1142         if (!cnt) {
1143                 reg = rd32(hw, I40E_PFGEN_CTRL);
1144                 wr32(hw, I40E_PFGEN_CTRL,
1145                      (reg | I40E_PFGEN_CTRL_PFSWR_MASK));
1146                 for (cnt = 0; cnt < I40E_PF_RESET_WAIT_COUNT; cnt++) {
1147                         reg = rd32(hw, I40E_PFGEN_CTRL);
1148                         if (!(reg & I40E_PFGEN_CTRL_PFSWR_MASK))
1149                                 break;
1150                         i40e_msec_delay(1);
1151                 }
1152                 if (reg & I40E_PFGEN_CTRL_PFSWR_MASK) {
1153                         DEBUGOUT("PF reset polling failed to complete.\n");
1154                         return I40E_ERR_RESET_FAILED;
1155                 }
1156         }
1157
1158         i40e_clear_pxe_mode(hw);
1159
1160
1161         return I40E_SUCCESS;
1162 }
1163
1164 /**
1165  * i40e_clear_hw - clear out any left over hw state
1166  * @hw: pointer to the hw struct
1167  *
1168  * Clear queues and interrupts, typically called at init time,
1169  * but after the capabilities have been found so we know how many
1170  * queues and msix vectors have been allocated.
1171  **/
1172 void i40e_clear_hw(struct i40e_hw *hw)
1173 {
1174         u32 num_queues, base_queue;
1175         u32 num_pf_int;
1176         u32 num_vf_int;
1177         u32 num_vfs;
1178         u32 i, j;
1179         u32 val;
1180         u32 eol = 0x7ff;
1181
1182         /* get number of interrupts, queues, and vfs */
1183         val = rd32(hw, I40E_GLPCI_CNF2);
1184         num_pf_int = (val & I40E_GLPCI_CNF2_MSI_X_PF_N_MASK) >>
1185                         I40E_GLPCI_CNF2_MSI_X_PF_N_SHIFT;
1186         num_vf_int = (val & I40E_GLPCI_CNF2_MSI_X_VF_N_MASK) >>
1187                         I40E_GLPCI_CNF2_MSI_X_VF_N_SHIFT;
1188
1189         val = rd32(hw, I40E_PFLAN_QALLOC);
1190         base_queue = (val & I40E_PFLAN_QALLOC_FIRSTQ_MASK) >>
1191                         I40E_PFLAN_QALLOC_FIRSTQ_SHIFT;
1192         j = (val & I40E_PFLAN_QALLOC_LASTQ_MASK) >>
1193                         I40E_PFLAN_QALLOC_LASTQ_SHIFT;
1194         if (val & I40E_PFLAN_QALLOC_VALID_MASK)
1195                 num_queues = (j - base_queue) + 1;
1196         else
1197                 num_queues = 0;
1198
1199         val = rd32(hw, I40E_PF_VT_PFALLOC);
1200         i = (val & I40E_PF_VT_PFALLOC_FIRSTVF_MASK) >>
1201                         I40E_PF_VT_PFALLOC_FIRSTVF_SHIFT;
1202         j = (val & I40E_PF_VT_PFALLOC_LASTVF_MASK) >>
1203                         I40E_PF_VT_PFALLOC_LASTVF_SHIFT;
1204         if (val & I40E_PF_VT_PFALLOC_VALID_MASK)
1205                 num_vfs = (j - i) + 1;
1206         else
1207                 num_vfs = 0;
1208
1209         /* stop all the interrupts */
1210         wr32(hw, I40E_PFINT_ICR0_ENA, 0);
1211         val = 0x3 << I40E_PFINT_DYN_CTLN_ITR_INDX_SHIFT;
1212         for (i = 0; i < num_pf_int - 2; i++)
1213                 wr32(hw, I40E_PFINT_DYN_CTLN(i), val);
1214
1215         /* Set the FIRSTQ_INDX field to 0x7FF in PFINT_LNKLSTx */
1216         val = eol << I40E_PFINT_LNKLST0_FIRSTQ_INDX_SHIFT;
1217         wr32(hw, I40E_PFINT_LNKLST0, val);
1218         for (i = 0; i < num_pf_int - 2; i++)
1219                 wr32(hw, I40E_PFINT_LNKLSTN(i), val);
1220         val = eol << I40E_VPINT_LNKLST0_FIRSTQ_INDX_SHIFT;
1221         for (i = 0; i < num_vfs; i++)
1222                 wr32(hw, I40E_VPINT_LNKLST0(i), val);
1223         for (i = 0; i < num_vf_int - 2; i++)
1224                 wr32(hw, I40E_VPINT_LNKLSTN(i), val);
1225
1226         /* warn the HW of the coming Tx disables */
1227         for (i = 0; i < num_queues; i++) {
1228                 u32 abs_queue_idx = base_queue + i;
1229                 u32 reg_block = 0;
1230
1231                 if (abs_queue_idx >= 128) {
1232                         reg_block = abs_queue_idx / 128;
1233                         abs_queue_idx %= 128;
1234                 }
1235
1236                 val = rd32(hw, I40E_GLLAN_TXPRE_QDIS(reg_block));
1237                 val &= ~I40E_GLLAN_TXPRE_QDIS_QINDX_MASK;
1238                 val |= (abs_queue_idx << I40E_GLLAN_TXPRE_QDIS_QINDX_SHIFT);
1239                 val |= I40E_GLLAN_TXPRE_QDIS_SET_QDIS_MASK;
1240
1241                 wr32(hw, I40E_GLLAN_TXPRE_QDIS(reg_block), val);
1242         }
1243         i40e_usec_delay(400);
1244
1245         /* stop all the queues */
1246         for (i = 0; i < num_queues; i++) {
1247                 wr32(hw, I40E_QINT_TQCTL(i), 0);
1248                 wr32(hw, I40E_QTX_ENA(i), 0);
1249                 wr32(hw, I40E_QINT_RQCTL(i), 0);
1250                 wr32(hw, I40E_QRX_ENA(i), 0);
1251         }
1252
1253         /* short wait for all queue disables to settle */
1254         i40e_usec_delay(50);
1255 }
1256
1257 /**
1258  * i40e_clear_pxe_mode - clear pxe operations mode
1259  * @hw: pointer to the hw struct
1260  *
1261  * Make sure all PXE mode settings are cleared, including things
1262  * like descriptor fetch/write-back mode.
1263  **/
1264 void i40e_clear_pxe_mode(struct i40e_hw *hw)
1265 {
1266         if (i40e_check_asq_alive(hw))
1267                 i40e_aq_clear_pxe_mode(hw, NULL);
1268 }
1269
1270 /**
1271  * i40e_led_is_mine - helper to find matching led
1272  * @hw: pointer to the hw struct
1273  * @idx: index into GPIO registers
1274  *
1275  * returns: 0 if no match, otherwise the value of the GPIO_CTL register
1276  */
1277 static u32 i40e_led_is_mine(struct i40e_hw *hw, int idx)
1278 {
1279         u32 gpio_val = 0;
1280         u32 port;
1281
1282         if (!hw->func_caps.led[idx])
1283                 return 0;
1284
1285         gpio_val = rd32(hw, I40E_GLGEN_GPIO_CTL(idx));
1286         port = (gpio_val & I40E_GLGEN_GPIO_CTL_PRT_NUM_MASK) >>
1287                 I40E_GLGEN_GPIO_CTL_PRT_NUM_SHIFT;
1288
1289         /* if PRT_NUM_NA is 1 then this LED is not port specific, OR
1290          * if it is not our port then ignore
1291          */
1292         if ((gpio_val & I40E_GLGEN_GPIO_CTL_PRT_NUM_NA_MASK) ||
1293             (port != hw->port))
1294                 return 0;
1295
1296         return gpio_val;
1297 }
1298
1299 #define I40E_COMBINED_ACTIVITY 0xA
1300 #define I40E_FILTER_ACTIVITY 0xE
1301 #define I40E_LINK_ACTIVITY 0xC
1302 #define I40E_MAC_ACTIVITY 0xD
1303 #define I40E_LED0 22
1304
1305 /**
1306  * i40e_led_get - return current on/off mode
1307  * @hw: pointer to the hw struct
1308  *
1309  * The value returned is the 'mode' field as defined in the
1310  * GPIO register definitions: 0x0 = off, 0xf = on, and other
1311  * values are variations of possible behaviors relating to
1312  * blink, link, and wire.
1313  **/
1314 u32 i40e_led_get(struct i40e_hw *hw)
1315 {
1316         u32 current_mode = 0;
1317         u32 mode = 0;
1318         int i;
1319
1320         /* as per the documentation GPIO 22-29 are the LED
1321          * GPIO pins named LED0..LED7
1322          */
1323         for (i = I40E_LED0; i <= I40E_GLGEN_GPIO_CTL_MAX_INDEX; i++) {
1324                 u32 gpio_val = i40e_led_is_mine(hw, i);
1325
1326                 if (!gpio_val)
1327                         continue;
1328
1329                 /* ignore gpio LED src mode entries related to the activity LEDs */
1330                 current_mode = ((gpio_val & I40E_GLGEN_GPIO_CTL_LED_MODE_MASK) >>
1331                         I40E_GLGEN_GPIO_CTL_LED_MODE_SHIFT);
1332                 switch (current_mode) {
1333                 case I40E_COMBINED_ACTIVITY:
1334                 case I40E_FILTER_ACTIVITY:
1335                 case I40E_MAC_ACTIVITY:
1336                         continue;
1337                 default:
1338                         break;
1339                 }
1340
1341                 mode = (gpio_val & I40E_GLGEN_GPIO_CTL_LED_MODE_MASK) >>
1342                         I40E_GLGEN_GPIO_CTL_LED_MODE_SHIFT;
1343                 break;
1344         }
1345
1346         return mode;
1347 }
1348
1349 /**
1350  * i40e_led_set - set new on/off mode
1351  * @hw: pointer to the hw struct
1352  * @mode: 0=off, 0xf=on (else see manual for mode details)
1353  * @blink: true if the LED should blink when on, false if steady
1354  *
1355  * if this function is used to turn on the blink it should
1356  * be used to disable the blink when restoring the original state.
1357  **/
1358 void i40e_led_set(struct i40e_hw *hw, u32 mode, bool blink)
1359 {
1360         u32 current_mode = 0;
1361         int i;
1362
1363         if (mode & 0xfffffff0)
1364                 DEBUGOUT1("invalid mode passed in %X\n", mode);
1365
1366         /* as per the documentation GPIO 22-29 are the LED
1367          * GPIO pins named LED0..LED7
1368          */
1369         for (i = I40E_LED0; i <= I40E_GLGEN_GPIO_CTL_MAX_INDEX; i++) {
1370                 u32 gpio_val = i40e_led_is_mine(hw, i);
1371
1372                 if (!gpio_val)
1373                         continue;
1374
1375                 /* ignore gpio LED src mode entries related to the activity LEDs */
1376                 current_mode = ((gpio_val & I40E_GLGEN_GPIO_CTL_LED_MODE_MASK) >>
1377                         I40E_GLGEN_GPIO_CTL_LED_MODE_SHIFT);
1378                 switch (current_mode) {
1379                 case I40E_COMBINED_ACTIVITY:
1380                 case I40E_FILTER_ACTIVITY:
1381                 case I40E_MAC_ACTIVITY:
1382                         continue;
1383                 default:
1384                         break;
1385                 }
1386
1387                 gpio_val &= ~I40E_GLGEN_GPIO_CTL_LED_MODE_MASK;
1388                 /* this & is a bit of paranoia, but serves as a range check */
1389                 gpio_val |= ((mode << I40E_GLGEN_GPIO_CTL_LED_MODE_SHIFT) &
1390                              I40E_GLGEN_GPIO_CTL_LED_MODE_MASK);
1391
1392                 if (mode == I40E_LINK_ACTIVITY)
1393                         blink = false;
1394
1395                 if (blink)
1396                         gpio_val |= (1 << I40E_GLGEN_GPIO_CTL_LED_BLINK_SHIFT);
1397                 else
1398                         gpio_val &= ~(1 << I40E_GLGEN_GPIO_CTL_LED_BLINK_SHIFT);
1399
1400                 wr32(hw, I40E_GLGEN_GPIO_CTL(i), gpio_val);
1401                 break;
1402         }
1403 }
1404
1405 /* Admin command wrappers */
1406
1407 /**
1408  * i40e_aq_get_phy_capabilities
1409  * @hw: pointer to the hw struct
1410  * @abilities: structure for PHY capabilities to be filled
1411  * @qualified_modules: report Qualified Modules
1412  * @report_init: report init capabilities (active are default)
1413  * @cmd_details: pointer to command details structure or NULL
1414  *
1415  * Returns the various PHY abilities supported on the Port.
1416  **/
1417 enum i40e_status_code i40e_aq_get_phy_capabilities(struct i40e_hw *hw,
1418                         bool qualified_modules, bool report_init,
1419                         struct i40e_aq_get_phy_abilities_resp *abilities,
1420                         struct i40e_asq_cmd_details *cmd_details)
1421 {
1422         struct i40e_aq_desc desc;
1423         enum i40e_status_code status;
1424         u16 abilities_size = sizeof(struct i40e_aq_get_phy_abilities_resp);
1425
1426         if (!abilities)
1427                 return I40E_ERR_PARAM;
1428
1429         i40e_fill_default_direct_cmd_desc(&desc,
1430                                           i40e_aqc_opc_get_phy_abilities);
1431
1432         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
1433         if (abilities_size > I40E_AQ_LARGE_BUF)
1434                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
1435
1436         if (qualified_modules)
1437                 desc.params.external.param0 |=
1438                         CPU_TO_LE32(I40E_AQ_PHY_REPORT_QUALIFIED_MODULES);
1439
1440         if (report_init)
1441                 desc.params.external.param0 |=
1442                         CPU_TO_LE32(I40E_AQ_PHY_REPORT_INITIAL_VALUES);
1443
1444         status = i40e_asq_send_command(hw, &desc, abilities, abilities_size,
1445                                     cmd_details);
1446
1447         if (hw->aq.asq_last_status == I40E_AQ_RC_EIO)
1448                 status = I40E_ERR_UNKNOWN_PHY;
1449
1450         return status;
1451 }
1452
1453 /**
1454  * i40e_aq_set_phy_config
1455  * @hw: pointer to the hw struct
1456  * @config: structure with PHY configuration to be set
1457  * @cmd_details: pointer to command details structure or NULL
1458  *
1459  * Set the various PHY configuration parameters
1460  * supported on the Port.One or more of the Set PHY config parameters may be
1461  * ignored in an MFP mode as the PF may not have the privilege to set some
1462  * of the PHY Config parameters. This status will be indicated by the
1463  * command response.
1464  **/
1465 enum i40e_status_code i40e_aq_set_phy_config(struct i40e_hw *hw,
1466                                 struct i40e_aq_set_phy_config *config,
1467                                 struct i40e_asq_cmd_details *cmd_details)
1468 {
1469         struct i40e_aq_desc desc;
1470         struct i40e_aq_set_phy_config *cmd =
1471                 (struct i40e_aq_set_phy_config *)&desc.params.raw;
1472         enum i40e_status_code status;
1473
1474         if (!config)
1475                 return I40E_ERR_PARAM;
1476
1477         i40e_fill_default_direct_cmd_desc(&desc,
1478                                           i40e_aqc_opc_set_phy_config);
1479
1480         *cmd = *config;
1481
1482         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1483
1484         return status;
1485 }
1486
1487 /**
1488  * i40e_set_fc
1489  * @hw: pointer to the hw struct
1490  *
1491  * Set the requested flow control mode using set_phy_config.
1492  **/
1493 enum i40e_status_code i40e_set_fc(struct i40e_hw *hw, u8 *aq_failures,
1494                                   bool atomic_restart)
1495 {
1496         enum i40e_fc_mode fc_mode = hw->fc.requested_mode;
1497         struct i40e_aq_get_phy_abilities_resp abilities;
1498         struct i40e_aq_set_phy_config config;
1499         enum i40e_status_code status;
1500         u8 pause_mask = 0x0;
1501
1502         *aq_failures = 0x0;
1503
1504         switch (fc_mode) {
1505         case I40E_FC_FULL:
1506                 pause_mask |= I40E_AQ_PHY_FLAG_PAUSE_TX;
1507                 pause_mask |= I40E_AQ_PHY_FLAG_PAUSE_RX;
1508                 break;
1509         case I40E_FC_RX_PAUSE:
1510                 pause_mask |= I40E_AQ_PHY_FLAG_PAUSE_RX;
1511                 break;
1512         case I40E_FC_TX_PAUSE:
1513                 pause_mask |= I40E_AQ_PHY_FLAG_PAUSE_TX;
1514                 break;
1515         default:
1516                 break;
1517         }
1518
1519         /* Get the current phy config */
1520         status = i40e_aq_get_phy_capabilities(hw, false, false, &abilities,
1521                                               NULL);
1522         if (status) {
1523                 *aq_failures |= I40E_SET_FC_AQ_FAIL_GET;
1524                 return status;
1525         }
1526
1527         memset(&config, 0, sizeof(config));
1528         /* clear the old pause settings */
1529         config.abilities = abilities.abilities & ~(I40E_AQ_PHY_FLAG_PAUSE_TX) &
1530                            ~(I40E_AQ_PHY_FLAG_PAUSE_RX);
1531         /* set the new abilities */
1532         config.abilities |= pause_mask;
1533         /* If the abilities have changed, then set the new config */
1534         if (config.abilities != abilities.abilities) {
1535                 /* Auto restart link so settings take effect */
1536                 if (atomic_restart)
1537                         config.abilities |= I40E_AQ_PHY_ENABLE_ATOMIC_LINK;
1538                 /* Copy over all the old settings */
1539                 config.phy_type = abilities.phy_type;
1540                 config.link_speed = abilities.link_speed;
1541                 config.eee_capability = abilities.eee_capability;
1542                 config.eeer = abilities.eeer_val;
1543                 config.low_power_ctrl = abilities.d3_lpan;
1544                 status = i40e_aq_set_phy_config(hw, &config, NULL);
1545
1546                 if (status)
1547                         *aq_failures |= I40E_SET_FC_AQ_FAIL_SET;
1548         }
1549         /* Update the link info */
1550         status = i40e_update_link_info(hw);
1551         if (status) {
1552                 /* Wait a little bit (on 40G cards it sometimes takes a really
1553                  * long time for link to come back from the atomic reset)
1554                  * and try once more
1555                  */
1556                 i40e_msec_delay(1000);
1557                 status = i40e_update_link_info(hw);
1558         }
1559         if (status)
1560                 *aq_failures |= I40E_SET_FC_AQ_FAIL_UPDATE;
1561
1562         return status;
1563 }
1564
1565 /**
1566  * i40e_aq_set_mac_config
1567  * @hw: pointer to the hw struct
1568  * @max_frame_size: Maximum Frame Size to be supported by the port
1569  * @crc_en: Tell HW to append a CRC to outgoing frames
1570  * @pacing: Pacing configurations
1571  * @cmd_details: pointer to command details structure or NULL
1572  *
1573  * Configure MAC settings for frame size, jumbo frame support and the
1574  * addition of a CRC by the hardware.
1575  **/
1576 enum i40e_status_code i40e_aq_set_mac_config(struct i40e_hw *hw,
1577                                 u16 max_frame_size,
1578                                 bool crc_en, u16 pacing,
1579                                 struct i40e_asq_cmd_details *cmd_details)
1580 {
1581         struct i40e_aq_desc desc;
1582         struct i40e_aq_set_mac_config *cmd =
1583                 (struct i40e_aq_set_mac_config *)&desc.params.raw;
1584         enum i40e_status_code status;
1585
1586         if (max_frame_size == 0)
1587                 return I40E_ERR_PARAM;
1588
1589         i40e_fill_default_direct_cmd_desc(&desc,
1590                                           i40e_aqc_opc_set_mac_config);
1591
1592         cmd->max_frame_size = CPU_TO_LE16(max_frame_size);
1593         cmd->params = ((u8)pacing & 0x0F) << 3;
1594         if (crc_en)
1595                 cmd->params |= I40E_AQ_SET_MAC_CONFIG_CRC_EN;
1596
1597         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1598
1599         return status;
1600 }
1601
1602 /**
1603  * i40e_aq_clear_pxe_mode
1604  * @hw: pointer to the hw struct
1605  * @cmd_details: pointer to command details structure or NULL
1606  *
1607  * Tell the firmware that the driver is taking over from PXE
1608  **/
1609 enum i40e_status_code i40e_aq_clear_pxe_mode(struct i40e_hw *hw,
1610                         struct i40e_asq_cmd_details *cmd_details)
1611 {
1612         enum i40e_status_code status;
1613         struct i40e_aq_desc desc;
1614         struct i40e_aqc_clear_pxe *cmd =
1615                 (struct i40e_aqc_clear_pxe *)&desc.params.raw;
1616
1617         i40e_fill_default_direct_cmd_desc(&desc,
1618                                           i40e_aqc_opc_clear_pxe_mode);
1619
1620         cmd->rx_cnt = 0x2;
1621
1622         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1623
1624         wr32(hw, I40E_GLLAN_RCTL_0, 0x1);
1625
1626         return status;
1627 }
1628
1629 /**
1630  * i40e_aq_set_link_restart_an
1631  * @hw: pointer to the hw struct
1632  * @enable_link: if true: enable link, if false: disable link
1633  * @cmd_details: pointer to command details structure or NULL
1634  *
1635  * Sets up the link and restarts the Auto-Negotiation over the link.
1636  **/
1637 enum i40e_status_code i40e_aq_set_link_restart_an(struct i40e_hw *hw,
1638                 bool enable_link, struct i40e_asq_cmd_details *cmd_details)
1639 {
1640         struct i40e_aq_desc desc;
1641         struct i40e_aqc_set_link_restart_an *cmd =
1642                 (struct i40e_aqc_set_link_restart_an *)&desc.params.raw;
1643         enum i40e_status_code status;
1644
1645         i40e_fill_default_direct_cmd_desc(&desc,
1646                                           i40e_aqc_opc_set_link_restart_an);
1647
1648         cmd->command = I40E_AQ_PHY_RESTART_AN;
1649         if (enable_link)
1650                 cmd->command |= I40E_AQ_PHY_LINK_ENABLE;
1651         else
1652                 cmd->command &= ~I40E_AQ_PHY_LINK_ENABLE;
1653
1654         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1655
1656         return status;
1657 }
1658
1659 /**
1660  * i40e_aq_get_link_info
1661  * @hw: pointer to the hw struct
1662  * @enable_lse: enable/disable LinkStatusEvent reporting
1663  * @link: pointer to link status structure - optional
1664  * @cmd_details: pointer to command details structure or NULL
1665  *
1666  * Returns the link status of the adapter.
1667  **/
1668 enum i40e_status_code i40e_aq_get_link_info(struct i40e_hw *hw,
1669                                 bool enable_lse, struct i40e_link_status *link,
1670                                 struct i40e_asq_cmd_details *cmd_details)
1671 {
1672         struct i40e_aq_desc desc;
1673         struct i40e_aqc_get_link_status *resp =
1674                 (struct i40e_aqc_get_link_status *)&desc.params.raw;
1675         struct i40e_link_status *hw_link_info = &hw->phy.link_info;
1676         enum i40e_status_code status;
1677         bool tx_pause, rx_pause;
1678         u16 command_flags;
1679
1680         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_get_link_status);
1681
1682         if (enable_lse)
1683                 command_flags = I40E_AQ_LSE_ENABLE;
1684         else
1685                 command_flags = I40E_AQ_LSE_DISABLE;
1686         resp->command_flags = CPU_TO_LE16(command_flags);
1687
1688         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1689
1690         if (status != I40E_SUCCESS)
1691                 goto aq_get_link_info_exit;
1692
1693         /* save off old link status information */
1694         i40e_memcpy(&hw->phy.link_info_old, hw_link_info,
1695                     sizeof(*hw_link_info), I40E_NONDMA_TO_NONDMA);
1696
1697         /* update link status */
1698         hw_link_info->phy_type = (enum i40e_aq_phy_type)resp->phy_type;
1699         hw->phy.media_type = i40e_get_media_type(hw);
1700         hw_link_info->link_speed = (enum i40e_aq_link_speed)resp->link_speed;
1701         hw_link_info->link_info = resp->link_info;
1702         hw_link_info->an_info = resp->an_info;
1703         hw_link_info->ext_info = resp->ext_info;
1704         hw_link_info->loopback = resp->loopback;
1705         hw_link_info->max_frame_size = LE16_TO_CPU(resp->max_frame_size);
1706         hw_link_info->pacing = resp->config & I40E_AQ_CONFIG_PACING_MASK;
1707
1708         /* update fc info */
1709         tx_pause = !!(resp->an_info & I40E_AQ_LINK_PAUSE_TX);
1710         rx_pause = !!(resp->an_info & I40E_AQ_LINK_PAUSE_RX);
1711         if (tx_pause & rx_pause)
1712                 hw->fc.current_mode = I40E_FC_FULL;
1713         else if (tx_pause)
1714                 hw->fc.current_mode = I40E_FC_TX_PAUSE;
1715         else if (rx_pause)
1716                 hw->fc.current_mode = I40E_FC_RX_PAUSE;
1717         else
1718                 hw->fc.current_mode = I40E_FC_NONE;
1719
1720         if (resp->config & I40E_AQ_CONFIG_CRC_ENA)
1721                 hw_link_info->crc_enable = true;
1722         else
1723                 hw_link_info->crc_enable = false;
1724
1725         if (resp->command_flags & CPU_TO_LE16(I40E_AQ_LSE_ENABLE))
1726                 hw_link_info->lse_enable = true;
1727         else
1728                 hw_link_info->lse_enable = false;
1729
1730         if ((hw->aq.fw_maj_ver < 4 || (hw->aq.fw_maj_ver == 4 &&
1731              hw->aq.fw_min_ver < 40)) && hw_link_info->phy_type == 0xE)
1732                 hw_link_info->phy_type = I40E_PHY_TYPE_10GBASE_SFPP_CU;
1733
1734         /* save link status information */
1735         if (link)
1736                 i40e_memcpy(link, hw_link_info, sizeof(*hw_link_info),
1737                             I40E_NONDMA_TO_NONDMA);
1738
1739         /* flag cleared so helper functions don't call AQ again */
1740         hw->phy.get_link_info = false;
1741
1742 aq_get_link_info_exit:
1743         return status;
1744 }
1745
1746 /**
1747  * i40e_aq_set_phy_int_mask
1748  * @hw: pointer to the hw struct
1749  * @mask: interrupt mask to be set
1750  * @cmd_details: pointer to command details structure or NULL
1751  *
1752  * Set link interrupt mask.
1753  **/
1754 enum i40e_status_code i40e_aq_set_phy_int_mask(struct i40e_hw *hw,
1755                                 u16 mask,
1756                                 struct i40e_asq_cmd_details *cmd_details)
1757 {
1758         struct i40e_aq_desc desc;
1759         struct i40e_aqc_set_phy_int_mask *cmd =
1760                 (struct i40e_aqc_set_phy_int_mask *)&desc.params.raw;
1761         enum i40e_status_code status;
1762
1763         i40e_fill_default_direct_cmd_desc(&desc,
1764                                           i40e_aqc_opc_set_phy_int_mask);
1765
1766         cmd->event_mask = CPU_TO_LE16(mask);
1767
1768         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1769
1770         return status;
1771 }
1772
1773 /**
1774  * i40e_aq_get_local_advt_reg
1775  * @hw: pointer to the hw struct
1776  * @advt_reg: local AN advertisement register value
1777  * @cmd_details: pointer to command details structure or NULL
1778  *
1779  * Get the Local AN advertisement register value.
1780  **/
1781 enum i40e_status_code i40e_aq_get_local_advt_reg(struct i40e_hw *hw,
1782                                 u64 *advt_reg,
1783                                 struct i40e_asq_cmd_details *cmd_details)
1784 {
1785         struct i40e_aq_desc desc;
1786         struct i40e_aqc_an_advt_reg *resp =
1787                 (struct i40e_aqc_an_advt_reg *)&desc.params.raw;
1788         enum i40e_status_code status;
1789
1790         i40e_fill_default_direct_cmd_desc(&desc,
1791                                           i40e_aqc_opc_get_local_advt_reg);
1792
1793         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1794
1795         if (status != I40E_SUCCESS)
1796                 goto aq_get_local_advt_reg_exit;
1797
1798         *advt_reg = (u64)(LE16_TO_CPU(resp->local_an_reg1)) << 32;
1799         *advt_reg |= LE32_TO_CPU(resp->local_an_reg0);
1800
1801 aq_get_local_advt_reg_exit:
1802         return status;
1803 }
1804
1805 /**
1806  * i40e_aq_set_local_advt_reg
1807  * @hw: pointer to the hw struct
1808  * @advt_reg: local AN advertisement register value
1809  * @cmd_details: pointer to command details structure or NULL
1810  *
1811  * Get the Local AN advertisement register value.
1812  **/
1813 enum i40e_status_code i40e_aq_set_local_advt_reg(struct i40e_hw *hw,
1814                                 u64 advt_reg,
1815                                 struct i40e_asq_cmd_details *cmd_details)
1816 {
1817         struct i40e_aq_desc desc;
1818         struct i40e_aqc_an_advt_reg *cmd =
1819                 (struct i40e_aqc_an_advt_reg *)&desc.params.raw;
1820         enum i40e_status_code status;
1821
1822         i40e_fill_default_direct_cmd_desc(&desc,
1823                                           i40e_aqc_opc_get_local_advt_reg);
1824
1825         cmd->local_an_reg0 = CPU_TO_LE32(I40E_LO_DWORD(advt_reg));
1826         cmd->local_an_reg1 = CPU_TO_LE16(I40E_HI_DWORD(advt_reg));
1827
1828         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1829
1830         return status;
1831 }
1832
1833 /**
1834  * i40e_aq_get_partner_advt
1835  * @hw: pointer to the hw struct
1836  * @advt_reg: AN partner advertisement register value
1837  * @cmd_details: pointer to command details structure or NULL
1838  *
1839  * Get the link partner AN advertisement register value.
1840  **/
1841 enum i40e_status_code i40e_aq_get_partner_advt(struct i40e_hw *hw,
1842                                 u64 *advt_reg,
1843                                 struct i40e_asq_cmd_details *cmd_details)
1844 {
1845         struct i40e_aq_desc desc;
1846         struct i40e_aqc_an_advt_reg *resp =
1847                 (struct i40e_aqc_an_advt_reg *)&desc.params.raw;
1848         enum i40e_status_code status;
1849
1850         i40e_fill_default_direct_cmd_desc(&desc,
1851                                           i40e_aqc_opc_get_partner_advt);
1852
1853         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1854
1855         if (status != I40E_SUCCESS)
1856                 goto aq_get_partner_advt_exit;
1857
1858         *advt_reg = (u64)(LE16_TO_CPU(resp->local_an_reg1)) << 32;
1859         *advt_reg |= LE32_TO_CPU(resp->local_an_reg0);
1860
1861 aq_get_partner_advt_exit:
1862         return status;
1863 }
1864
1865 /**
1866  * i40e_aq_set_lb_modes
1867  * @hw: pointer to the hw struct
1868  * @lb_modes: loopback mode to be set
1869  * @cmd_details: pointer to command details structure or NULL
1870  *
1871  * Sets loopback modes.
1872  **/
1873 enum i40e_status_code i40e_aq_set_lb_modes(struct i40e_hw *hw,
1874                                 u16 lb_modes,
1875                                 struct i40e_asq_cmd_details *cmd_details)
1876 {
1877         struct i40e_aq_desc desc;
1878         struct i40e_aqc_set_lb_mode *cmd =
1879                 (struct i40e_aqc_set_lb_mode *)&desc.params.raw;
1880         enum i40e_status_code status;
1881
1882         i40e_fill_default_direct_cmd_desc(&desc,
1883                                           i40e_aqc_opc_set_lb_modes);
1884
1885         cmd->lb_mode = CPU_TO_LE16(lb_modes);
1886
1887         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1888
1889         return status;
1890 }
1891
1892 /**
1893  * i40e_aq_set_phy_debug
1894  * @hw: pointer to the hw struct
1895  * @cmd_flags: debug command flags
1896  * @cmd_details: pointer to command details structure or NULL
1897  *
1898  * Reset the external PHY.
1899  **/
1900 enum i40e_status_code i40e_aq_set_phy_debug(struct i40e_hw *hw, u8 cmd_flags,
1901                                 struct i40e_asq_cmd_details *cmd_details)
1902 {
1903         struct i40e_aq_desc desc;
1904         struct i40e_aqc_set_phy_debug *cmd =
1905                 (struct i40e_aqc_set_phy_debug *)&desc.params.raw;
1906         enum i40e_status_code status;
1907
1908         i40e_fill_default_direct_cmd_desc(&desc,
1909                                           i40e_aqc_opc_set_phy_debug);
1910
1911         cmd->command_flags = cmd_flags;
1912
1913         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1914
1915         return status;
1916 }
1917
1918 /**
1919  * i40e_aq_add_vsi
1920  * @hw: pointer to the hw struct
1921  * @vsi_ctx: pointer to a vsi context struct
1922  * @cmd_details: pointer to command details structure or NULL
1923  *
1924  * Add a VSI context to the hardware.
1925 **/
1926 enum i40e_status_code i40e_aq_add_vsi(struct i40e_hw *hw,
1927                                 struct i40e_vsi_context *vsi_ctx,
1928                                 struct i40e_asq_cmd_details *cmd_details)
1929 {
1930         struct i40e_aq_desc desc;
1931         struct i40e_aqc_add_get_update_vsi *cmd =
1932                 (struct i40e_aqc_add_get_update_vsi *)&desc.params.raw;
1933         struct i40e_aqc_add_get_update_vsi_completion *resp =
1934                 (struct i40e_aqc_add_get_update_vsi_completion *)
1935                 &desc.params.raw;
1936         enum i40e_status_code status;
1937
1938         i40e_fill_default_direct_cmd_desc(&desc,
1939                                           i40e_aqc_opc_add_vsi);
1940
1941         cmd->uplink_seid = CPU_TO_LE16(vsi_ctx->uplink_seid);
1942         cmd->connection_type = vsi_ctx->connection_type;
1943         cmd->vf_id = vsi_ctx->vf_num;
1944         cmd->vsi_flags = CPU_TO_LE16(vsi_ctx->flags);
1945
1946         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
1947
1948         status = i40e_asq_send_command(hw, &desc, &vsi_ctx->info,
1949                                     sizeof(vsi_ctx->info), cmd_details);
1950
1951         if (status != I40E_SUCCESS)
1952                 goto aq_add_vsi_exit;
1953
1954         vsi_ctx->seid = LE16_TO_CPU(resp->seid);
1955         vsi_ctx->vsi_number = LE16_TO_CPU(resp->vsi_number);
1956         vsi_ctx->vsis_allocated = LE16_TO_CPU(resp->vsi_used);
1957         vsi_ctx->vsis_unallocated = LE16_TO_CPU(resp->vsi_free);
1958
1959 aq_add_vsi_exit:
1960         return status;
1961 }
1962
1963 /**
1964  * i40e_aq_set_default_vsi
1965  * @hw: pointer to the hw struct
1966  * @seid: vsi number
1967  * @cmd_details: pointer to command details structure or NULL
1968  **/
1969 enum i40e_status_code i40e_aq_set_default_vsi(struct i40e_hw *hw,
1970                                 u16 seid,
1971                                 struct i40e_asq_cmd_details *cmd_details)
1972 {
1973         struct i40e_aq_desc desc;
1974         struct i40e_aqc_set_vsi_promiscuous_modes *cmd =
1975                 (struct i40e_aqc_set_vsi_promiscuous_modes *)
1976                 &desc.params.raw;
1977         enum i40e_status_code status;
1978
1979         i40e_fill_default_direct_cmd_desc(&desc,
1980                                         i40e_aqc_opc_set_vsi_promiscuous_modes);
1981
1982         cmd->promiscuous_flags = CPU_TO_LE16(I40E_AQC_SET_VSI_DEFAULT);
1983         cmd->valid_flags = CPU_TO_LE16(I40E_AQC_SET_VSI_DEFAULT);
1984         cmd->seid = CPU_TO_LE16(seid);
1985
1986         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
1987
1988         return status;
1989 }
1990
1991 /**
1992  * i40e_aq_set_vsi_unicast_promiscuous
1993  * @hw: pointer to the hw struct
1994  * @seid: vsi number
1995  * @set: set unicast promiscuous enable/disable
1996  * @cmd_details: pointer to command details structure or NULL
1997  **/
1998 enum i40e_status_code i40e_aq_set_vsi_unicast_promiscuous(struct i40e_hw *hw,
1999                                 u16 seid, bool set,
2000                                 struct i40e_asq_cmd_details *cmd_details)
2001 {
2002         struct i40e_aq_desc desc;
2003         struct i40e_aqc_set_vsi_promiscuous_modes *cmd =
2004                 (struct i40e_aqc_set_vsi_promiscuous_modes *)&desc.params.raw;
2005         enum i40e_status_code status;
2006         u16 flags = 0;
2007
2008         i40e_fill_default_direct_cmd_desc(&desc,
2009                                         i40e_aqc_opc_set_vsi_promiscuous_modes);
2010
2011         if (set)
2012                 flags |= I40E_AQC_SET_VSI_PROMISC_UNICAST;
2013
2014         cmd->promiscuous_flags = CPU_TO_LE16(flags);
2015
2016         cmd->valid_flags = CPU_TO_LE16(I40E_AQC_SET_VSI_PROMISC_UNICAST);
2017
2018         cmd->seid = CPU_TO_LE16(seid);
2019         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2020
2021         return status;
2022 }
2023
2024 /**
2025  * i40e_aq_set_vsi_multicast_promiscuous
2026  * @hw: pointer to the hw struct
2027  * @seid: vsi number
2028  * @set: set multicast promiscuous enable/disable
2029  * @cmd_details: pointer to command details structure or NULL
2030  **/
2031 enum i40e_status_code i40e_aq_set_vsi_multicast_promiscuous(struct i40e_hw *hw,
2032                                 u16 seid, bool set, struct i40e_asq_cmd_details *cmd_details)
2033 {
2034         struct i40e_aq_desc desc;
2035         struct i40e_aqc_set_vsi_promiscuous_modes *cmd =
2036                 (struct i40e_aqc_set_vsi_promiscuous_modes *)&desc.params.raw;
2037         enum i40e_status_code status;
2038         u16 flags = 0;
2039
2040         i40e_fill_default_direct_cmd_desc(&desc,
2041                                         i40e_aqc_opc_set_vsi_promiscuous_modes);
2042
2043         if (set)
2044                 flags |= I40E_AQC_SET_VSI_PROMISC_MULTICAST;
2045
2046         cmd->promiscuous_flags = CPU_TO_LE16(flags);
2047
2048         cmd->valid_flags = CPU_TO_LE16(I40E_AQC_SET_VSI_PROMISC_MULTICAST);
2049
2050         cmd->seid = CPU_TO_LE16(seid);
2051         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2052
2053         return status;
2054 }
2055
2056 /**
2057  * i40e_aq_set_vsi_mc_promisc_on_vlan
2058  * @hw: pointer to the hw struct
2059  * @seid: vsi number
2060  * @enable: set MAC L2 layer unicast promiscuous enable/disable for a given VLAN
2061  * @vid: The VLAN tag filter - capture any multicast packet with this VLAN tag
2062  * @cmd_details: pointer to command details structure or NULL
2063  **/
2064 enum i40e_status_code i40e_aq_set_vsi_mc_promisc_on_vlan(struct i40e_hw *hw,
2065                                 u16 seid, bool enable, u16 vid,
2066                                 struct i40e_asq_cmd_details *cmd_details)
2067 {
2068         struct i40e_aq_desc desc;
2069         struct i40e_aqc_set_vsi_promiscuous_modes *cmd =
2070                 (struct i40e_aqc_set_vsi_promiscuous_modes *)&desc.params.raw;
2071         enum i40e_status_code status;
2072         u16 flags = 0;
2073
2074         i40e_fill_default_direct_cmd_desc(&desc,
2075                                         i40e_aqc_opc_set_vsi_promiscuous_modes);
2076
2077         if (enable)
2078                 flags |= I40E_AQC_SET_VSI_PROMISC_MULTICAST;
2079
2080         cmd->promiscuous_flags = CPU_TO_LE16(flags);
2081         cmd->valid_flags = CPU_TO_LE16(I40E_AQC_SET_VSI_PROMISC_MULTICAST);
2082         cmd->seid = CPU_TO_LE16(seid);
2083         cmd->vlan_tag = CPU_TO_LE16(vid | I40E_AQC_SET_VSI_VLAN_VALID);
2084
2085         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2086
2087         return status;
2088 }
2089
2090 /**
2091  * i40e_aq_set_vsi_uc_promisc_on_vlan
2092  * @hw: pointer to the hw struct
2093  * @seid: vsi number
2094  * @enable: set MAC L2 layer unicast promiscuous enable/disable for a given VLAN
2095  * @vid: The VLAN tag filter - capture any unicast packet with this VLAN tag
2096  * @cmd_details: pointer to command details structure or NULL
2097  **/
2098 enum i40e_status_code i40e_aq_set_vsi_uc_promisc_on_vlan(struct i40e_hw *hw,
2099                                 u16 seid, bool enable, u16 vid,
2100                                 struct i40e_asq_cmd_details *cmd_details)
2101 {
2102         struct i40e_aq_desc desc;
2103         struct i40e_aqc_set_vsi_promiscuous_modes *cmd =
2104                 (struct i40e_aqc_set_vsi_promiscuous_modes *)&desc.params.raw;
2105         enum i40e_status_code status;
2106         u16 flags = 0;
2107
2108         i40e_fill_default_direct_cmd_desc(&desc,
2109                                         i40e_aqc_opc_set_vsi_promiscuous_modes);
2110
2111         if (enable)
2112                 flags |= I40E_AQC_SET_VSI_PROMISC_UNICAST;
2113
2114         cmd->promiscuous_flags = CPU_TO_LE16(flags);
2115         cmd->valid_flags = CPU_TO_LE16(I40E_AQC_SET_VSI_PROMISC_UNICAST);
2116         cmd->seid = CPU_TO_LE16(seid);
2117         cmd->vlan_tag = CPU_TO_LE16(vid | I40E_AQC_SET_VSI_VLAN_VALID);
2118
2119         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2120
2121         return status;
2122 }
2123
2124 /**
2125  * i40e_aq_set_vsi_broadcast
2126  * @hw: pointer to the hw struct
2127  * @seid: vsi number
2128  * @set_filter: true to set filter, false to clear filter
2129  * @cmd_details: pointer to command details structure or NULL
2130  *
2131  * Set or clear the broadcast promiscuous flag (filter) for a given VSI.
2132  **/
2133 enum i40e_status_code i40e_aq_set_vsi_broadcast(struct i40e_hw *hw,
2134                                 u16 seid, bool set_filter,
2135                                 struct i40e_asq_cmd_details *cmd_details)
2136 {
2137         struct i40e_aq_desc desc;
2138         struct i40e_aqc_set_vsi_promiscuous_modes *cmd =
2139                 (struct i40e_aqc_set_vsi_promiscuous_modes *)&desc.params.raw;
2140         enum i40e_status_code status;
2141
2142         i40e_fill_default_direct_cmd_desc(&desc,
2143                                         i40e_aqc_opc_set_vsi_promiscuous_modes);
2144
2145         if (set_filter)
2146                 cmd->promiscuous_flags
2147                             |= CPU_TO_LE16(I40E_AQC_SET_VSI_PROMISC_BROADCAST);
2148         else
2149                 cmd->promiscuous_flags
2150                             &= CPU_TO_LE16(~I40E_AQC_SET_VSI_PROMISC_BROADCAST);
2151
2152         cmd->valid_flags = CPU_TO_LE16(I40E_AQC_SET_VSI_PROMISC_BROADCAST);
2153         cmd->seid = CPU_TO_LE16(seid);
2154         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2155
2156         return status;
2157 }
2158
2159 /**
2160  * i40e_get_vsi_params - get VSI configuration info
2161  * @hw: pointer to the hw struct
2162  * @vsi_ctx: pointer to a vsi context struct
2163  * @cmd_details: pointer to command details structure or NULL
2164  **/
2165 enum i40e_status_code i40e_aq_get_vsi_params(struct i40e_hw *hw,
2166                                 struct i40e_vsi_context *vsi_ctx,
2167                                 struct i40e_asq_cmd_details *cmd_details)
2168 {
2169         struct i40e_aq_desc desc;
2170         struct i40e_aqc_add_get_update_vsi *cmd =
2171                 (struct i40e_aqc_add_get_update_vsi *)&desc.params.raw;
2172         struct i40e_aqc_add_get_update_vsi_completion *resp =
2173                 (struct i40e_aqc_add_get_update_vsi_completion *)
2174                 &desc.params.raw;
2175         enum i40e_status_code status;
2176
2177         UNREFERENCED_1PARAMETER(cmd_details);
2178         i40e_fill_default_direct_cmd_desc(&desc,
2179                                           i40e_aqc_opc_get_vsi_parameters);
2180
2181         cmd->uplink_seid = CPU_TO_LE16(vsi_ctx->seid);
2182
2183         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
2184
2185         status = i40e_asq_send_command(hw, &desc, &vsi_ctx->info,
2186                                     sizeof(vsi_ctx->info), NULL);
2187
2188         if (status != I40E_SUCCESS)
2189                 goto aq_get_vsi_params_exit;
2190
2191         vsi_ctx->seid = LE16_TO_CPU(resp->seid);
2192         vsi_ctx->vsi_number = LE16_TO_CPU(resp->vsi_number);
2193         vsi_ctx->vsis_allocated = LE16_TO_CPU(resp->vsi_used);
2194         vsi_ctx->vsis_unallocated = LE16_TO_CPU(resp->vsi_free);
2195
2196 aq_get_vsi_params_exit:
2197         return status;
2198 }
2199
2200 /**
2201  * i40e_aq_update_vsi_params
2202  * @hw: pointer to the hw struct
2203  * @vsi_ctx: pointer to a vsi context struct
2204  * @cmd_details: pointer to command details structure or NULL
2205  *
2206  * Update a VSI context.
2207  **/
2208 enum i40e_status_code i40e_aq_update_vsi_params(struct i40e_hw *hw,
2209                                 struct i40e_vsi_context *vsi_ctx,
2210                                 struct i40e_asq_cmd_details *cmd_details)
2211 {
2212         struct i40e_aq_desc desc;
2213         struct i40e_aqc_add_get_update_vsi *cmd =
2214                 (struct i40e_aqc_add_get_update_vsi *)&desc.params.raw;
2215         enum i40e_status_code status;
2216
2217         i40e_fill_default_direct_cmd_desc(&desc,
2218                                           i40e_aqc_opc_update_vsi_parameters);
2219         cmd->uplink_seid = CPU_TO_LE16(vsi_ctx->seid);
2220
2221         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
2222
2223         status = i40e_asq_send_command(hw, &desc, &vsi_ctx->info,
2224                                     sizeof(vsi_ctx->info), cmd_details);
2225
2226         return status;
2227 }
2228
2229 /**
2230  * i40e_aq_get_switch_config
2231  * @hw: pointer to the hardware structure
2232  * @buf: pointer to the result buffer
2233  * @buf_size: length of input buffer
2234  * @start_seid: seid to start for the report, 0 == beginning
2235  * @cmd_details: pointer to command details structure or NULL
2236  *
2237  * Fill the buf with switch configuration returned from AdminQ command
2238  **/
2239 enum i40e_status_code i40e_aq_get_switch_config(struct i40e_hw *hw,
2240                                 struct i40e_aqc_get_switch_config_resp *buf,
2241                                 u16 buf_size, u16 *start_seid,
2242                                 struct i40e_asq_cmd_details *cmd_details)
2243 {
2244         struct i40e_aq_desc desc;
2245         struct i40e_aqc_switch_seid *scfg =
2246                 (struct i40e_aqc_switch_seid *)&desc.params.raw;
2247         enum i40e_status_code status;
2248
2249         i40e_fill_default_direct_cmd_desc(&desc,
2250                                           i40e_aqc_opc_get_switch_config);
2251         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
2252         if (buf_size > I40E_AQ_LARGE_BUF)
2253                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
2254         scfg->seid = CPU_TO_LE16(*start_seid);
2255
2256         status = i40e_asq_send_command(hw, &desc, buf, buf_size, cmd_details);
2257         *start_seid = LE16_TO_CPU(scfg->seid);
2258
2259         return status;
2260 }
2261
2262 /**
2263  * i40e_aq_get_firmware_version
2264  * @hw: pointer to the hw struct
2265  * @fw_major_version: firmware major version
2266  * @fw_minor_version: firmware minor version
2267  * @fw_build: firmware build number
2268  * @api_major_version: major queue version
2269  * @api_minor_version: minor queue version
2270  * @cmd_details: pointer to command details structure or NULL
2271  *
2272  * Get the firmware version from the admin queue commands
2273  **/
2274 enum i40e_status_code i40e_aq_get_firmware_version(struct i40e_hw *hw,
2275                                 u16 *fw_major_version, u16 *fw_minor_version,
2276                                 u32 *fw_build,
2277                                 u16 *api_major_version, u16 *api_minor_version,
2278                                 struct i40e_asq_cmd_details *cmd_details)
2279 {
2280         struct i40e_aq_desc desc;
2281         struct i40e_aqc_get_version *resp =
2282                 (struct i40e_aqc_get_version *)&desc.params.raw;
2283         enum i40e_status_code status;
2284
2285         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_get_version);
2286
2287         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2288
2289         if (status == I40E_SUCCESS) {
2290                 if (fw_major_version != NULL)
2291                         *fw_major_version = LE16_TO_CPU(resp->fw_major);
2292                 if (fw_minor_version != NULL)
2293                         *fw_minor_version = LE16_TO_CPU(resp->fw_minor);
2294                 if (fw_build != NULL)
2295                         *fw_build = LE32_TO_CPU(resp->fw_build);
2296                 if (api_major_version != NULL)
2297                         *api_major_version = LE16_TO_CPU(resp->api_major);
2298                 if (api_minor_version != NULL)
2299                         *api_minor_version = LE16_TO_CPU(resp->api_minor);
2300
2301                 /* A workaround to fix the API version in SW */
2302                 if (api_major_version && api_minor_version &&
2303                     fw_major_version && fw_minor_version &&
2304                     ((*api_major_version == 1) && (*api_minor_version == 1)) &&
2305                     (((*fw_major_version == 4) && (*fw_minor_version >= 2)) ||
2306                      (*fw_major_version > 4)))
2307                         *api_minor_version = 2;
2308         }
2309
2310         return status;
2311 }
2312
2313 /**
2314  * i40e_aq_send_driver_version
2315  * @hw: pointer to the hw struct
2316  * @dv: driver's major, minor version
2317  * @cmd_details: pointer to command details structure or NULL
2318  *
2319  * Send the driver version to the firmware
2320  **/
2321 enum i40e_status_code i40e_aq_send_driver_version(struct i40e_hw *hw,
2322                                 struct i40e_driver_version *dv,
2323                                 struct i40e_asq_cmd_details *cmd_details)
2324 {
2325         struct i40e_aq_desc desc;
2326         struct i40e_aqc_driver_version *cmd =
2327                 (struct i40e_aqc_driver_version *)&desc.params.raw;
2328         enum i40e_status_code status;
2329         u16 len;
2330
2331         if (dv == NULL)
2332                 return I40E_ERR_PARAM;
2333
2334         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_driver_version);
2335
2336         desc.flags |= CPU_TO_LE16(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD);
2337         cmd->driver_major_ver = dv->major_version;
2338         cmd->driver_minor_ver = dv->minor_version;
2339         cmd->driver_build_ver = dv->build_version;
2340         cmd->driver_subbuild_ver = dv->subbuild_version;
2341
2342         len = 0;
2343         while (len < sizeof(dv->driver_string) &&
2344                (dv->driver_string[len] < 0x80) &&
2345                dv->driver_string[len])
2346                 len++;
2347         status = i40e_asq_send_command(hw, &desc, dv->driver_string,
2348                                        len, cmd_details);
2349
2350         return status;
2351 }
2352
2353 /**
2354  * i40e_get_link_status - get status of the HW network link
2355  * @hw: pointer to the hw struct
2356  * @link_up: pointer to bool (true/false = linkup/linkdown)
2357  *
2358  * Variable link_up true if link is up, false if link is down.
2359  * The variable link_up is invalid if returned value of status != I40E_SUCCESS
2360  *
2361  * Side effect: LinkStatusEvent reporting becomes enabled
2362  **/
2363 enum i40e_status_code i40e_get_link_status(struct i40e_hw *hw, bool *link_up)
2364 {
2365         enum i40e_status_code status = I40E_SUCCESS;
2366
2367         if (hw->phy.get_link_info) {
2368                 status = i40e_update_link_info(hw);
2369
2370                 if (status != I40E_SUCCESS)
2371                         i40e_debug(hw, I40E_DEBUG_LINK, "get link failed: status %d\n",
2372                                    status);
2373         }
2374
2375         *link_up = hw->phy.link_info.link_info & I40E_AQ_LINK_UP;
2376
2377         return status;
2378 }
2379
2380 /**
2381  * i40e_updatelink_status - update status of the HW network link
2382  * @hw: pointer to the hw struct
2383  **/
2384 enum i40e_status_code i40e_update_link_info(struct i40e_hw *hw)
2385 {
2386         struct i40e_aq_get_phy_abilities_resp abilities;
2387         enum i40e_status_code status = I40E_SUCCESS;
2388
2389         status = i40e_aq_get_link_info(hw, true, NULL, NULL);
2390         if (status)
2391                 return status;
2392
2393         status = i40e_aq_get_phy_capabilities(hw, false, false, &abilities,
2394                                               NULL);
2395         if (status)
2396                 return status;
2397
2398         memcpy(hw->phy.link_info.module_type, &abilities.module_type,
2399                 sizeof(hw->phy.link_info.module_type));
2400
2401         return status;
2402 }
2403
2404 /**
2405  * i40e_get_link_speed
2406  * @hw: pointer to the hw struct
2407  *
2408  * Returns the link speed of the adapter.
2409  **/
2410 enum i40e_aq_link_speed i40e_get_link_speed(struct i40e_hw *hw)
2411 {
2412         enum i40e_aq_link_speed speed = I40E_LINK_SPEED_UNKNOWN;
2413         enum i40e_status_code status = I40E_SUCCESS;
2414
2415         if (hw->phy.get_link_info) {
2416                 status = i40e_aq_get_link_info(hw, true, NULL, NULL);
2417
2418                 if (status != I40E_SUCCESS)
2419                         goto i40e_link_speed_exit;
2420         }
2421
2422         speed = hw->phy.link_info.link_speed;
2423
2424 i40e_link_speed_exit:
2425         return speed;
2426 }
2427
2428 /**
2429  * i40e_aq_add_veb - Insert a VEB between the VSI and the MAC
2430  * @hw: pointer to the hw struct
2431  * @uplink_seid: the MAC or other gizmo SEID
2432  * @downlink_seid: the VSI SEID
2433  * @enabled_tc: bitmap of TCs to be enabled
2434  * @default_port: true for default port VSI, false for control port
2435  * @enable_l2_filtering: true to add L2 filter table rules to regular forwarding rules for cloud support
2436  * @veb_seid: pointer to where to put the resulting VEB SEID
2437  * @cmd_details: pointer to command details structure or NULL
2438  *
2439  * This asks the FW to add a VEB between the uplink and downlink
2440  * elements.  If the uplink SEID is 0, this will be a floating VEB.
2441  **/
2442 enum i40e_status_code i40e_aq_add_veb(struct i40e_hw *hw, u16 uplink_seid,
2443                                 u16 downlink_seid, u8 enabled_tc,
2444                                 bool default_port, bool enable_l2_filtering,
2445                                 u16 *veb_seid,
2446                                 struct i40e_asq_cmd_details *cmd_details)
2447 {
2448         struct i40e_aq_desc desc;
2449         struct i40e_aqc_add_veb *cmd =
2450                 (struct i40e_aqc_add_veb *)&desc.params.raw;
2451         struct i40e_aqc_add_veb_completion *resp =
2452                 (struct i40e_aqc_add_veb_completion *)&desc.params.raw;
2453         enum i40e_status_code status;
2454         u16 veb_flags = 0;
2455
2456         /* SEIDs need to either both be set or both be 0 for floating VEB */
2457         if (!!uplink_seid != !!downlink_seid)
2458                 return I40E_ERR_PARAM;
2459
2460         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_add_veb);
2461
2462         cmd->uplink_seid = CPU_TO_LE16(uplink_seid);
2463         cmd->downlink_seid = CPU_TO_LE16(downlink_seid);
2464         cmd->enable_tcs = enabled_tc;
2465         if (!uplink_seid)
2466                 veb_flags |= I40E_AQC_ADD_VEB_FLOATING;
2467         if (default_port)
2468                 veb_flags |= I40E_AQC_ADD_VEB_PORT_TYPE_DEFAULT;
2469         else
2470                 veb_flags |= I40E_AQC_ADD_VEB_PORT_TYPE_DATA;
2471
2472         if (enable_l2_filtering)
2473                 veb_flags |= I40E_AQC_ADD_VEB_ENABLE_L2_FILTER;
2474
2475         cmd->veb_flags = CPU_TO_LE16(veb_flags);
2476
2477         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2478
2479         if (!status && veb_seid)
2480                 *veb_seid = LE16_TO_CPU(resp->veb_seid);
2481
2482         return status;
2483 }
2484
2485 /**
2486  * i40e_aq_get_veb_parameters - Retrieve VEB parameters
2487  * @hw: pointer to the hw struct
2488  * @veb_seid: the SEID of the VEB to query
2489  * @switch_id: the uplink switch id
2490  * @floating: set to true if the VEB is floating
2491  * @statistic_index: index of the stats counter block for this VEB
2492  * @vebs_used: number of VEB's used by function
2493  * @vebs_free: total VEB's not reserved by any function
2494  * @cmd_details: pointer to command details structure or NULL
2495  *
2496  * This retrieves the parameters for a particular VEB, specified by
2497  * uplink_seid, and returns them to the caller.
2498  **/
2499 enum i40e_status_code i40e_aq_get_veb_parameters(struct i40e_hw *hw,
2500                                 u16 veb_seid, u16 *switch_id,
2501                                 bool *floating, u16 *statistic_index,
2502                                 u16 *vebs_used, u16 *vebs_free,
2503                                 struct i40e_asq_cmd_details *cmd_details)
2504 {
2505         struct i40e_aq_desc desc;
2506         struct i40e_aqc_get_veb_parameters_completion *cmd_resp =
2507                 (struct i40e_aqc_get_veb_parameters_completion *)
2508                 &desc.params.raw;
2509         enum i40e_status_code status;
2510
2511         if (veb_seid == 0)
2512                 return I40E_ERR_PARAM;
2513
2514         i40e_fill_default_direct_cmd_desc(&desc,
2515                                           i40e_aqc_opc_get_veb_parameters);
2516         cmd_resp->seid = CPU_TO_LE16(veb_seid);
2517
2518         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2519         if (status)
2520                 goto get_veb_exit;
2521
2522         if (switch_id)
2523                 *switch_id = LE16_TO_CPU(cmd_resp->switch_id);
2524         if (statistic_index)
2525                 *statistic_index = LE16_TO_CPU(cmd_resp->statistic_index);
2526         if (vebs_used)
2527                 *vebs_used = LE16_TO_CPU(cmd_resp->vebs_used);
2528         if (vebs_free)
2529                 *vebs_free = LE16_TO_CPU(cmd_resp->vebs_free);
2530         if (floating) {
2531                 u16 flags = LE16_TO_CPU(cmd_resp->veb_flags);
2532                 if (flags & I40E_AQC_ADD_VEB_FLOATING)
2533                         *floating = true;
2534                 else
2535                         *floating = false;
2536         }
2537
2538 get_veb_exit:
2539         return status;
2540 }
2541
2542 /**
2543  * i40e_aq_add_macvlan
2544  * @hw: pointer to the hw struct
2545  * @seid: VSI for the mac address
2546  * @mv_list: list of macvlans to be added
2547  * @count: length of the list
2548  * @cmd_details: pointer to command details structure or NULL
2549  *
2550  * Add MAC/VLAN addresses to the HW filtering
2551  **/
2552 enum i40e_status_code i40e_aq_add_macvlan(struct i40e_hw *hw, u16 seid,
2553                         struct i40e_aqc_add_macvlan_element_data *mv_list,
2554                         u16 count, struct i40e_asq_cmd_details *cmd_details)
2555 {
2556         struct i40e_aq_desc desc;
2557         struct i40e_aqc_macvlan *cmd =
2558                 (struct i40e_aqc_macvlan *)&desc.params.raw;
2559         enum i40e_status_code status;
2560         u16 buf_size;
2561
2562         if (count == 0 || !mv_list || !hw)
2563                 return I40E_ERR_PARAM;
2564
2565         buf_size = count * sizeof(*mv_list);
2566
2567         /* prep the rest of the request */
2568         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_add_macvlan);
2569         cmd->num_addresses = CPU_TO_LE16(count);
2570         cmd->seid[0] = CPU_TO_LE16(I40E_AQC_MACVLAN_CMD_SEID_VALID | seid);
2571         cmd->seid[1] = 0;
2572         cmd->seid[2] = 0;
2573
2574         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
2575         if (buf_size > I40E_AQ_LARGE_BUF)
2576                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
2577
2578         status = i40e_asq_send_command(hw, &desc, mv_list, buf_size,
2579                                     cmd_details);
2580
2581         return status;
2582 }
2583
2584 /**
2585  * i40e_aq_remove_macvlan
2586  * @hw: pointer to the hw struct
2587  * @seid: VSI for the mac address
2588  * @mv_list: list of macvlans to be removed
2589  * @count: length of the list
2590  * @cmd_details: pointer to command details structure or NULL
2591  *
2592  * Remove MAC/VLAN addresses from the HW filtering
2593  **/
2594 enum i40e_status_code i40e_aq_remove_macvlan(struct i40e_hw *hw, u16 seid,
2595                         struct i40e_aqc_remove_macvlan_element_data *mv_list,
2596                         u16 count, struct i40e_asq_cmd_details *cmd_details)
2597 {
2598         struct i40e_aq_desc desc;
2599         struct i40e_aqc_macvlan *cmd =
2600                 (struct i40e_aqc_macvlan *)&desc.params.raw;
2601         enum i40e_status_code status;
2602         u16 buf_size;
2603
2604         if (count == 0 || !mv_list || !hw)
2605                 return I40E_ERR_PARAM;
2606
2607         buf_size = count * sizeof(*mv_list);
2608
2609         /* prep the rest of the request */
2610         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_remove_macvlan);
2611         cmd->num_addresses = CPU_TO_LE16(count);
2612         cmd->seid[0] = CPU_TO_LE16(I40E_AQC_MACVLAN_CMD_SEID_VALID | seid);
2613         cmd->seid[1] = 0;
2614         cmd->seid[2] = 0;
2615
2616         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
2617         if (buf_size > I40E_AQ_LARGE_BUF)
2618                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
2619
2620         status = i40e_asq_send_command(hw, &desc, mv_list, buf_size,
2621                                        cmd_details);
2622
2623         return status;
2624 }
2625
2626 /**
2627  * i40e_aq_add_vlan - Add VLAN ids to the HW filtering
2628  * @hw: pointer to the hw struct
2629  * @seid: VSI for the vlan filters
2630  * @v_list: list of vlan filters to be added
2631  * @count: length of the list
2632  * @cmd_details: pointer to command details structure or NULL
2633  **/
2634 enum i40e_status_code i40e_aq_add_vlan(struct i40e_hw *hw, u16 seid,
2635                         struct i40e_aqc_add_remove_vlan_element_data *v_list,
2636                         u8 count, struct i40e_asq_cmd_details *cmd_details)
2637 {
2638         struct i40e_aq_desc desc;
2639         struct i40e_aqc_macvlan *cmd =
2640                 (struct i40e_aqc_macvlan *)&desc.params.raw;
2641         enum i40e_status_code status;
2642         u16 buf_size;
2643
2644         if (count == 0 || !v_list || !hw)
2645                 return I40E_ERR_PARAM;
2646
2647         buf_size = count * sizeof(*v_list);
2648
2649         /* prep the rest of the request */
2650         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_add_vlan);
2651         cmd->num_addresses = CPU_TO_LE16(count);
2652         cmd->seid[0] = CPU_TO_LE16(seid | I40E_AQC_MACVLAN_CMD_SEID_VALID);
2653         cmd->seid[1] = 0;
2654         cmd->seid[2] = 0;
2655
2656         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
2657         if (buf_size > I40E_AQ_LARGE_BUF)
2658                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
2659
2660         status = i40e_asq_send_command(hw, &desc, v_list, buf_size,
2661                                        cmd_details);
2662
2663         return status;
2664 }
2665
2666 /**
2667  * i40e_aq_remove_vlan - Remove VLANs from the HW filtering
2668  * @hw: pointer to the hw struct
2669  * @seid: VSI for the vlan filters
2670  * @v_list: list of macvlans to be removed
2671  * @count: length of the list
2672  * @cmd_details: pointer to command details structure or NULL
2673  **/
2674 enum i40e_status_code i40e_aq_remove_vlan(struct i40e_hw *hw, u16 seid,
2675                         struct i40e_aqc_add_remove_vlan_element_data *v_list,
2676                         u8 count, struct i40e_asq_cmd_details *cmd_details)
2677 {
2678         struct i40e_aq_desc desc;
2679         struct i40e_aqc_macvlan *cmd =
2680                 (struct i40e_aqc_macvlan *)&desc.params.raw;
2681         enum i40e_status_code status;
2682         u16 buf_size;
2683
2684         if (count == 0 || !v_list || !hw)
2685                 return I40E_ERR_PARAM;
2686
2687         buf_size = count * sizeof(*v_list);
2688
2689         /* prep the rest of the request */
2690         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_remove_vlan);
2691         cmd->num_addresses = CPU_TO_LE16(count);
2692         cmd->seid[0] = CPU_TO_LE16(seid | I40E_AQC_MACVLAN_CMD_SEID_VALID);
2693         cmd->seid[1] = 0;
2694         cmd->seid[2] = 0;
2695
2696         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
2697         if (buf_size > I40E_AQ_LARGE_BUF)
2698                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
2699
2700         status = i40e_asq_send_command(hw, &desc, v_list, buf_size,
2701                                        cmd_details);
2702
2703         return status;
2704 }
2705
2706 /**
2707  * i40e_aq_send_msg_to_vf
2708  * @hw: pointer to the hardware structure
2709  * @vfid: vf id to send msg
2710  * @v_opcode: opcodes for VF-PF communication
2711  * @v_retval: return error code
2712  * @msg: pointer to the msg buffer
2713  * @msglen: msg length
2714  * @cmd_details: pointer to command details
2715  *
2716  * send msg to vf
2717  **/
2718 enum i40e_status_code i40e_aq_send_msg_to_vf(struct i40e_hw *hw, u16 vfid,
2719                                 u32 v_opcode, u32 v_retval, u8 *msg, u16 msglen,
2720                                 struct i40e_asq_cmd_details *cmd_details)
2721 {
2722         struct i40e_aq_desc desc;
2723         struct i40e_aqc_pf_vf_message *cmd =
2724                 (struct i40e_aqc_pf_vf_message *)&desc.params.raw;
2725         enum i40e_status_code status;
2726
2727         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_send_msg_to_vf);
2728         cmd->id = CPU_TO_LE32(vfid);
2729         desc.cookie_high = CPU_TO_LE32(v_opcode);
2730         desc.cookie_low = CPU_TO_LE32(v_retval);
2731         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_SI);
2732         if (msglen) {
2733                 desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF |
2734                                                 I40E_AQ_FLAG_RD));
2735                 if (msglen > I40E_AQ_LARGE_BUF)
2736                         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
2737                 desc.datalen = CPU_TO_LE16(msglen);
2738         }
2739         status = i40e_asq_send_command(hw, &desc, msg, msglen, cmd_details);
2740
2741         return status;
2742 }
2743
2744 /**
2745  * i40e_aq_debug_read_register
2746  * @hw: pointer to the hw struct
2747  * @reg_addr: register address
2748  * @reg_val: register value
2749  * @cmd_details: pointer to command details structure or NULL
2750  *
2751  * Read the register using the admin queue commands
2752  **/
2753 enum i40e_status_code i40e_aq_debug_read_register(struct i40e_hw *hw,
2754                                 u32 reg_addr, u64 *reg_val,
2755                                 struct i40e_asq_cmd_details *cmd_details)
2756 {
2757         struct i40e_aq_desc desc;
2758         struct i40e_aqc_debug_reg_read_write *cmd_resp =
2759                 (struct i40e_aqc_debug_reg_read_write *)&desc.params.raw;
2760         enum i40e_status_code status;
2761
2762         if (reg_val == NULL)
2763                 return I40E_ERR_PARAM;
2764
2765         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_debug_read_reg);
2766
2767         cmd_resp->address = CPU_TO_LE32(reg_addr);
2768
2769         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2770
2771         if (status == I40E_SUCCESS) {
2772                 *reg_val = ((u64)LE32_TO_CPU(cmd_resp->value_high) << 32) |
2773                            (u64)LE32_TO_CPU(cmd_resp->value_low);
2774         }
2775
2776         return status;
2777 }
2778
2779 /**
2780  * i40e_aq_debug_write_register
2781  * @hw: pointer to the hw struct
2782  * @reg_addr: register address
2783  * @reg_val: register value
2784  * @cmd_details: pointer to command details structure or NULL
2785  *
2786  * Write to a register using the admin queue commands
2787  **/
2788 enum i40e_status_code i40e_aq_debug_write_register(struct i40e_hw *hw,
2789                                 u32 reg_addr, u64 reg_val,
2790                                 struct i40e_asq_cmd_details *cmd_details)
2791 {
2792         struct i40e_aq_desc desc;
2793         struct i40e_aqc_debug_reg_read_write *cmd =
2794                 (struct i40e_aqc_debug_reg_read_write *)&desc.params.raw;
2795         enum i40e_status_code status;
2796
2797         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_debug_write_reg);
2798
2799         cmd->address = CPU_TO_LE32(reg_addr);
2800         cmd->value_high = CPU_TO_LE32((u32)(reg_val >> 32));
2801         cmd->value_low = CPU_TO_LE32((u32)(reg_val & 0xFFFFFFFF));
2802
2803         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2804
2805         return status;
2806 }
2807
2808 /**
2809  * i40e_aq_get_hmc_resource_profile
2810  * @hw: pointer to the hw struct
2811  * @profile: type of profile the HMC is to be set as
2812  * @pe_vf_enabled_count: the number of PE enabled VFs the system has
2813  * @cmd_details: pointer to command details structure or NULL
2814  *
2815  * query the HMC profile of the device.
2816  **/
2817 enum i40e_status_code i40e_aq_get_hmc_resource_profile(struct i40e_hw *hw,
2818                                 enum i40e_aq_hmc_profile *profile,
2819                                 u8 *pe_vf_enabled_count,
2820                                 struct i40e_asq_cmd_details *cmd_details)
2821 {
2822         struct i40e_aq_desc desc;
2823         struct i40e_aq_get_set_hmc_resource_profile *resp =
2824                 (struct i40e_aq_get_set_hmc_resource_profile *)&desc.params.raw;
2825         enum i40e_status_code status;
2826
2827         i40e_fill_default_direct_cmd_desc(&desc,
2828                                 i40e_aqc_opc_query_hmc_resource_profile);
2829         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2830
2831         *profile = (enum i40e_aq_hmc_profile)(resp->pm_profile &
2832                    I40E_AQ_GET_HMC_RESOURCE_PROFILE_PM_MASK);
2833         *pe_vf_enabled_count = resp->pe_vf_enabled &
2834                                I40E_AQ_GET_HMC_RESOURCE_PROFILE_COUNT_MASK;
2835
2836         return status;
2837 }
2838
2839 /**
2840  * i40e_aq_set_hmc_resource_profile
2841  * @hw: pointer to the hw struct
2842  * @profile: type of profile the HMC is to be set as
2843  * @pe_vf_enabled_count: the number of PE enabled VFs the system has
2844  * @cmd_details: pointer to command details structure or NULL
2845  *
2846  * set the HMC profile of the device.
2847  **/
2848 enum i40e_status_code i40e_aq_set_hmc_resource_profile(struct i40e_hw *hw,
2849                                 enum i40e_aq_hmc_profile profile,
2850                                 u8 pe_vf_enabled_count,
2851                                 struct i40e_asq_cmd_details *cmd_details)
2852 {
2853         struct i40e_aq_desc desc;
2854         struct i40e_aq_get_set_hmc_resource_profile *cmd =
2855                 (struct i40e_aq_get_set_hmc_resource_profile *)&desc.params.raw;
2856         enum i40e_status_code status;
2857
2858         i40e_fill_default_direct_cmd_desc(&desc,
2859                                         i40e_aqc_opc_set_hmc_resource_profile);
2860
2861         cmd->pm_profile = (u8)profile;
2862         cmd->pe_vf_enabled = pe_vf_enabled_count;
2863
2864         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2865
2866         return status;
2867 }
2868
2869 /**
2870  * i40e_aq_request_resource
2871  * @hw: pointer to the hw struct
2872  * @resource: resource id
2873  * @access: access type
2874  * @sdp_number: resource number
2875  * @timeout: the maximum time in ms that the driver may hold the resource
2876  * @cmd_details: pointer to command details structure or NULL
2877  *
2878  * requests common resource using the admin queue commands
2879  **/
2880 enum i40e_status_code i40e_aq_request_resource(struct i40e_hw *hw,
2881                                 enum i40e_aq_resources_ids resource,
2882                                 enum i40e_aq_resource_access_type access,
2883                                 u8 sdp_number, u64 *timeout,
2884                                 struct i40e_asq_cmd_details *cmd_details)
2885 {
2886         struct i40e_aq_desc desc;
2887         struct i40e_aqc_request_resource *cmd_resp =
2888                 (struct i40e_aqc_request_resource *)&desc.params.raw;
2889         enum i40e_status_code status;
2890
2891         DEBUGFUNC("i40e_aq_request_resource");
2892
2893         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_request_resource);
2894
2895         cmd_resp->resource_id = CPU_TO_LE16(resource);
2896         cmd_resp->access_type = CPU_TO_LE16(access);
2897         cmd_resp->resource_number = CPU_TO_LE32(sdp_number);
2898
2899         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2900         /* The completion specifies the maximum time in ms that the driver
2901          * may hold the resource in the Timeout field.
2902          * If the resource is held by someone else, the command completes with
2903          * busy return value and the timeout field indicates the maximum time
2904          * the current owner of the resource has to free it.
2905          */
2906         if (status == I40E_SUCCESS || hw->aq.asq_last_status == I40E_AQ_RC_EBUSY)
2907                 *timeout = LE32_TO_CPU(cmd_resp->timeout);
2908
2909         return status;
2910 }
2911
2912 /**
2913  * i40e_aq_release_resource
2914  * @hw: pointer to the hw struct
2915  * @resource: resource id
2916  * @sdp_number: resource number
2917  * @cmd_details: pointer to command details structure or NULL
2918  *
2919  * release common resource using the admin queue commands
2920  **/
2921 enum i40e_status_code i40e_aq_release_resource(struct i40e_hw *hw,
2922                                 enum i40e_aq_resources_ids resource,
2923                                 u8 sdp_number,
2924                                 struct i40e_asq_cmd_details *cmd_details)
2925 {
2926         struct i40e_aq_desc desc;
2927         struct i40e_aqc_request_resource *cmd =
2928                 (struct i40e_aqc_request_resource *)&desc.params.raw;
2929         enum i40e_status_code status;
2930
2931         DEBUGFUNC("i40e_aq_release_resource");
2932
2933         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_release_resource);
2934
2935         cmd->resource_id = CPU_TO_LE16(resource);
2936         cmd->resource_number = CPU_TO_LE32(sdp_number);
2937
2938         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
2939
2940         return status;
2941 }
2942
2943 /**
2944  * i40e_aq_read_nvm
2945  * @hw: pointer to the hw struct
2946  * @module_pointer: module pointer location in words from the NVM beginning
2947  * @offset: byte offset from the module beginning
2948  * @length: length of the section to be read (in bytes from the offset)
2949  * @data: command buffer (size [bytes] = length)
2950  * @last_command: tells if this is the last command in a series
2951  * @cmd_details: pointer to command details structure or NULL
2952  *
2953  * Read the NVM using the admin queue commands
2954  **/
2955 enum i40e_status_code i40e_aq_read_nvm(struct i40e_hw *hw, u8 module_pointer,
2956                                 u32 offset, u16 length, void *data,
2957                                 bool last_command,
2958                                 struct i40e_asq_cmd_details *cmd_details)
2959 {
2960         struct i40e_aq_desc desc;
2961         struct i40e_aqc_nvm_update *cmd =
2962                 (struct i40e_aqc_nvm_update *)&desc.params.raw;
2963         enum i40e_status_code status;
2964
2965         DEBUGFUNC("i40e_aq_read_nvm");
2966
2967         /* In offset the highest byte must be zeroed. */
2968         if (offset & 0xFF000000) {
2969                 status = I40E_ERR_PARAM;
2970                 goto i40e_aq_read_nvm_exit;
2971         }
2972
2973         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_nvm_read);
2974
2975         /* If this is the last command in a series, set the proper flag. */
2976         if (last_command)
2977                 cmd->command_flags |= I40E_AQ_NVM_LAST_CMD;
2978         cmd->module_pointer = module_pointer;
2979         cmd->offset = CPU_TO_LE32(offset);
2980         cmd->length = CPU_TO_LE16(length);
2981
2982         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
2983         if (length > I40E_AQ_LARGE_BUF)
2984                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
2985
2986         status = i40e_asq_send_command(hw, &desc, data, length, cmd_details);
2987
2988 i40e_aq_read_nvm_exit:
2989         return status;
2990 }
2991
2992 /**
2993  * i40e_aq_read_nvm_config - read an nvm config block
2994  * @hw: pointer to the hw struct
2995  * @cmd_flags: NVM access admin command bits
2996  * @field_id: field or feature id
2997  * @data: buffer for result
2998  * @buf_size: buffer size
2999  * @element_count: pointer to count of elements read by FW
3000  * @cmd_details: pointer to command details structure or NULL
3001  **/
3002 enum i40e_status_code i40e_aq_read_nvm_config(struct i40e_hw *hw,
3003                                 u8 cmd_flags, u32 field_id, void *data,
3004                                 u16 buf_size, u16 *element_count,
3005                                 struct i40e_asq_cmd_details *cmd_details)
3006 {
3007         struct i40e_aq_desc desc;
3008         struct i40e_aqc_nvm_config_read *cmd =
3009                 (struct i40e_aqc_nvm_config_read *)&desc.params.raw;
3010         enum i40e_status_code status;
3011
3012         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_nvm_config_read);
3013         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF));
3014         if (buf_size > I40E_AQ_LARGE_BUF)
3015                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3016
3017         cmd->cmd_flags = CPU_TO_LE16(cmd_flags);
3018         cmd->element_id = CPU_TO_LE16((u16)(0xffff & field_id));
3019         if (cmd_flags & I40E_AQ_ANVM_FEATURE_OR_IMMEDIATE_MASK)
3020                 cmd->element_id_msw = CPU_TO_LE16((u16)(field_id >> 16));
3021         else
3022                 cmd->element_id_msw = 0;
3023
3024         status = i40e_asq_send_command(hw, &desc, data, buf_size, cmd_details);
3025
3026         if (!status && element_count)
3027                 *element_count = LE16_TO_CPU(cmd->element_count);
3028
3029         return status;
3030 }
3031
3032 /**
3033  * i40e_aq_write_nvm_config - write an nvm config block
3034  * @hw: pointer to the hw struct
3035  * @cmd_flags: NVM access admin command bits
3036  * @data: buffer for result
3037  * @buf_size: buffer size
3038  * @element_count: count of elements to be written
3039  * @cmd_details: pointer to command details structure or NULL
3040  **/
3041 enum i40e_status_code i40e_aq_write_nvm_config(struct i40e_hw *hw,
3042                                 u8 cmd_flags, void *data, u16 buf_size,
3043                                 u16 element_count,
3044                                 struct i40e_asq_cmd_details *cmd_details)
3045 {
3046         struct i40e_aq_desc desc;
3047         struct i40e_aqc_nvm_config_write *cmd =
3048                 (struct i40e_aqc_nvm_config_write *)&desc.params.raw;
3049         enum i40e_status_code status;
3050
3051         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_nvm_config_write);
3052         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
3053         if (buf_size > I40E_AQ_LARGE_BUF)
3054                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3055
3056         cmd->element_count = CPU_TO_LE16(element_count);
3057         cmd->cmd_flags = CPU_TO_LE16(cmd_flags);
3058         status = i40e_asq_send_command(hw, &desc, data, buf_size, cmd_details);
3059
3060         return status;
3061 }
3062
3063 /**
3064  * i40e_aq_erase_nvm
3065  * @hw: pointer to the hw struct
3066  * @module_pointer: module pointer location in words from the NVM beginning
3067  * @offset: offset in the module (expressed in 4 KB from module's beginning)
3068  * @length: length of the section to be erased (expressed in 4 KB)
3069  * @last_command: tells if this is the last command in a series
3070  * @cmd_details: pointer to command details structure or NULL
3071  *
3072  * Erase the NVM sector using the admin queue commands
3073  **/
3074 enum i40e_status_code i40e_aq_erase_nvm(struct i40e_hw *hw, u8 module_pointer,
3075                                 u32 offset, u16 length, bool last_command,
3076                                 struct i40e_asq_cmd_details *cmd_details)
3077 {
3078         struct i40e_aq_desc desc;
3079         struct i40e_aqc_nvm_update *cmd =
3080                 (struct i40e_aqc_nvm_update *)&desc.params.raw;
3081         enum i40e_status_code status;
3082
3083         DEBUGFUNC("i40e_aq_erase_nvm");
3084
3085         /* In offset the highest byte must be zeroed. */
3086         if (offset & 0xFF000000) {
3087                 status = I40E_ERR_PARAM;
3088                 goto i40e_aq_erase_nvm_exit;
3089         }
3090
3091         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_nvm_erase);
3092
3093         /* If this is the last command in a series, set the proper flag. */
3094         if (last_command)
3095                 cmd->command_flags |= I40E_AQ_NVM_LAST_CMD;
3096         cmd->module_pointer = module_pointer;
3097         cmd->offset = CPU_TO_LE32(offset);
3098         cmd->length = CPU_TO_LE16(length);
3099
3100         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
3101
3102 i40e_aq_erase_nvm_exit:
3103         return status;
3104 }
3105
3106 #define I40E_DEV_FUNC_CAP_SWITCH_MODE   0x01
3107 #define I40E_DEV_FUNC_CAP_MGMT_MODE     0x02
3108 #define I40E_DEV_FUNC_CAP_NPAR          0x03
3109 #define I40E_DEV_FUNC_CAP_OS2BMC        0x04
3110 #define I40E_DEV_FUNC_CAP_VALID_FUNC    0x05
3111 #define I40E_DEV_FUNC_CAP_SRIOV_1_1     0x12
3112 #define I40E_DEV_FUNC_CAP_VF            0x13
3113 #define I40E_DEV_FUNC_CAP_VMDQ          0x14
3114 #define I40E_DEV_FUNC_CAP_802_1_QBG     0x15
3115 #define I40E_DEV_FUNC_CAP_802_1_QBH     0x16
3116 #define I40E_DEV_FUNC_CAP_VSI           0x17
3117 #define I40E_DEV_FUNC_CAP_DCB           0x18
3118 #define I40E_DEV_FUNC_CAP_FCOE          0x21
3119 #define I40E_DEV_FUNC_CAP_ISCSI         0x22
3120 #define I40E_DEV_FUNC_CAP_RSS           0x40
3121 #define I40E_DEV_FUNC_CAP_RX_QUEUES     0x41
3122 #define I40E_DEV_FUNC_CAP_TX_QUEUES     0x42
3123 #define I40E_DEV_FUNC_CAP_MSIX          0x43
3124 #define I40E_DEV_FUNC_CAP_MSIX_VF       0x44
3125 #define I40E_DEV_FUNC_CAP_FLOW_DIRECTOR 0x45
3126 #define I40E_DEV_FUNC_CAP_IEEE_1588     0x46
3127 #define I40E_DEV_FUNC_CAP_MFP_MODE_1    0xF1
3128 #define I40E_DEV_FUNC_CAP_CEM           0xF2
3129 #define I40E_DEV_FUNC_CAP_IWARP         0x51
3130 #define I40E_DEV_FUNC_CAP_LED           0x61
3131 #define I40E_DEV_FUNC_CAP_SDP           0x62
3132 #define I40E_DEV_FUNC_CAP_MDIO          0x63
3133
3134 /**
3135  * i40e_parse_discover_capabilities
3136  * @hw: pointer to the hw struct
3137  * @buff: pointer to a buffer containing device/function capability records
3138  * @cap_count: number of capability records in the list
3139  * @list_type_opc: type of capabilities list to parse
3140  *
3141  * Parse the device/function capabilities list.
3142  **/
3143 STATIC void i40e_parse_discover_capabilities(struct i40e_hw *hw, void *buff,
3144                                      u32 cap_count,
3145                                      enum i40e_admin_queue_opc list_type_opc)
3146 {
3147         struct i40e_aqc_list_capabilities_element_resp *cap;
3148         u32 valid_functions, num_functions;
3149         u32 number, logical_id, phys_id;
3150         struct i40e_hw_capabilities *p;
3151         u32 i = 0;
3152         u16 id;
3153
3154         cap = (struct i40e_aqc_list_capabilities_element_resp *) buff;
3155
3156         if (list_type_opc == i40e_aqc_opc_list_dev_capabilities)
3157                 p = (struct i40e_hw_capabilities *)&hw->dev_caps;
3158         else if (list_type_opc == i40e_aqc_opc_list_func_capabilities)
3159                 p = (struct i40e_hw_capabilities *)&hw->func_caps;
3160         else
3161                 return;
3162
3163         for (i = 0; i < cap_count; i++, cap++) {
3164                 id = LE16_TO_CPU(cap->id);
3165                 number = LE32_TO_CPU(cap->number);
3166                 logical_id = LE32_TO_CPU(cap->logical_id);
3167                 phys_id = LE32_TO_CPU(cap->phys_id);
3168
3169                 switch (id) {
3170                 case I40E_DEV_FUNC_CAP_SWITCH_MODE:
3171                         p->switch_mode = number;
3172                         break;
3173                 case I40E_DEV_FUNC_CAP_MGMT_MODE:
3174                         p->management_mode = number;
3175                         break;
3176                 case I40E_DEV_FUNC_CAP_NPAR:
3177                         p->npar_enable = number;
3178                         break;
3179                 case I40E_DEV_FUNC_CAP_OS2BMC:
3180                         p->os2bmc = number;
3181                         break;
3182                 case I40E_DEV_FUNC_CAP_VALID_FUNC:
3183                         p->valid_functions = number;
3184                         break;
3185                 case I40E_DEV_FUNC_CAP_SRIOV_1_1:
3186                         if (number == 1)
3187                                 p->sr_iov_1_1 = true;
3188                         break;
3189                 case I40E_DEV_FUNC_CAP_VF:
3190                         p->num_vfs = number;
3191                         p->vf_base_id = logical_id;
3192                         break;
3193                 case I40E_DEV_FUNC_CAP_VMDQ:
3194                         if (number == 1)
3195                                 p->vmdq = true;
3196                         break;
3197                 case I40E_DEV_FUNC_CAP_802_1_QBG:
3198                         if (number == 1)
3199                                 p->evb_802_1_qbg = true;
3200                         break;
3201                 case I40E_DEV_FUNC_CAP_802_1_QBH:
3202                         if (number == 1)
3203                                 p->evb_802_1_qbh = true;
3204                         break;
3205                 case I40E_DEV_FUNC_CAP_VSI:
3206                         p->num_vsis = number;
3207                         break;
3208                 case I40E_DEV_FUNC_CAP_DCB:
3209                         if (number == 1) {
3210                                 p->dcb = true;
3211                                 p->enabled_tcmap = logical_id;
3212                                 p->maxtc = phys_id;
3213                         }
3214                         break;
3215                 case I40E_DEV_FUNC_CAP_FCOE:
3216                         if (number == 1)
3217                                 p->fcoe = true;
3218                         break;
3219                 case I40E_DEV_FUNC_CAP_ISCSI:
3220                         if (number == 1)
3221                                 p->iscsi = true;
3222                         break;
3223                 case I40E_DEV_FUNC_CAP_RSS:
3224                         p->rss = true;
3225                         p->rss_table_size = number;
3226                         p->rss_table_entry_width = logical_id;
3227                         break;
3228                 case I40E_DEV_FUNC_CAP_RX_QUEUES:
3229                         p->num_rx_qp = number;
3230                         p->base_queue = phys_id;
3231                         break;
3232                 case I40E_DEV_FUNC_CAP_TX_QUEUES:
3233                         p->num_tx_qp = number;
3234                         p->base_queue = phys_id;
3235                         break;
3236                 case I40E_DEV_FUNC_CAP_MSIX:
3237                         p->num_msix_vectors = number;
3238                         break;
3239                 case I40E_DEV_FUNC_CAP_MSIX_VF:
3240                         p->num_msix_vectors_vf = number;
3241                         break;
3242                 case I40E_DEV_FUNC_CAP_MFP_MODE_1:
3243                         if (number == 1)
3244                                 p->mfp_mode_1 = true;
3245                         break;
3246                 case I40E_DEV_FUNC_CAP_CEM:
3247                         if (number == 1)
3248                                 p->mgmt_cem = true;
3249                         break;
3250                 case I40E_DEV_FUNC_CAP_IWARP:
3251                         if (number == 1)
3252                                 p->iwarp = true;
3253                         break;
3254                 case I40E_DEV_FUNC_CAP_LED:
3255                         if (phys_id < I40E_HW_CAP_MAX_GPIO)
3256                                 p->led[phys_id] = true;
3257                         break;
3258                 case I40E_DEV_FUNC_CAP_SDP:
3259                         if (phys_id < I40E_HW_CAP_MAX_GPIO)
3260                                 p->sdp[phys_id] = true;
3261                         break;
3262                 case I40E_DEV_FUNC_CAP_MDIO:
3263                         if (number == 1) {
3264                                 p->mdio_port_num = phys_id;
3265                                 p->mdio_port_mode = logical_id;
3266                         }
3267                         break;
3268                 case I40E_DEV_FUNC_CAP_IEEE_1588:
3269                         if (number == 1)
3270                                 p->ieee_1588 = true;
3271                         break;
3272                 case I40E_DEV_FUNC_CAP_FLOW_DIRECTOR:
3273                         p->fd = true;
3274                         p->fd_filters_guaranteed = number;
3275                         p->fd_filters_best_effort = logical_id;
3276                         break;
3277                 default:
3278                         break;
3279                 }
3280         }
3281
3282 #ifdef I40E_FCOE_ENA
3283         /* Software override ensuring FCoE is disabled if npar or mfp
3284          * mode because it is not supported in these modes.
3285          */
3286         if (p->npar_enable || p->mfp_mode_1)
3287                 p->fcoe = false;
3288 #else
3289         /* Always disable FCoE if compiled without the I40E_FCOE_ENA flag */
3290         p->fcoe = false;
3291 #endif
3292
3293         /* count the enabled ports (aka the "not disabled" ports) */
3294         hw->num_ports = 0;
3295         for (i = 0; i < 4; i++) {
3296                 u32 port_cfg_reg = I40E_PRTGEN_CNF + (4 * i);
3297                 u64 port_cfg = 0;
3298
3299                 /* use AQ read to get the physical register offset instead
3300                  * of the port relative offset
3301                  */
3302                 i40e_aq_debug_read_register(hw, port_cfg_reg, &port_cfg, NULL);
3303                 if (!(port_cfg & I40E_PRTGEN_CNF_PORT_DIS_MASK))
3304                         hw->num_ports++;
3305         }
3306
3307         valid_functions = p->valid_functions;
3308         num_functions = 0;
3309         while (valid_functions) {
3310                 if (valid_functions & 1)
3311                         num_functions++;
3312                 valid_functions >>= 1;
3313         }
3314
3315         /* partition id is 1-based, and functions are evenly spread
3316          * across the ports as partitions
3317          */
3318         hw->partition_id = (hw->pf_id / hw->num_ports) + 1;
3319         hw->num_partitions = num_functions / hw->num_ports;
3320
3321         /* additional HW specific goodies that might
3322          * someday be HW version specific
3323          */
3324         p->rx_buf_chain_len = I40E_MAX_CHAINED_RX_BUFFERS;
3325 }
3326
3327 /**
3328  * i40e_aq_discover_capabilities
3329  * @hw: pointer to the hw struct
3330  * @buff: a virtual buffer to hold the capabilities
3331  * @buff_size: Size of the virtual buffer
3332  * @data_size: Size of the returned data, or buff size needed if AQ err==ENOMEM
3333  * @list_type_opc: capabilities type to discover - pass in the command opcode
3334  * @cmd_details: pointer to command details structure or NULL
3335  *
3336  * Get the device capabilities descriptions from the firmware
3337  **/
3338 enum i40e_status_code i40e_aq_discover_capabilities(struct i40e_hw *hw,
3339                                 void *buff, u16 buff_size, u16 *data_size,
3340                                 enum i40e_admin_queue_opc list_type_opc,
3341                                 struct i40e_asq_cmd_details *cmd_details)
3342 {
3343         struct i40e_aqc_list_capabilites *cmd;
3344         struct i40e_aq_desc desc;
3345         enum i40e_status_code status = I40E_SUCCESS;
3346
3347         cmd = (struct i40e_aqc_list_capabilites *)&desc.params.raw;
3348
3349         if (list_type_opc != i40e_aqc_opc_list_func_capabilities &&
3350                 list_type_opc != i40e_aqc_opc_list_dev_capabilities) {
3351                 status = I40E_ERR_PARAM;
3352                 goto exit;
3353         }
3354
3355         i40e_fill_default_direct_cmd_desc(&desc, list_type_opc);
3356
3357         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
3358         if (buff_size > I40E_AQ_LARGE_BUF)
3359                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3360
3361         status = i40e_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
3362         *data_size = LE16_TO_CPU(desc.datalen);
3363
3364         if (status)
3365                 goto exit;
3366
3367         i40e_parse_discover_capabilities(hw, buff, LE32_TO_CPU(cmd->count),
3368                                          list_type_opc);
3369
3370 exit:
3371         return status;
3372 }
3373
3374 /**
3375  * i40e_aq_update_nvm
3376  * @hw: pointer to the hw struct
3377  * @module_pointer: module pointer location in words from the NVM beginning
3378  * @offset: byte offset from the module beginning
3379  * @length: length of the section to be written (in bytes from the offset)
3380  * @data: command buffer (size [bytes] = length)
3381  * @last_command: tells if this is the last command in a series
3382  * @cmd_details: pointer to command details structure or NULL
3383  *
3384  * Update the NVM using the admin queue commands
3385  **/
3386 enum i40e_status_code i40e_aq_update_nvm(struct i40e_hw *hw, u8 module_pointer,
3387                                 u32 offset, u16 length, void *data,
3388                                 bool last_command,
3389                                 struct i40e_asq_cmd_details *cmd_details)
3390 {
3391         struct i40e_aq_desc desc;
3392         struct i40e_aqc_nvm_update *cmd =
3393                 (struct i40e_aqc_nvm_update *)&desc.params.raw;
3394         enum i40e_status_code status;
3395
3396         DEBUGFUNC("i40e_aq_update_nvm");
3397
3398         /* In offset the highest byte must be zeroed. */
3399         if (offset & 0xFF000000) {
3400                 status = I40E_ERR_PARAM;
3401                 goto i40e_aq_update_nvm_exit;
3402         }
3403
3404         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_nvm_update);
3405
3406         /* If this is the last command in a series, set the proper flag. */
3407         if (last_command)
3408                 cmd->command_flags |= I40E_AQ_NVM_LAST_CMD;
3409         cmd->module_pointer = module_pointer;
3410         cmd->offset = CPU_TO_LE32(offset);
3411         cmd->length = CPU_TO_LE16(length);
3412
3413         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
3414         if (length > I40E_AQ_LARGE_BUF)
3415                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3416
3417         status = i40e_asq_send_command(hw, &desc, data, length, cmd_details);
3418
3419 i40e_aq_update_nvm_exit:
3420         return status;
3421 }
3422
3423 /**
3424  * i40e_aq_get_lldp_mib
3425  * @hw: pointer to the hw struct
3426  * @bridge_type: type of bridge requested
3427  * @mib_type: Local, Remote or both Local and Remote MIBs
3428  * @buff: pointer to a user supplied buffer to store the MIB block
3429  * @buff_size: size of the buffer (in bytes)
3430  * @local_len : length of the returned Local LLDP MIB
3431  * @remote_len: length of the returned Remote LLDP MIB
3432  * @cmd_details: pointer to command details structure or NULL
3433  *
3434  * Requests the complete LLDP MIB (entire packet).
3435  **/
3436 enum i40e_status_code i40e_aq_get_lldp_mib(struct i40e_hw *hw, u8 bridge_type,
3437                                 u8 mib_type, void *buff, u16 buff_size,
3438                                 u16 *local_len, u16 *remote_len,
3439                                 struct i40e_asq_cmd_details *cmd_details)
3440 {
3441         struct i40e_aq_desc desc;
3442         struct i40e_aqc_lldp_get_mib *cmd =
3443                 (struct i40e_aqc_lldp_get_mib *)&desc.params.raw;
3444         struct i40e_aqc_lldp_get_mib *resp =
3445                 (struct i40e_aqc_lldp_get_mib *)&desc.params.raw;
3446         enum i40e_status_code status;
3447
3448         if (buff_size == 0 || !buff)
3449                 return I40E_ERR_PARAM;
3450
3451         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_lldp_get_mib);
3452         /* Indirect Command */
3453         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
3454
3455         cmd->type = mib_type & I40E_AQ_LLDP_MIB_TYPE_MASK;
3456         cmd->type |= ((bridge_type << I40E_AQ_LLDP_BRIDGE_TYPE_SHIFT) &
3457                        I40E_AQ_LLDP_BRIDGE_TYPE_MASK);
3458
3459         desc.datalen = CPU_TO_LE16(buff_size);
3460
3461         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
3462         if (buff_size > I40E_AQ_LARGE_BUF)
3463                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3464
3465         status = i40e_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
3466         if (!status) {
3467                 if (local_len != NULL)
3468                         *local_len = LE16_TO_CPU(resp->local_len);
3469                 if (remote_len != NULL)
3470                         *remote_len = LE16_TO_CPU(resp->remote_len);
3471         }
3472
3473         return status;
3474 }
3475
3476  /**
3477  * i40e_aq_set_lldp_mib - Set the LLDP MIB
3478  * @hw: pointer to the hw struct
3479  * @mib_type: Local, Remote or both Local and Remote MIBs
3480  * @buff: pointer to a user supplied buffer to store the MIB block
3481  * @buff_size: size of the buffer (in bytes)
3482  * @cmd_details: pointer to command details structure or NULL
3483  *
3484  * Set the LLDP MIB.
3485  **/
3486 enum i40e_status_code i40e_aq_set_lldp_mib(struct i40e_hw *hw,
3487                                 u8 mib_type, void *buff, u16 buff_size,
3488                                 struct i40e_asq_cmd_details *cmd_details)
3489 {
3490         struct i40e_aq_desc desc;
3491         struct i40e_aqc_lldp_set_local_mib *cmd =
3492                 (struct i40e_aqc_lldp_set_local_mib *)&desc.params.raw;
3493         enum i40e_status_code status;
3494
3495         if (buff_size == 0 || !buff)
3496                 return I40E_ERR_PARAM;
3497
3498         i40e_fill_default_direct_cmd_desc(&desc,
3499                                 i40e_aqc_opc_lldp_set_local_mib);
3500         /* Indirect Command */
3501         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
3502         if (buff_size > I40E_AQ_LARGE_BUF)
3503                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3504         desc.datalen = CPU_TO_LE16(buff_size);
3505
3506         cmd->type = mib_type;
3507         cmd->length = CPU_TO_LE16(buff_size);
3508         cmd->address_high = CPU_TO_LE32(I40E_HI_WORD((u64)buff));
3509         cmd->address_low =  CPU_TO_LE32(I40E_LO_DWORD((u64)buff));
3510
3511         status = i40e_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
3512         return status;
3513 }
3514
3515 /**
3516  * i40e_aq_cfg_lldp_mib_change_event
3517  * @hw: pointer to the hw struct
3518  * @enable_update: Enable or Disable event posting
3519  * @cmd_details: pointer to command details structure or NULL
3520  *
3521  * Enable or Disable posting of an event on ARQ when LLDP MIB
3522  * associated with the interface changes
3523  **/
3524 enum i40e_status_code i40e_aq_cfg_lldp_mib_change_event(struct i40e_hw *hw,
3525                                 bool enable_update,
3526                                 struct i40e_asq_cmd_details *cmd_details)
3527 {
3528         struct i40e_aq_desc desc;
3529         struct i40e_aqc_lldp_update_mib *cmd =
3530                 (struct i40e_aqc_lldp_update_mib *)&desc.params.raw;
3531         enum i40e_status_code status;
3532
3533         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_lldp_update_mib);
3534
3535         if (!enable_update)
3536                 cmd->command |= I40E_AQ_LLDP_MIB_UPDATE_DISABLE;
3537
3538         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
3539
3540         return status;
3541 }
3542
3543 /**
3544  * i40e_aq_add_lldp_tlv
3545  * @hw: pointer to the hw struct
3546  * @bridge_type: type of bridge
3547  * @buff: buffer with TLV to add
3548  * @buff_size: length of the buffer
3549  * @tlv_len: length of the TLV to be added
3550  * @mib_len: length of the LLDP MIB returned in response
3551  * @cmd_details: pointer to command details structure or NULL
3552  *
3553  * Add the specified TLV to LLDP Local MIB for the given bridge type,
3554  * it is responsibility of the caller to make sure that the TLV is not
3555  * already present in the LLDPDU.
3556  * In return firmware will write the complete LLDP MIB with the newly
3557  * added TLV in the response buffer.
3558  **/
3559 enum i40e_status_code i40e_aq_add_lldp_tlv(struct i40e_hw *hw, u8 bridge_type,
3560                                 void *buff, u16 buff_size, u16 tlv_len,
3561                                 u16 *mib_len,
3562                                 struct i40e_asq_cmd_details *cmd_details)
3563 {
3564         struct i40e_aq_desc desc;
3565         struct i40e_aqc_lldp_add_tlv *cmd =
3566                 (struct i40e_aqc_lldp_add_tlv *)&desc.params.raw;
3567         enum i40e_status_code status;
3568
3569         if (buff_size == 0 || !buff || tlv_len == 0)
3570                 return I40E_ERR_PARAM;
3571
3572         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_lldp_add_tlv);
3573
3574         /* Indirect Command */
3575         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
3576         if (buff_size > I40E_AQ_LARGE_BUF)
3577                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3578         desc.datalen = CPU_TO_LE16(buff_size);
3579
3580         cmd->type = ((bridge_type << I40E_AQ_LLDP_BRIDGE_TYPE_SHIFT) &
3581                       I40E_AQ_LLDP_BRIDGE_TYPE_MASK);
3582         cmd->len = CPU_TO_LE16(tlv_len);
3583
3584         status = i40e_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
3585         if (!status) {
3586                 if (mib_len != NULL)
3587                         *mib_len = LE16_TO_CPU(desc.datalen);
3588         }
3589
3590         return status;
3591 }
3592
3593 /**
3594  * i40e_aq_update_lldp_tlv
3595  * @hw: pointer to the hw struct
3596  * @bridge_type: type of bridge
3597  * @buff: buffer with TLV to update
3598  * @buff_size: size of the buffer holding original and updated TLVs
3599  * @old_len: Length of the Original TLV
3600  * @new_len: Length of the Updated TLV
3601  * @offset: offset of the updated TLV in the buff
3602  * @mib_len: length of the returned LLDP MIB
3603  * @cmd_details: pointer to command details structure or NULL
3604  *
3605  * Update the specified TLV to the LLDP Local MIB for the given bridge type.
3606  * Firmware will place the complete LLDP MIB in response buffer with the
3607  * updated TLV.
3608  **/
3609 enum i40e_status_code i40e_aq_update_lldp_tlv(struct i40e_hw *hw,
3610                                 u8 bridge_type, void *buff, u16 buff_size,
3611                                 u16 old_len, u16 new_len, u16 offset,
3612                                 u16 *mib_len,
3613                                 struct i40e_asq_cmd_details *cmd_details)
3614 {
3615         struct i40e_aq_desc desc;
3616         struct i40e_aqc_lldp_update_tlv *cmd =
3617                 (struct i40e_aqc_lldp_update_tlv *)&desc.params.raw;
3618         enum i40e_status_code status;
3619
3620         if (buff_size == 0 || !buff || offset == 0 ||
3621             old_len == 0 || new_len == 0)
3622                 return I40E_ERR_PARAM;
3623
3624         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_lldp_update_tlv);
3625
3626         /* Indirect Command */
3627         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
3628         if (buff_size > I40E_AQ_LARGE_BUF)
3629                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3630         desc.datalen = CPU_TO_LE16(buff_size);
3631
3632         cmd->type = ((bridge_type << I40E_AQ_LLDP_BRIDGE_TYPE_SHIFT) &
3633                       I40E_AQ_LLDP_BRIDGE_TYPE_MASK);
3634         cmd->old_len = CPU_TO_LE16(old_len);
3635         cmd->new_offset = CPU_TO_LE16(offset);
3636         cmd->new_len = CPU_TO_LE16(new_len);
3637
3638         status = i40e_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
3639         if (!status) {
3640                 if (mib_len != NULL)
3641                         *mib_len = LE16_TO_CPU(desc.datalen);
3642         }
3643
3644         return status;
3645 }
3646
3647 /**
3648  * i40e_aq_delete_lldp_tlv
3649  * @hw: pointer to the hw struct
3650  * @bridge_type: type of bridge
3651  * @buff: pointer to a user supplied buffer that has the TLV
3652  * @buff_size: length of the buffer
3653  * @tlv_len: length of the TLV to be deleted
3654  * @mib_len: length of the returned LLDP MIB
3655  * @cmd_details: pointer to command details structure or NULL
3656  *
3657  * Delete the specified TLV from LLDP Local MIB for the given bridge type.
3658  * The firmware places the entire LLDP MIB in the response buffer.
3659  **/
3660 enum i40e_status_code i40e_aq_delete_lldp_tlv(struct i40e_hw *hw,
3661                                 u8 bridge_type, void *buff, u16 buff_size,
3662                                 u16 tlv_len, u16 *mib_len,
3663                                 struct i40e_asq_cmd_details *cmd_details)
3664 {
3665         struct i40e_aq_desc desc;
3666         struct i40e_aqc_lldp_add_tlv *cmd =
3667                 (struct i40e_aqc_lldp_add_tlv *)&desc.params.raw;
3668         enum i40e_status_code status;
3669
3670         if (buff_size == 0 || !buff)
3671                 return I40E_ERR_PARAM;
3672
3673         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_lldp_delete_tlv);
3674
3675         /* Indirect Command */
3676         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
3677         if (buff_size > I40E_AQ_LARGE_BUF)
3678                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3679         desc.datalen = CPU_TO_LE16(buff_size);
3680         cmd->len = CPU_TO_LE16(tlv_len);
3681         cmd->type = ((bridge_type << I40E_AQ_LLDP_BRIDGE_TYPE_SHIFT) &
3682                       I40E_AQ_LLDP_BRIDGE_TYPE_MASK);
3683
3684         status = i40e_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
3685         if (!status) {
3686                 if (mib_len != NULL)
3687                         *mib_len = LE16_TO_CPU(desc.datalen);
3688         }
3689
3690         return status;
3691 }
3692
3693 /**
3694  * i40e_aq_stop_lldp
3695  * @hw: pointer to the hw struct
3696  * @shutdown_agent: True if LLDP Agent needs to be Shutdown
3697  * @cmd_details: pointer to command details structure or NULL
3698  *
3699  * Stop or Shutdown the embedded LLDP Agent
3700  **/
3701 enum i40e_status_code i40e_aq_stop_lldp(struct i40e_hw *hw, bool shutdown_agent,
3702                                 struct i40e_asq_cmd_details *cmd_details)
3703 {
3704         struct i40e_aq_desc desc;
3705         struct i40e_aqc_lldp_stop *cmd =
3706                 (struct i40e_aqc_lldp_stop *)&desc.params.raw;
3707         enum i40e_status_code status;
3708
3709         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_lldp_stop);
3710
3711         if (shutdown_agent)
3712                 cmd->command |= I40E_AQ_LLDP_AGENT_SHUTDOWN;
3713
3714         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
3715
3716         return status;
3717 }
3718
3719 /**
3720  * i40e_aq_start_lldp
3721  * @hw: pointer to the hw struct
3722  * @cmd_details: pointer to command details structure or NULL
3723  *
3724  * Start the embedded LLDP Agent on all ports.
3725  **/
3726 enum i40e_status_code i40e_aq_start_lldp(struct i40e_hw *hw,
3727                                 struct i40e_asq_cmd_details *cmd_details)
3728 {
3729         struct i40e_aq_desc desc;
3730         struct i40e_aqc_lldp_start *cmd =
3731                 (struct i40e_aqc_lldp_start *)&desc.params.raw;
3732         enum i40e_status_code status;
3733
3734         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_lldp_start);
3735
3736         cmd->command = I40E_AQ_LLDP_AGENT_START;
3737
3738         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
3739
3740         return status;
3741 }
3742
3743 /**
3744  * i40e_aq_get_cee_dcb_config
3745  * @hw: pointer to the hw struct
3746  * @buff: response buffer that stores CEE operational configuration
3747  * @buff_size: size of the buffer passed
3748  * @cmd_details: pointer to command details structure or NULL
3749  *
3750  * Get CEE DCBX mode operational configuration from firmware
3751  **/
3752 enum i40e_status_code i40e_aq_get_cee_dcb_config(struct i40e_hw *hw,
3753                                 void *buff, u16 buff_size,
3754                                 struct i40e_asq_cmd_details *cmd_details)
3755 {
3756         struct i40e_aq_desc desc;
3757         enum i40e_status_code status;
3758
3759         if (buff_size == 0 || !buff)
3760                 return I40E_ERR_PARAM;
3761
3762         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_get_cee_dcb_cfg);
3763
3764         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
3765         status = i40e_asq_send_command(hw, &desc, (void *)buff, buff_size,
3766                                        cmd_details);
3767
3768         return status;
3769 }
3770
3771 /**
3772  * i40e_aq_start_stop_dcbx - Start/Stop DCBx service in FW
3773  * @hw: pointer to the hw struct
3774  * @start_agent: True if DCBx Agent needs to be Started
3775  *                              False if DCBx Agent needs to be Stopped
3776  * @cmd_details: pointer to command details structure or NULL
3777  *
3778  * Start/Stop the embedded dcbx Agent
3779  **/
3780 enum i40e_status_code i40e_aq_start_stop_dcbx(struct i40e_hw *hw,
3781                                 bool start_agent,
3782                                 struct i40e_asq_cmd_details *cmd_details)
3783 {
3784         struct i40e_aq_desc desc;
3785         struct i40e_aqc_lldp_stop_start_specific_agent *cmd =
3786                 (struct i40e_aqc_lldp_stop_start_specific_agent *)
3787                                 &desc.params.raw;
3788         enum i40e_status_code status;
3789
3790         i40e_fill_default_direct_cmd_desc(&desc,
3791                                 i40e_aqc_opc_lldp_stop_start_spec_agent);
3792
3793         if (start_agent)
3794                 cmd->command = I40E_AQC_START_SPECIFIC_AGENT_MASK;
3795
3796         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
3797
3798         return status;
3799 }
3800
3801 /**
3802  * i40e_aq_add_udp_tunnel
3803  * @hw: pointer to the hw struct
3804  * @udp_port: the UDP port to add
3805  * @header_len: length of the tunneling header length in DWords
3806  * @protocol_index: protocol index type
3807  * @filter_index: pointer to filter index
3808  * @cmd_details: pointer to command details structure or NULL
3809  **/
3810 enum i40e_status_code i40e_aq_add_udp_tunnel(struct i40e_hw *hw,
3811                                 u16 udp_port, u8 protocol_index,
3812                                 u8 *filter_index,
3813                                 struct i40e_asq_cmd_details *cmd_details)
3814 {
3815         struct i40e_aq_desc desc;
3816         struct i40e_aqc_add_udp_tunnel *cmd =
3817                 (struct i40e_aqc_add_udp_tunnel *)&desc.params.raw;
3818         struct i40e_aqc_del_udp_tunnel_completion *resp =
3819                 (struct i40e_aqc_del_udp_tunnel_completion *)&desc.params.raw;
3820         enum i40e_status_code status;
3821
3822         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_add_udp_tunnel);
3823
3824         cmd->udp_port = CPU_TO_LE16(udp_port);
3825         cmd->protocol_type = protocol_index;
3826
3827         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
3828
3829         if (!status && filter_index)
3830                 *filter_index = resp->index;
3831
3832         return status;
3833 }
3834
3835 /**
3836  * i40e_aq_del_udp_tunnel
3837  * @hw: pointer to the hw struct
3838  * @index: filter index
3839  * @cmd_details: pointer to command details structure or NULL
3840  **/
3841 enum i40e_status_code i40e_aq_del_udp_tunnel(struct i40e_hw *hw, u8 index,
3842                                 struct i40e_asq_cmd_details *cmd_details)
3843 {
3844         struct i40e_aq_desc desc;
3845         struct i40e_aqc_remove_udp_tunnel *cmd =
3846                 (struct i40e_aqc_remove_udp_tunnel *)&desc.params.raw;
3847         enum i40e_status_code status;
3848
3849         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_del_udp_tunnel);
3850
3851         cmd->index = index;
3852
3853         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
3854
3855         return status;
3856 }
3857
3858 /**
3859  * i40e_aq_get_switch_resource_alloc (0x0204)
3860  * @hw: pointer to the hw struct
3861  * @num_entries: pointer to u8 to store the number of resource entries returned
3862  * @buf: pointer to a user supplied buffer.  This buffer must be large enough
3863  *        to store the resource information for all resource types.  Each
3864  *        resource type is a i40e_aqc_switch_resource_alloc_data structure.
3865  * @count: size, in bytes, of the buffer provided
3866  * @cmd_details: pointer to command details structure or NULL
3867  *
3868  * Query the resources allocated to a function.
3869  **/
3870 enum i40e_status_code i40e_aq_get_switch_resource_alloc(struct i40e_hw *hw,
3871                         u8 *num_entries,
3872                         struct i40e_aqc_switch_resource_alloc_element_resp *buf,
3873                         u16 count,
3874                         struct i40e_asq_cmd_details *cmd_details)
3875 {
3876         struct i40e_aq_desc desc;
3877         struct i40e_aqc_get_switch_resource_alloc *cmd_resp =
3878                 (struct i40e_aqc_get_switch_resource_alloc *)&desc.params.raw;
3879         enum i40e_status_code status;
3880         u16 length = count * sizeof(*buf);
3881
3882         i40e_fill_default_direct_cmd_desc(&desc,
3883                                         i40e_aqc_opc_get_switch_resource_alloc);
3884
3885         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
3886         if (length > I40E_AQ_LARGE_BUF)
3887                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
3888
3889         status = i40e_asq_send_command(hw, &desc, buf, length, cmd_details);
3890
3891         if (!status && num_entries)
3892                 *num_entries = cmd_resp->num_entries;
3893
3894         return status;
3895 }
3896
3897 /**
3898  * i40e_aq_delete_element - Delete switch element
3899  * @hw: pointer to the hw struct
3900  * @seid: the SEID to delete from the switch
3901  * @cmd_details: pointer to command details structure or NULL
3902  *
3903  * This deletes a switch element from the switch.
3904  **/
3905 enum i40e_status_code i40e_aq_delete_element(struct i40e_hw *hw, u16 seid,
3906                                 struct i40e_asq_cmd_details *cmd_details)
3907 {
3908         struct i40e_aq_desc desc;
3909         struct i40e_aqc_switch_seid *cmd =
3910                 (struct i40e_aqc_switch_seid *)&desc.params.raw;
3911         enum i40e_status_code status;
3912
3913         if (seid == 0)
3914                 return I40E_ERR_PARAM;
3915
3916         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_delete_element);
3917
3918         cmd->seid = CPU_TO_LE16(seid);
3919
3920         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
3921
3922         return status;
3923 }
3924
3925 /**
3926  * i40_aq_add_pvirt - Instantiate a Port Virtualizer on a port
3927  * @hw: pointer to the hw struct
3928  * @flags: component flags
3929  * @mac_seid: uplink seid (MAC SEID)
3930  * @vsi_seid: connected vsi seid
3931  * @ret_seid: seid of create pv component
3932  *
3933  * This instantiates an i40e port virtualizer with specified flags.
3934  * Depending on specified flags the port virtualizer can act as a
3935  * 802.1Qbr port virtualizer or a 802.1Qbg S-component.
3936  */
3937 enum i40e_status_code i40e_aq_add_pvirt(struct i40e_hw *hw, u16 flags,
3938                                        u16 mac_seid, u16 vsi_seid,
3939                                        u16 *ret_seid)
3940 {
3941         struct i40e_aq_desc desc;
3942         struct i40e_aqc_add_update_pv *cmd =
3943                 (struct i40e_aqc_add_update_pv *)&desc.params.raw;
3944         struct i40e_aqc_add_update_pv_completion *resp =
3945                 (struct i40e_aqc_add_update_pv_completion *)&desc.params.raw;
3946         enum i40e_status_code status;
3947
3948         if (vsi_seid == 0)
3949                 return I40E_ERR_PARAM;
3950
3951         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_add_pv);
3952         cmd->command_flags = CPU_TO_LE16(flags);
3953         cmd->uplink_seid = CPU_TO_LE16(mac_seid);
3954         cmd->connected_seid = CPU_TO_LE16(vsi_seid);
3955
3956         status = i40e_asq_send_command(hw, &desc, NULL, 0, NULL);
3957         if (!status && ret_seid)
3958                 *ret_seid = LE16_TO_CPU(resp->pv_seid);
3959
3960         return status;
3961 }
3962
3963 /**
3964  * i40e_aq_add_tag - Add an S/E-tag
3965  * @hw: pointer to the hw struct
3966  * @direct_to_queue: should s-tag direct flow to a specific queue
3967  * @vsi_seid: VSI SEID to use this tag
3968  * @tag: value of the tag
3969  * @queue_num: queue number, only valid is direct_to_queue is true
3970  * @tags_used: return value, number of tags in use by this PF
3971  * @tags_free: return value, number of unallocated tags
3972  * @cmd_details: pointer to command details structure or NULL
3973  *
3974  * This associates an S- or E-tag to a VSI in the switch complex.  It returns
3975  * the number of tags allocated by the PF, and the number of unallocated
3976  * tags available.
3977  **/
3978 enum i40e_status_code i40e_aq_add_tag(struct i40e_hw *hw, bool direct_to_queue,
3979                                 u16 vsi_seid, u16 tag, u16 queue_num,
3980                                 u16 *tags_used, u16 *tags_free,
3981                                 struct i40e_asq_cmd_details *cmd_details)
3982 {
3983         struct i40e_aq_desc desc;
3984         struct i40e_aqc_add_tag *cmd =
3985                 (struct i40e_aqc_add_tag *)&desc.params.raw;
3986         struct i40e_aqc_add_remove_tag_completion *resp =
3987                 (struct i40e_aqc_add_remove_tag_completion *)&desc.params.raw;
3988         enum i40e_status_code status;
3989
3990         if (vsi_seid == 0)
3991                 return I40E_ERR_PARAM;
3992
3993         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_add_tag);
3994
3995         cmd->seid = CPU_TO_LE16(vsi_seid);
3996         cmd->tag = CPU_TO_LE16(tag);
3997         if (direct_to_queue) {
3998                 cmd->flags = CPU_TO_LE16(I40E_AQC_ADD_TAG_FLAG_TO_QUEUE);
3999                 cmd->queue_number = CPU_TO_LE16(queue_num);
4000         }
4001
4002         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4003
4004         if (!status) {
4005                 if (tags_used != NULL)
4006                         *tags_used = LE16_TO_CPU(resp->tags_used);
4007                 if (tags_free != NULL)
4008                         *tags_free = LE16_TO_CPU(resp->tags_free);
4009         }
4010
4011         return status;
4012 }
4013
4014 /**
4015  * i40e_aq_remove_tag - Remove an S- or E-tag
4016  * @hw: pointer to the hw struct
4017  * @vsi_seid: VSI SEID this tag is associated with
4018  * @tag: value of the S-tag to delete
4019  * @tags_used: return value, number of tags in use by this PF
4020  * @tags_free: return value, number of unallocated tags
4021  * @cmd_details: pointer to command details structure or NULL
4022  *
4023  * This deletes an S- or E-tag from a VSI in the switch complex.  It returns
4024  * the number of tags allocated by the PF, and the number of unallocated
4025  * tags available.
4026  **/
4027 enum i40e_status_code i40e_aq_remove_tag(struct i40e_hw *hw, u16 vsi_seid,
4028                                 u16 tag, u16 *tags_used, u16 *tags_free,
4029                                 struct i40e_asq_cmd_details *cmd_details)
4030 {
4031         struct i40e_aq_desc desc;
4032         struct i40e_aqc_remove_tag *cmd =
4033                 (struct i40e_aqc_remove_tag *)&desc.params.raw;
4034         struct i40e_aqc_add_remove_tag_completion *resp =
4035                 (struct i40e_aqc_add_remove_tag_completion *)&desc.params.raw;
4036         enum i40e_status_code status;
4037
4038         if (vsi_seid == 0)
4039                 return I40E_ERR_PARAM;
4040
4041         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_remove_tag);
4042
4043         cmd->seid = CPU_TO_LE16(vsi_seid);
4044         cmd->tag = CPU_TO_LE16(tag);
4045
4046         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4047
4048         if (!status) {
4049                 if (tags_used != NULL)
4050                         *tags_used = LE16_TO_CPU(resp->tags_used);
4051                 if (tags_free != NULL)
4052                         *tags_free = LE16_TO_CPU(resp->tags_free);
4053         }
4054
4055         return status;
4056 }
4057
4058 /**
4059  * i40e_aq_add_mcast_etag - Add a multicast E-tag
4060  * @hw: pointer to the hw struct
4061  * @pv_seid: Port Virtualizer of this SEID to associate E-tag with
4062  * @etag: value of E-tag to add
4063  * @num_tags_in_buf: number of unicast E-tags in indirect buffer
4064  * @buf: address of indirect buffer
4065  * @tags_used: return value, number of E-tags in use by this port
4066  * @tags_free: return value, number of unallocated M-tags
4067  * @cmd_details: pointer to command details structure or NULL
4068  *
4069  * This associates a multicast E-tag to a port virtualizer.  It will return
4070  * the number of tags allocated by the PF, and the number of unallocated
4071  * tags available.
4072  *
4073  * The indirect buffer pointed to by buf is a list of 2-byte E-tags,
4074  * num_tags_in_buf long.
4075  **/
4076 enum i40e_status_code i40e_aq_add_mcast_etag(struct i40e_hw *hw, u16 pv_seid,
4077                                 u16 etag, u8 num_tags_in_buf, void *buf,
4078                                 u16 *tags_used, u16 *tags_free,
4079                                 struct i40e_asq_cmd_details *cmd_details)
4080 {
4081         struct i40e_aq_desc desc;
4082         struct i40e_aqc_add_remove_mcast_etag *cmd =
4083                 (struct i40e_aqc_add_remove_mcast_etag *)&desc.params.raw;
4084         struct i40e_aqc_add_remove_mcast_etag_completion *resp =
4085            (struct i40e_aqc_add_remove_mcast_etag_completion *)&desc.params.raw;
4086         enum i40e_status_code status;
4087         u16 length = sizeof(u16) * num_tags_in_buf;
4088
4089         if ((pv_seid == 0) || (buf == NULL) || (num_tags_in_buf == 0))
4090                 return I40E_ERR_PARAM;
4091
4092         i40e_fill_default_direct_cmd_desc(&desc,
4093                                           i40e_aqc_opc_add_multicast_etag);
4094
4095         cmd->pv_seid = CPU_TO_LE16(pv_seid);
4096         cmd->etag = CPU_TO_LE16(etag);
4097         cmd->num_unicast_etags = num_tags_in_buf;
4098
4099         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
4100         if (length > I40E_AQ_LARGE_BUF)
4101                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
4102
4103         status = i40e_asq_send_command(hw, &desc, buf, length, cmd_details);
4104
4105         if (!status) {
4106                 if (tags_used != NULL)
4107                         *tags_used = LE16_TO_CPU(resp->mcast_etags_used);
4108                 if (tags_free != NULL)
4109                         *tags_free = LE16_TO_CPU(resp->mcast_etags_free);
4110         }
4111
4112         return status;
4113 }
4114
4115 /**
4116  * i40e_aq_remove_mcast_etag - Remove a multicast E-tag
4117  * @hw: pointer to the hw struct
4118  * @pv_seid: Port Virtualizer SEID this M-tag is associated with
4119  * @etag: value of the E-tag to remove
4120  * @tags_used: return value, number of tags in use by this port
4121  * @tags_free: return value, number of unallocated tags
4122  * @cmd_details: pointer to command details structure or NULL
4123  *
4124  * This deletes an E-tag from the port virtualizer.  It will return
4125  * the number of tags allocated by the port, and the number of unallocated
4126  * tags available.
4127  **/
4128 enum i40e_status_code i40e_aq_remove_mcast_etag(struct i40e_hw *hw, u16 pv_seid,
4129                                 u16 etag, u16 *tags_used, u16 *tags_free,
4130                                 struct i40e_asq_cmd_details *cmd_details)
4131 {
4132         struct i40e_aq_desc desc;
4133         struct i40e_aqc_add_remove_mcast_etag *cmd =
4134                 (struct i40e_aqc_add_remove_mcast_etag *)&desc.params.raw;
4135         struct i40e_aqc_add_remove_mcast_etag_completion *resp =
4136            (struct i40e_aqc_add_remove_mcast_etag_completion *)&desc.params.raw;
4137         enum i40e_status_code status;
4138
4139
4140         if (pv_seid == 0)
4141                 return I40E_ERR_PARAM;
4142
4143         i40e_fill_default_direct_cmd_desc(&desc,
4144                                           i40e_aqc_opc_remove_multicast_etag);
4145
4146         cmd->pv_seid = CPU_TO_LE16(pv_seid);
4147         cmd->etag = CPU_TO_LE16(etag);
4148
4149         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4150
4151         if (!status) {
4152                 if (tags_used != NULL)
4153                         *tags_used = LE16_TO_CPU(resp->mcast_etags_used);
4154                 if (tags_free != NULL)
4155                         *tags_free = LE16_TO_CPU(resp->mcast_etags_free);
4156         }
4157
4158         return status;
4159 }
4160
4161 /**
4162  * i40e_aq_update_tag - Update an S/E-tag
4163  * @hw: pointer to the hw struct
4164  * @vsi_seid: VSI SEID using this S-tag
4165  * @old_tag: old tag value
4166  * @new_tag: new tag value
4167  * @tags_used: return value, number of tags in use by this PF
4168  * @tags_free: return value, number of unallocated tags
4169  * @cmd_details: pointer to command details structure or NULL
4170  *
4171  * This updates the value of the tag currently attached to this VSI
4172  * in the switch complex.  It will return the number of tags allocated
4173  * by the PF, and the number of unallocated tags available.
4174  **/
4175 enum i40e_status_code i40e_aq_update_tag(struct i40e_hw *hw, u16 vsi_seid,
4176                                 u16 old_tag, u16 new_tag, u16 *tags_used,
4177                                 u16 *tags_free,
4178                                 struct i40e_asq_cmd_details *cmd_details)
4179 {
4180         struct i40e_aq_desc desc;
4181         struct i40e_aqc_update_tag *cmd =
4182                 (struct i40e_aqc_update_tag *)&desc.params.raw;
4183         struct i40e_aqc_update_tag_completion *resp =
4184                 (struct i40e_aqc_update_tag_completion *)&desc.params.raw;
4185         enum i40e_status_code status;
4186
4187         if (vsi_seid == 0)
4188                 return I40E_ERR_PARAM;
4189
4190         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_update_tag);
4191
4192         cmd->seid = CPU_TO_LE16(vsi_seid);
4193         cmd->old_tag = CPU_TO_LE16(old_tag);
4194         cmd->new_tag = CPU_TO_LE16(new_tag);
4195
4196         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4197
4198         if (!status) {
4199                 if (tags_used != NULL)
4200                         *tags_used = LE16_TO_CPU(resp->tags_used);
4201                 if (tags_free != NULL)
4202                         *tags_free = LE16_TO_CPU(resp->tags_free);
4203         }
4204
4205         return status;
4206 }
4207
4208 /**
4209  * i40e_aq_dcb_ignore_pfc - Ignore PFC for given TCs
4210  * @hw: pointer to the hw struct
4211  * @tcmap: TC map for request/release any ignore PFC condition
4212  * @request: request or release ignore PFC condition
4213  * @tcmap_ret: return TCs for which PFC is currently ignored
4214  * @cmd_details: pointer to command details structure or NULL
4215  *
4216  * This sends out request/release to ignore PFC condition for a TC.
4217  * It will return the TCs for which PFC is currently ignored.
4218  **/
4219 enum i40e_status_code i40e_aq_dcb_ignore_pfc(struct i40e_hw *hw, u8 tcmap,
4220                                 bool request, u8 *tcmap_ret,
4221                                 struct i40e_asq_cmd_details *cmd_details)
4222 {
4223         struct i40e_aq_desc desc;
4224         struct i40e_aqc_pfc_ignore *cmd_resp =
4225                 (struct i40e_aqc_pfc_ignore *)&desc.params.raw;
4226         enum i40e_status_code status;
4227
4228         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_dcb_ignore_pfc);
4229
4230         if (request)
4231                 cmd_resp->command_flags = I40E_AQC_PFC_IGNORE_SET;
4232
4233         cmd_resp->tc_bitmap = tcmap;
4234
4235         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4236
4237         if (!status) {
4238                 if (tcmap_ret != NULL)
4239                         *tcmap_ret = cmd_resp->tc_bitmap;
4240         }
4241
4242         return status;
4243 }
4244
4245 /**
4246  * i40e_aq_dcb_updated - DCB Updated Command
4247  * @hw: pointer to the hw struct
4248  * @cmd_details: pointer to command details structure or NULL
4249  *
4250  * When LLDP is handled in PF this command is used by the PF
4251  * to notify EMP that a DCB setting is modified.
4252  * When LLDP is handled in EMP this command is used by the PF
4253  * to notify EMP whenever one of the following parameters get
4254  * modified:
4255  *   - PFCLinkDelayAllowance in PRTDCB_GENC.PFCLDA
4256  *   - PCIRTT in PRTDCB_GENC.PCIRTT
4257  *   - Maximum Frame Size for non-FCoE TCs set by PRTDCB_TDPUC.MAX_TXFRAME.
4258  * EMP will return when the shared RPB settings have been
4259  * recomputed and modified. The retval field in the descriptor
4260  * will be set to 0 when RPB is modified.
4261  **/
4262 enum i40e_status_code i40e_aq_dcb_updated(struct i40e_hw *hw,
4263                                 struct i40e_asq_cmd_details *cmd_details)
4264 {
4265         struct i40e_aq_desc desc;
4266         enum i40e_status_code status;
4267
4268         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_dcb_updated);
4269
4270         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4271
4272         return status;
4273 }
4274
4275 /**
4276  * i40e_aq_add_statistics - Add a statistics block to a VLAN in a switch.
4277  * @hw: pointer to the hw struct
4278  * @seid: defines the SEID of the switch for which the stats are requested
4279  * @vlan_id: the VLAN ID for which the statistics are requested
4280  * @stat_index: index of the statistics counters block assigned to this VLAN
4281  * @cmd_details: pointer to command details structure or NULL
4282  *
4283  * XL710 supports 128 smonVlanStats counters.This command is used to
4284  * allocate a set of smonVlanStats counters to a specific VLAN in a specific
4285  * switch.
4286  **/
4287 enum i40e_status_code i40e_aq_add_statistics(struct i40e_hw *hw, u16 seid,
4288                                 u16 vlan_id, u16 *stat_index,
4289                                 struct i40e_asq_cmd_details *cmd_details)
4290 {
4291         struct i40e_aq_desc desc;
4292         struct i40e_aqc_add_remove_statistics *cmd_resp =
4293                 (struct i40e_aqc_add_remove_statistics *)&desc.params.raw;
4294         enum i40e_status_code status;
4295
4296         if ((seid == 0) || (stat_index == NULL))
4297                 return I40E_ERR_PARAM;
4298
4299         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_add_statistics);
4300
4301         cmd_resp->seid = CPU_TO_LE16(seid);
4302         cmd_resp->vlan = CPU_TO_LE16(vlan_id);
4303
4304         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4305
4306         if (!status && stat_index)
4307                 *stat_index = LE16_TO_CPU(cmd_resp->stat_index);
4308
4309         return status;
4310 }
4311
4312 /**
4313  * i40e_aq_remove_statistics - Remove a statistics block to a VLAN in a switch.
4314  * @hw: pointer to the hw struct
4315  * @seid: defines the SEID of the switch for which the stats are requested
4316  * @vlan_id: the VLAN ID for which the statistics are requested
4317  * @stat_index: index of the statistics counters block assigned to this VLAN
4318  * @cmd_details: pointer to command details structure or NULL
4319  *
4320  * XL710 supports 128 smonVlanStats counters.This command is used to
4321  * deallocate a set of smonVlanStats counters to a specific VLAN in a specific
4322  * switch.
4323  **/
4324 enum i40e_status_code i40e_aq_remove_statistics(struct i40e_hw *hw, u16 seid,
4325                                 u16 vlan_id, u16 stat_index,
4326                                 struct i40e_asq_cmd_details *cmd_details)
4327 {
4328         struct i40e_aq_desc desc;
4329         struct i40e_aqc_add_remove_statistics *cmd =
4330                 (struct i40e_aqc_add_remove_statistics *)&desc.params.raw;
4331         enum i40e_status_code status;
4332
4333         if (seid == 0)
4334                 return I40E_ERR_PARAM;
4335
4336         i40e_fill_default_direct_cmd_desc(&desc,
4337                                           i40e_aqc_opc_remove_statistics);
4338
4339         cmd->seid = CPU_TO_LE16(seid);
4340         cmd->vlan  = CPU_TO_LE16(vlan_id);
4341         cmd->stat_index = CPU_TO_LE16(stat_index);
4342
4343         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4344
4345         return status;
4346 }
4347
4348 /**
4349  * i40e_aq_set_port_parameters - set physical port parameters.
4350  * @hw: pointer to the hw struct
4351  * @bad_frame_vsi: defines the VSI to which bad frames are forwarded
4352  * @save_bad_pac: if set packets with errors are forwarded to the bad frames VSI
4353  * @pad_short_pac: if set transmit packets smaller than 60 bytes are padded
4354  * @double_vlan: if set double VLAN is enabled
4355  * @cmd_details: pointer to command details structure or NULL
4356  **/
4357 enum i40e_status_code i40e_aq_set_port_parameters(struct i40e_hw *hw,
4358                                 u16 bad_frame_vsi, bool save_bad_pac,
4359                                 bool pad_short_pac, bool double_vlan,
4360                                 struct i40e_asq_cmd_details *cmd_details)
4361 {
4362         struct i40e_aqc_set_port_parameters *cmd;
4363         enum i40e_status_code status;
4364         struct i40e_aq_desc desc;
4365         u16 command_flags = 0;
4366
4367         cmd = (struct i40e_aqc_set_port_parameters *)&desc.params.raw;
4368
4369         i40e_fill_default_direct_cmd_desc(&desc,
4370                                           i40e_aqc_opc_set_port_parameters);
4371
4372         cmd->bad_frame_vsi = CPU_TO_LE16(bad_frame_vsi);
4373         if (save_bad_pac)
4374                 command_flags |= I40E_AQ_SET_P_PARAMS_SAVE_BAD_PACKETS;
4375         if (pad_short_pac)
4376                 command_flags |= I40E_AQ_SET_P_PARAMS_PAD_SHORT_PACKETS;
4377         if (double_vlan)
4378                 command_flags |= I40E_AQ_SET_P_PARAMS_DOUBLE_VLAN_ENA;
4379         cmd->command_flags = CPU_TO_LE16(command_flags);
4380
4381         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4382
4383         return status;
4384 }
4385
4386 /**
4387  * i40e_aq_tx_sched_cmd - generic Tx scheduler AQ command handler
4388  * @hw: pointer to the hw struct
4389  * @seid: seid for the physical port/switching component/vsi
4390  * @buff: Indirect buffer to hold data parameters and response
4391  * @buff_size: Indirect buffer size
4392  * @opcode: Tx scheduler AQ command opcode
4393  * @cmd_details: pointer to command details structure or NULL
4394  *
4395  * Generic command handler for Tx scheduler AQ commands
4396  **/
4397 static enum i40e_status_code i40e_aq_tx_sched_cmd(struct i40e_hw *hw, u16 seid,
4398                                 void *buff, u16 buff_size,
4399                                  enum i40e_admin_queue_opc opcode,
4400                                 struct i40e_asq_cmd_details *cmd_details)
4401 {
4402         struct i40e_aq_desc desc;
4403         struct i40e_aqc_tx_sched_ind *cmd =
4404                 (struct i40e_aqc_tx_sched_ind *)&desc.params.raw;
4405         enum i40e_status_code status;
4406         bool cmd_param_flag = false;
4407
4408         switch (opcode) {
4409         case i40e_aqc_opc_configure_vsi_ets_sla_bw_limit:
4410         case i40e_aqc_opc_configure_vsi_tc_bw:
4411         case i40e_aqc_opc_enable_switching_comp_ets:
4412         case i40e_aqc_opc_modify_switching_comp_ets:
4413         case i40e_aqc_opc_disable_switching_comp_ets:
4414         case i40e_aqc_opc_configure_switching_comp_ets_bw_limit:
4415         case i40e_aqc_opc_configure_switching_comp_bw_config:
4416                 cmd_param_flag = true;
4417                 break;
4418         case i40e_aqc_opc_query_vsi_bw_config:
4419         case i40e_aqc_opc_query_vsi_ets_sla_config:
4420         case i40e_aqc_opc_query_switching_comp_ets_config:
4421         case i40e_aqc_opc_query_port_ets_config:
4422         case i40e_aqc_opc_query_switching_comp_bw_config:
4423                 cmd_param_flag = false;
4424                 break;
4425         default:
4426                 return I40E_ERR_PARAM;
4427         }
4428
4429         i40e_fill_default_direct_cmd_desc(&desc, opcode);
4430
4431         /* Indirect command */
4432         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
4433         if (cmd_param_flag)
4434                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_RD);
4435         if (buff_size > I40E_AQ_LARGE_BUF)
4436                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
4437
4438         desc.datalen = CPU_TO_LE16(buff_size);
4439
4440         cmd->vsi_seid = CPU_TO_LE16(seid);
4441
4442         status = i40e_asq_send_command(hw, &desc, buff, buff_size, cmd_details);
4443
4444         return status;
4445 }
4446
4447 /**
4448  * i40e_aq_config_vsi_bw_limit - Configure VSI BW Limit
4449  * @hw: pointer to the hw struct
4450  * @seid: VSI seid
4451  * @credit: BW limit credits (0 = disabled)
4452  * @max_credit: Max BW limit credits
4453  * @cmd_details: pointer to command details structure or NULL
4454  **/
4455 enum i40e_status_code i40e_aq_config_vsi_bw_limit(struct i40e_hw *hw,
4456                                 u16 seid, u16 credit, u8 max_credit,
4457                                 struct i40e_asq_cmd_details *cmd_details)
4458 {
4459         struct i40e_aq_desc desc;
4460         struct i40e_aqc_configure_vsi_bw_limit *cmd =
4461                 (struct i40e_aqc_configure_vsi_bw_limit *)&desc.params.raw;
4462         enum i40e_status_code status;
4463
4464         i40e_fill_default_direct_cmd_desc(&desc,
4465                                           i40e_aqc_opc_configure_vsi_bw_limit);
4466
4467         cmd->vsi_seid = CPU_TO_LE16(seid);
4468         cmd->credit = CPU_TO_LE16(credit);
4469         cmd->max_credit = max_credit;
4470
4471         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4472
4473         return status;
4474 }
4475
4476 /**
4477  * i40e_aq_config_switch_comp_bw_limit - Configure Switching component BW Limit
4478  * @hw: pointer to the hw struct
4479  * @seid: switching component seid
4480  * @credit: BW limit credits (0 = disabled)
4481  * @max_bw: Max BW limit credits
4482  * @cmd_details: pointer to command details structure or NULL
4483  **/
4484 enum i40e_status_code i40e_aq_config_switch_comp_bw_limit(struct i40e_hw *hw,
4485                                 u16 seid, u16 credit, u8 max_bw,
4486                                 struct i40e_asq_cmd_details *cmd_details)
4487 {
4488         struct i40e_aq_desc desc;
4489         struct i40e_aqc_configure_switching_comp_bw_limit *cmd =
4490           (struct i40e_aqc_configure_switching_comp_bw_limit *)&desc.params.raw;
4491         enum i40e_status_code status;
4492
4493         i40e_fill_default_direct_cmd_desc(&desc,
4494                                 i40e_aqc_opc_configure_switching_comp_bw_limit);
4495
4496         cmd->seid = CPU_TO_LE16(seid);
4497         cmd->credit = CPU_TO_LE16(credit);
4498         cmd->max_bw = max_bw;
4499
4500         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4501
4502         return status;
4503 }
4504
4505 /**
4506  * i40e_aq_config_vsi_ets_sla_bw_limit - Config VSI BW Limit per TC
4507  * @hw: pointer to the hw struct
4508  * @seid: VSI seid
4509  * @bw_data: Buffer holding enabled TCs, per TC BW limit/credits
4510  * @cmd_details: pointer to command details structure or NULL
4511  **/
4512 enum i40e_status_code i40e_aq_config_vsi_ets_sla_bw_limit(struct i40e_hw *hw,
4513                         u16 seid,
4514                         struct i40e_aqc_configure_vsi_ets_sla_bw_data *bw_data,
4515                         struct i40e_asq_cmd_details *cmd_details)
4516 {
4517         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4518                                     i40e_aqc_opc_configure_vsi_ets_sla_bw_limit,
4519                                     cmd_details);
4520 }
4521
4522 /**
4523  * i40e_aq_config_vsi_tc_bw - Config VSI BW Allocation per TC
4524  * @hw: pointer to the hw struct
4525  * @seid: VSI seid
4526  * @bw_data: Buffer holding enabled TCs, relative TC BW limit/credits
4527  * @cmd_details: pointer to command details structure or NULL
4528  **/
4529 enum i40e_status_code i40e_aq_config_vsi_tc_bw(struct i40e_hw *hw,
4530                         u16 seid,
4531                         struct i40e_aqc_configure_vsi_tc_bw_data *bw_data,
4532                         struct i40e_asq_cmd_details *cmd_details)
4533 {
4534         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4535                                     i40e_aqc_opc_configure_vsi_tc_bw,
4536                                     cmd_details);
4537 }
4538
4539 /**
4540  * i40e_aq_config_switch_comp_ets - Enable/Disable/Modify ETS on the port
4541  * @hw: pointer to the hw struct
4542  * @seid: seid of the switching component connected to Physical Port
4543  * @ets_data: Buffer holding ETS parameters
4544  * @cmd_details: pointer to command details structure or NULL
4545  **/
4546 enum i40e_status_code i40e_aq_config_switch_comp_ets(struct i40e_hw *hw,
4547                 u16 seid,
4548                 struct i40e_aqc_configure_switching_comp_ets_data *ets_data,
4549                 enum i40e_admin_queue_opc opcode,
4550                 struct i40e_asq_cmd_details *cmd_details)
4551 {
4552         return i40e_aq_tx_sched_cmd(hw, seid, (void *)ets_data,
4553                                     sizeof(*ets_data), opcode, cmd_details);
4554 }
4555
4556 /**
4557  * i40e_aq_config_switch_comp_bw_config - Config Switch comp BW Alloc per TC
4558  * @hw: pointer to the hw struct
4559  * @seid: seid of the switching component
4560  * @bw_data: Buffer holding enabled TCs, relative/absolute TC BW limit/credits
4561  * @cmd_details: pointer to command details structure or NULL
4562  **/
4563 enum i40e_status_code i40e_aq_config_switch_comp_bw_config(struct i40e_hw *hw,
4564         u16 seid,
4565         struct i40e_aqc_configure_switching_comp_bw_config_data *bw_data,
4566         struct i40e_asq_cmd_details *cmd_details)
4567 {
4568         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4569                             i40e_aqc_opc_configure_switching_comp_bw_config,
4570                             cmd_details);
4571 }
4572
4573 /**
4574  * i40e_aq_config_switch_comp_ets_bw_limit - Config Switch comp BW Limit per TC
4575  * @hw: pointer to the hw struct
4576  * @seid: seid of the switching component
4577  * @bw_data: Buffer holding enabled TCs, per TC BW limit/credits
4578  * @cmd_details: pointer to command details structure or NULL
4579  **/
4580 enum i40e_status_code i40e_aq_config_switch_comp_ets_bw_limit(
4581         struct i40e_hw *hw, u16 seid,
4582         struct i40e_aqc_configure_switching_comp_ets_bw_limit_data *bw_data,
4583         struct i40e_asq_cmd_details *cmd_details)
4584 {
4585         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4586                             i40e_aqc_opc_configure_switching_comp_ets_bw_limit,
4587                             cmd_details);
4588 }
4589
4590 /**
4591  * i40e_aq_query_vsi_bw_config - Query VSI BW configuration
4592  * @hw: pointer to the hw struct
4593  * @seid: seid of the VSI
4594  * @bw_data: Buffer to hold VSI BW configuration
4595  * @cmd_details: pointer to command details structure or NULL
4596  **/
4597 enum i40e_status_code i40e_aq_query_vsi_bw_config(struct i40e_hw *hw,
4598                         u16 seid,
4599                         struct i40e_aqc_query_vsi_bw_config_resp *bw_data,
4600                         struct i40e_asq_cmd_details *cmd_details)
4601 {
4602         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4603                                     i40e_aqc_opc_query_vsi_bw_config,
4604                                     cmd_details);
4605 }
4606
4607 /**
4608  * i40e_aq_query_vsi_ets_sla_config - Query VSI BW configuration per TC
4609  * @hw: pointer to the hw struct
4610  * @seid: seid of the VSI
4611  * @bw_data: Buffer to hold VSI BW configuration per TC
4612  * @cmd_details: pointer to command details structure or NULL
4613  **/
4614 enum i40e_status_code i40e_aq_query_vsi_ets_sla_config(struct i40e_hw *hw,
4615                         u16 seid,
4616                         struct i40e_aqc_query_vsi_ets_sla_config_resp *bw_data,
4617                         struct i40e_asq_cmd_details *cmd_details)
4618 {
4619         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4620                                     i40e_aqc_opc_query_vsi_ets_sla_config,
4621                                     cmd_details);
4622 }
4623
4624 /**
4625  * i40e_aq_query_switch_comp_ets_config - Query Switch comp BW config per TC
4626  * @hw: pointer to the hw struct
4627  * @seid: seid of the switching component
4628  * @bw_data: Buffer to hold switching component's per TC BW config
4629  * @cmd_details: pointer to command details structure or NULL
4630  **/
4631 enum i40e_status_code i40e_aq_query_switch_comp_ets_config(struct i40e_hw *hw,
4632                 u16 seid,
4633                 struct i40e_aqc_query_switching_comp_ets_config_resp *bw_data,
4634                 struct i40e_asq_cmd_details *cmd_details)
4635 {
4636         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4637                                    i40e_aqc_opc_query_switching_comp_ets_config,
4638                                    cmd_details);
4639 }
4640
4641 /**
4642  * i40e_aq_query_port_ets_config - Query Physical Port ETS configuration
4643  * @hw: pointer to the hw struct
4644  * @seid: seid of the VSI or switching component connected to Physical Port
4645  * @bw_data: Buffer to hold current ETS configuration for the Physical Port
4646  * @cmd_details: pointer to command details structure or NULL
4647  **/
4648 enum i40e_status_code i40e_aq_query_port_ets_config(struct i40e_hw *hw,
4649                         u16 seid,
4650                         struct i40e_aqc_query_port_ets_config_resp *bw_data,
4651                         struct i40e_asq_cmd_details *cmd_details)
4652 {
4653         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4654                                     i40e_aqc_opc_query_port_ets_config,
4655                                     cmd_details);
4656 }
4657
4658 /**
4659  * i40e_aq_query_switch_comp_bw_config - Query Switch comp BW configuration
4660  * @hw: pointer to the hw struct
4661  * @seid: seid of the switching component
4662  * @bw_data: Buffer to hold switching component's BW configuration
4663  * @cmd_details: pointer to command details structure or NULL
4664  **/
4665 enum i40e_status_code i40e_aq_query_switch_comp_bw_config(struct i40e_hw *hw,
4666                 u16 seid,
4667                 struct i40e_aqc_query_switching_comp_bw_config_resp *bw_data,
4668                 struct i40e_asq_cmd_details *cmd_details)
4669 {
4670         return i40e_aq_tx_sched_cmd(hw, seid, (void *)bw_data, sizeof(*bw_data),
4671                                     i40e_aqc_opc_query_switching_comp_bw_config,
4672                                     cmd_details);
4673 }
4674
4675 /**
4676  * i40e_validate_filter_settings
4677  * @hw: pointer to the hardware structure
4678  * @settings: Filter control settings
4679  *
4680  * Check and validate the filter control settings passed.
4681  * The function checks for the valid filter/context sizes being
4682  * passed for FCoE and PE.
4683  *
4684  * Returns I40E_SUCCESS if the values passed are valid and within
4685  * range else returns an error.
4686  **/
4687 STATIC enum i40e_status_code i40e_validate_filter_settings(struct i40e_hw *hw,
4688                                 struct i40e_filter_control_settings *settings)
4689 {
4690         u32 fcoe_cntx_size, fcoe_filt_size;
4691         u32 pe_cntx_size, pe_filt_size;
4692         u32 fcoe_fmax;
4693
4694         u32 val;
4695
4696         /* Validate FCoE settings passed */
4697         switch (settings->fcoe_filt_num) {
4698         case I40E_HASH_FILTER_SIZE_1K:
4699         case I40E_HASH_FILTER_SIZE_2K:
4700         case I40E_HASH_FILTER_SIZE_4K:
4701         case I40E_HASH_FILTER_SIZE_8K:
4702         case I40E_HASH_FILTER_SIZE_16K:
4703         case I40E_HASH_FILTER_SIZE_32K:
4704                 fcoe_filt_size = I40E_HASH_FILTER_BASE_SIZE;
4705                 fcoe_filt_size <<= (u32)settings->fcoe_filt_num;
4706                 break;
4707         default:
4708                 return I40E_ERR_PARAM;
4709         }
4710
4711         switch (settings->fcoe_cntx_num) {
4712         case I40E_DMA_CNTX_SIZE_512:
4713         case I40E_DMA_CNTX_SIZE_1K:
4714         case I40E_DMA_CNTX_SIZE_2K:
4715         case I40E_DMA_CNTX_SIZE_4K:
4716                 fcoe_cntx_size = I40E_DMA_CNTX_BASE_SIZE;
4717                 fcoe_cntx_size <<= (u32)settings->fcoe_cntx_num;
4718                 break;
4719         default:
4720                 return I40E_ERR_PARAM;
4721         }
4722
4723         /* Validate PE settings passed */
4724         switch (settings->pe_filt_num) {
4725         case I40E_HASH_FILTER_SIZE_1K:
4726         case I40E_HASH_FILTER_SIZE_2K:
4727         case I40E_HASH_FILTER_SIZE_4K:
4728         case I40E_HASH_FILTER_SIZE_8K:
4729         case I40E_HASH_FILTER_SIZE_16K:
4730         case I40E_HASH_FILTER_SIZE_32K:
4731         case I40E_HASH_FILTER_SIZE_64K:
4732         case I40E_HASH_FILTER_SIZE_128K:
4733         case I40E_HASH_FILTER_SIZE_256K:
4734         case I40E_HASH_FILTER_SIZE_512K:
4735         case I40E_HASH_FILTER_SIZE_1M:
4736                 pe_filt_size = I40E_HASH_FILTER_BASE_SIZE;
4737                 pe_filt_size <<= (u32)settings->pe_filt_num;
4738                 break;
4739         default:
4740                 return I40E_ERR_PARAM;
4741         }
4742
4743         switch (settings->pe_cntx_num) {
4744         case I40E_DMA_CNTX_SIZE_512:
4745         case I40E_DMA_CNTX_SIZE_1K:
4746         case I40E_DMA_CNTX_SIZE_2K:
4747         case I40E_DMA_CNTX_SIZE_4K:
4748         case I40E_DMA_CNTX_SIZE_8K:
4749         case I40E_DMA_CNTX_SIZE_16K:
4750         case I40E_DMA_CNTX_SIZE_32K:
4751         case I40E_DMA_CNTX_SIZE_64K:
4752         case I40E_DMA_CNTX_SIZE_128K:
4753         case I40E_DMA_CNTX_SIZE_256K:
4754                 pe_cntx_size = I40E_DMA_CNTX_BASE_SIZE;
4755                 pe_cntx_size <<= (u32)settings->pe_cntx_num;
4756                 break;
4757         default:
4758                 return I40E_ERR_PARAM;
4759         }
4760
4761         /* FCHSIZE + FCDSIZE should not be greater than PMFCOEFMAX */
4762         val = rd32(hw, I40E_GLHMC_FCOEFMAX);
4763         fcoe_fmax = (val & I40E_GLHMC_FCOEFMAX_PMFCOEFMAX_MASK)
4764                      >> I40E_GLHMC_FCOEFMAX_PMFCOEFMAX_SHIFT;
4765         if (fcoe_filt_size + fcoe_cntx_size >  fcoe_fmax)
4766                 return I40E_ERR_INVALID_SIZE;
4767
4768         return I40E_SUCCESS;
4769 }
4770
4771 /**
4772  * i40e_set_filter_control
4773  * @hw: pointer to the hardware structure
4774  * @settings: Filter control settings
4775  *
4776  * Set the Queue Filters for PE/FCoE and enable filters required
4777  * for a single PF. It is expected that these settings are programmed
4778  * at the driver initialization time.
4779  **/
4780 enum i40e_status_code i40e_set_filter_control(struct i40e_hw *hw,
4781                                 struct i40e_filter_control_settings *settings)
4782 {
4783         enum i40e_status_code ret = I40E_SUCCESS;
4784         u32 hash_lut_size = 0;
4785         u32 val;
4786
4787         if (!settings)
4788                 return I40E_ERR_PARAM;
4789
4790         /* Validate the input settings */
4791         ret = i40e_validate_filter_settings(hw, settings);
4792         if (ret)
4793                 return ret;
4794
4795         /* Read the PF Queue Filter control register */
4796         val = rd32(hw, I40E_PFQF_CTL_0);
4797
4798         /* Program required PE hash buckets for the PF */
4799         val &= ~I40E_PFQF_CTL_0_PEHSIZE_MASK;
4800         val |= ((u32)settings->pe_filt_num << I40E_PFQF_CTL_0_PEHSIZE_SHIFT) &
4801                 I40E_PFQF_CTL_0_PEHSIZE_MASK;
4802         /* Program required PE contexts for the PF */
4803         val &= ~I40E_PFQF_CTL_0_PEDSIZE_MASK;
4804         val |= ((u32)settings->pe_cntx_num << I40E_PFQF_CTL_0_PEDSIZE_SHIFT) &
4805                 I40E_PFQF_CTL_0_PEDSIZE_MASK;
4806
4807         /* Program required FCoE hash buckets for the PF */
4808         val &= ~I40E_PFQF_CTL_0_PFFCHSIZE_MASK;
4809         val |= ((u32)settings->fcoe_filt_num <<
4810                         I40E_PFQF_CTL_0_PFFCHSIZE_SHIFT) &
4811                 I40E_PFQF_CTL_0_PFFCHSIZE_MASK;
4812         /* Program required FCoE DDP contexts for the PF */
4813         val &= ~I40E_PFQF_CTL_0_PFFCDSIZE_MASK;
4814         val |= ((u32)settings->fcoe_cntx_num <<
4815                         I40E_PFQF_CTL_0_PFFCDSIZE_SHIFT) &
4816                 I40E_PFQF_CTL_0_PFFCDSIZE_MASK;
4817
4818         /* Program Hash LUT size for the PF */
4819         val &= ~I40E_PFQF_CTL_0_HASHLUTSIZE_MASK;
4820         if (settings->hash_lut_size == I40E_HASH_LUT_SIZE_512)
4821                 hash_lut_size = 1;
4822         val |= (hash_lut_size << I40E_PFQF_CTL_0_HASHLUTSIZE_SHIFT) &
4823                 I40E_PFQF_CTL_0_HASHLUTSIZE_MASK;
4824
4825         /* Enable FDIR, Ethertype and MACVLAN filters for PF and VFs */
4826         if (settings->enable_fdir)
4827                 val |= I40E_PFQF_CTL_0_FD_ENA_MASK;
4828         if (settings->enable_ethtype)
4829                 val |= I40E_PFQF_CTL_0_ETYPE_ENA_MASK;
4830         if (settings->enable_macvlan)
4831                 val |= I40E_PFQF_CTL_0_MACVLAN_ENA_MASK;
4832
4833         wr32(hw, I40E_PFQF_CTL_0, val);
4834
4835         return I40E_SUCCESS;
4836 }
4837
4838 /**
4839  * i40e_aq_add_rem_control_packet_filter - Add or Remove Control Packet Filter
4840  * @hw: pointer to the hw struct
4841  * @mac_addr: MAC address to use in the filter
4842  * @ethtype: Ethertype to use in the filter
4843  * @flags: Flags that needs to be applied to the filter
4844  * @vsi_seid: seid of the control VSI
4845  * @queue: VSI queue number to send the packet to
4846  * @is_add: Add control packet filter if True else remove
4847  * @stats: Structure to hold information on control filter counts
4848  * @cmd_details: pointer to command details structure or NULL
4849  *
4850  * This command will Add or Remove control packet filter for a control VSI.
4851  * In return it will update the total number of perfect filter count in
4852  * the stats member.
4853  **/
4854 enum i40e_status_code i40e_aq_add_rem_control_packet_filter(struct i40e_hw *hw,
4855                                 u8 *mac_addr, u16 ethtype, u16 flags,
4856                                 u16 vsi_seid, u16 queue, bool is_add,
4857                                 struct i40e_control_filter_stats *stats,
4858                                 struct i40e_asq_cmd_details *cmd_details)
4859 {
4860         struct i40e_aq_desc desc;
4861         struct i40e_aqc_add_remove_control_packet_filter *cmd =
4862                 (struct i40e_aqc_add_remove_control_packet_filter *)
4863                 &desc.params.raw;
4864         struct i40e_aqc_add_remove_control_packet_filter_completion *resp =
4865                 (struct i40e_aqc_add_remove_control_packet_filter_completion *)
4866                 &desc.params.raw;
4867         enum i40e_status_code status;
4868
4869         if (vsi_seid == 0)
4870                 return I40E_ERR_PARAM;
4871
4872         if (is_add) {
4873                 i40e_fill_default_direct_cmd_desc(&desc,
4874                                 i40e_aqc_opc_add_control_packet_filter);
4875                 cmd->queue = CPU_TO_LE16(queue);
4876         } else {
4877                 i40e_fill_default_direct_cmd_desc(&desc,
4878                                 i40e_aqc_opc_remove_control_packet_filter);
4879         }
4880
4881         if (mac_addr)
4882                 i40e_memcpy(cmd->mac, mac_addr, I40E_ETH_LENGTH_OF_ADDRESS,
4883                             I40E_NONDMA_TO_NONDMA);
4884
4885         cmd->etype = CPU_TO_LE16(ethtype);
4886         cmd->flags = CPU_TO_LE16(flags);
4887         cmd->seid = CPU_TO_LE16(vsi_seid);
4888
4889         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
4890
4891         if (!status && stats) {
4892                 stats->mac_etype_used = LE16_TO_CPU(resp->mac_etype_used);
4893                 stats->etype_used = LE16_TO_CPU(resp->etype_used);
4894                 stats->mac_etype_free = LE16_TO_CPU(resp->mac_etype_free);
4895                 stats->etype_free = LE16_TO_CPU(resp->etype_free);
4896         }
4897
4898         return status;
4899 }
4900
4901 /**
4902  * i40e_add_filter_to_drop_tx_flow_control_frames- filter to drop flow control
4903  * @hw: pointer to the hw struct
4904  * @seid: VSI seid to add ethertype filter from
4905  **/
4906 #define I40E_FLOW_CONTROL_ETHTYPE 0x8808
4907 void i40e_add_filter_to_drop_tx_flow_control_frames(struct i40e_hw *hw,
4908                                                     u16 seid)
4909 {
4910         u16 flag = I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC |
4911                    I40E_AQC_ADD_CONTROL_PACKET_FLAGS_DROP |
4912                    I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TX;
4913         u16 ethtype = I40E_FLOW_CONTROL_ETHTYPE;
4914         enum i40e_status_code status;
4915
4916         status = i40e_aq_add_rem_control_packet_filter(hw, 0, ethtype, flag,
4917                                                        seid, 0, true, NULL,
4918                                                        NULL);
4919         if (status)
4920                 DEBUGOUT("Ethtype Filter Add failed: Error pruning Tx flow control frames\n");
4921 }
4922
4923 /**
4924  * i40e_aq_add_cloud_filters
4925  * @hw: pointer to the hardware structure
4926  * @seid: VSI seid to add cloud filters from
4927  * @filters: Buffer which contains the filters to be added
4928  * @filter_count: number of filters contained in the buffer
4929  *
4930  * Set the cloud filters for a given VSI.  The contents of the
4931  * i40e_aqc_add_remove_cloud_filters_element_data are filled
4932  * in by the caller of the function.
4933  *
4934  **/
4935 enum i40e_status_code i40e_aq_add_cloud_filters(struct i40e_hw *hw,
4936         u16 seid,
4937         struct i40e_aqc_add_remove_cloud_filters_element_data *filters,
4938         u8 filter_count)
4939 {
4940         struct i40e_aq_desc desc;
4941         struct i40e_aqc_add_remove_cloud_filters *cmd =
4942         (struct i40e_aqc_add_remove_cloud_filters *)&desc.params.raw;
4943         u16 buff_len;
4944         enum i40e_status_code status;
4945
4946         i40e_fill_default_direct_cmd_desc(&desc,
4947                                           i40e_aqc_opc_add_cloud_filters);
4948
4949         buff_len = filter_count * sizeof(*filters);
4950         desc.datalen = CPU_TO_LE16(buff_len);
4951         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
4952         cmd->num_filters = filter_count;
4953         cmd->seid = CPU_TO_LE16(seid);
4954
4955         status = i40e_asq_send_command(hw, &desc, filters, buff_len, NULL);
4956
4957         return status;
4958 }
4959
4960 /**
4961  * i40e_aq_remove_cloud_filters
4962  * @hw: pointer to the hardware structure
4963  * @seid: VSI seid to remove cloud filters from
4964  * @filters: Buffer which contains the filters to be removed
4965  * @filter_count: number of filters contained in the buffer
4966  *
4967  * Remove the cloud filters for a given VSI.  The contents of the
4968  * i40e_aqc_add_remove_cloud_filters_element_data are filled
4969  * in by the caller of the function.
4970  *
4971  **/
4972 enum i40e_status_code i40e_aq_remove_cloud_filters(struct i40e_hw *hw,
4973                 u16 seid,
4974                 struct i40e_aqc_add_remove_cloud_filters_element_data *filters,
4975                 u8 filter_count)
4976 {
4977         struct i40e_aq_desc desc;
4978         struct i40e_aqc_add_remove_cloud_filters *cmd =
4979         (struct i40e_aqc_add_remove_cloud_filters *)&desc.params.raw;
4980         enum i40e_status_code status;
4981         u16 buff_len;
4982
4983         i40e_fill_default_direct_cmd_desc(&desc,
4984                                           i40e_aqc_opc_remove_cloud_filters);
4985
4986         buff_len = filter_count * sizeof(*filters);
4987         desc.datalen = CPU_TO_LE16(buff_len);
4988         desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF | I40E_AQ_FLAG_RD));
4989         cmd->num_filters = filter_count;
4990         cmd->seid = CPU_TO_LE16(seid);
4991
4992         status = i40e_asq_send_command(hw, &desc, filters, buff_len, NULL);
4993
4994         return status;
4995 }
4996
4997 /**
4998  * i40e_aq_alternate_write
4999  * @hw: pointer to the hardware structure
5000  * @reg_addr0: address of first dword to be read
5001  * @reg_val0: value to be written under 'reg_addr0'
5002  * @reg_addr1: address of second dword to be read
5003  * @reg_val1: value to be written under 'reg_addr1'
5004  *
5005  * Write one or two dwords to alternate structure. Fields are indicated
5006  * by 'reg_addr0' and 'reg_addr1' register numbers.
5007  *
5008  **/
5009 enum i40e_status_code i40e_aq_alternate_write(struct i40e_hw *hw,
5010                                 u32 reg_addr0, u32 reg_val0,
5011                                 u32 reg_addr1, u32 reg_val1)
5012 {
5013         struct i40e_aq_desc desc;
5014         struct i40e_aqc_alternate_write *cmd_resp =
5015                 (struct i40e_aqc_alternate_write *)&desc.params.raw;
5016         enum i40e_status_code status;
5017
5018         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_alternate_write);
5019         cmd_resp->address0 = CPU_TO_LE32(reg_addr0);
5020         cmd_resp->address1 = CPU_TO_LE32(reg_addr1);
5021         cmd_resp->data0 = CPU_TO_LE32(reg_val0);
5022         cmd_resp->data1 = CPU_TO_LE32(reg_val1);
5023
5024         status = i40e_asq_send_command(hw, &desc, NULL, 0, NULL);
5025
5026         return status;
5027 }
5028
5029 /**
5030  * i40e_aq_alternate_write_indirect
5031  * @hw: pointer to the hardware structure
5032  * @addr: address of a first register to be modified
5033  * @dw_count: number of alternate structure fields to write
5034  * @buffer: pointer to the command buffer
5035  *
5036  * Write 'dw_count' dwords from 'buffer' to alternate structure
5037  * starting at 'addr'.
5038  *
5039  **/
5040 enum i40e_status_code i40e_aq_alternate_write_indirect(struct i40e_hw *hw,
5041                                 u32 addr, u32 dw_count, void *buffer)
5042 {
5043         struct i40e_aq_desc desc;
5044         struct i40e_aqc_alternate_ind_write *cmd_resp =
5045                 (struct i40e_aqc_alternate_ind_write *)&desc.params.raw;
5046         enum i40e_status_code status;
5047
5048         if (buffer == NULL)
5049                 return I40E_ERR_PARAM;
5050
5051         /* Indirect command */
5052         i40e_fill_default_direct_cmd_desc(&desc,
5053                                          i40e_aqc_opc_alternate_write_indirect);
5054
5055         desc.flags |= CPU_TO_LE16(I40E_AQ_FLAG_RD);
5056         desc.flags |= CPU_TO_LE16(I40E_AQ_FLAG_BUF);
5057         if (dw_count > (I40E_AQ_LARGE_BUF/4))
5058                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
5059
5060         cmd_resp->address = CPU_TO_LE32(addr);
5061         cmd_resp->length = CPU_TO_LE32(dw_count);
5062         cmd_resp->addr_high = CPU_TO_LE32(I40E_HI_WORD((u64)buffer));
5063         cmd_resp->addr_low = CPU_TO_LE32(I40E_LO_DWORD((u64)buffer));
5064
5065         status = i40e_asq_send_command(hw, &desc, buffer,
5066                                        I40E_LO_DWORD(4*dw_count), NULL);
5067
5068         return status;
5069 }
5070
5071 /**
5072  * i40e_aq_alternate_read
5073  * @hw: pointer to the hardware structure
5074  * @reg_addr0: address of first dword to be read
5075  * @reg_val0: pointer for data read from 'reg_addr0'
5076  * @reg_addr1: address of second dword to be read
5077  * @reg_val1: pointer for data read from 'reg_addr1'
5078  *
5079  * Read one or two dwords from alternate structure. Fields are indicated
5080  * by 'reg_addr0' and 'reg_addr1' register numbers. If 'reg_val1' pointer
5081  * is not passed then only register at 'reg_addr0' is read.
5082  *
5083  **/
5084 enum i40e_status_code i40e_aq_alternate_read(struct i40e_hw *hw,
5085                                 u32 reg_addr0, u32 *reg_val0,
5086                                 u32 reg_addr1, u32 *reg_val1)
5087 {
5088         struct i40e_aq_desc desc;
5089         struct i40e_aqc_alternate_write *cmd_resp =
5090                 (struct i40e_aqc_alternate_write *)&desc.params.raw;
5091         enum i40e_status_code status;
5092
5093         if (reg_val0 == NULL)
5094                 return I40E_ERR_PARAM;
5095
5096         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_alternate_read);
5097         cmd_resp->address0 = CPU_TO_LE32(reg_addr0);
5098         cmd_resp->address1 = CPU_TO_LE32(reg_addr1);
5099
5100         status = i40e_asq_send_command(hw, &desc, NULL, 0, NULL);
5101
5102         if (status == I40E_SUCCESS) {
5103                 *reg_val0 = LE32_TO_CPU(cmd_resp->data0);
5104
5105                 if (reg_val1 != NULL)
5106                         *reg_val1 = LE32_TO_CPU(cmd_resp->data1);
5107         }
5108
5109         return status;
5110 }
5111
5112 /**
5113  * i40e_aq_alternate_read_indirect
5114  * @hw: pointer to the hardware structure
5115  * @addr: address of the alternate structure field
5116  * @dw_count: number of alternate structure fields to read
5117  * @buffer: pointer to the command buffer
5118  *
5119  * Read 'dw_count' dwords from alternate structure starting at 'addr' and
5120  * place them in 'buffer'. The buffer should be allocated by caller.
5121  *
5122  **/
5123 enum i40e_status_code i40e_aq_alternate_read_indirect(struct i40e_hw *hw,
5124                                 u32 addr, u32 dw_count, void *buffer)
5125 {
5126         struct i40e_aq_desc desc;
5127         struct i40e_aqc_alternate_ind_write *cmd_resp =
5128                 (struct i40e_aqc_alternate_ind_write *)&desc.params.raw;
5129         enum i40e_status_code status;
5130
5131         if (buffer == NULL)
5132                 return I40E_ERR_PARAM;
5133
5134         /* Indirect command */
5135         i40e_fill_default_direct_cmd_desc(&desc,
5136                 i40e_aqc_opc_alternate_read_indirect);
5137
5138         desc.flags |= CPU_TO_LE16(I40E_AQ_FLAG_RD);
5139         desc.flags |= CPU_TO_LE16(I40E_AQ_FLAG_BUF);
5140         if (dw_count > (I40E_AQ_LARGE_BUF/4))
5141                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
5142
5143         cmd_resp->address = CPU_TO_LE32(addr);
5144         cmd_resp->length = CPU_TO_LE32(dw_count);
5145         cmd_resp->addr_high = CPU_TO_LE32(I40E_HI_DWORD((u64)buffer));
5146         cmd_resp->addr_low = CPU_TO_LE32(I40E_LO_DWORD((u64)buffer));
5147
5148         status = i40e_asq_send_command(hw, &desc, buffer,
5149                                        I40E_LO_DWORD(4*dw_count), NULL);
5150
5151         return status;
5152 }
5153
5154 /**
5155  *  i40e_aq_alternate_clear
5156  *  @hw: pointer to the HW structure.
5157  *
5158  *  Clear the alternate structures of the port from which the function
5159  *  is called.
5160  *
5161  **/
5162 enum i40e_status_code i40e_aq_alternate_clear(struct i40e_hw *hw)
5163 {
5164         struct i40e_aq_desc desc;
5165         enum i40e_status_code status;
5166
5167         i40e_fill_default_direct_cmd_desc(&desc,
5168                                           i40e_aqc_opc_alternate_clear_port);
5169
5170         status = i40e_asq_send_command(hw, &desc, NULL, 0, NULL);
5171
5172         return status;
5173 }
5174
5175 /**
5176  *  i40e_aq_alternate_write_done
5177  *  @hw: pointer to the HW structure.
5178  *  @bios_mode: indicates whether the command is executed by UEFI or legacy BIOS
5179  *  @reset_needed: indicates the SW should trigger GLOBAL reset
5180  *
5181  *  Indicates to the FW that alternate structures have been changed.
5182  *
5183  **/
5184 enum i40e_status_code i40e_aq_alternate_write_done(struct i40e_hw *hw,
5185                 u8 bios_mode, bool *reset_needed)
5186 {
5187         struct i40e_aq_desc desc;
5188         struct i40e_aqc_alternate_write_done *cmd =
5189                 (struct i40e_aqc_alternate_write_done *)&desc.params.raw;
5190         enum i40e_status_code status;
5191
5192         if (reset_needed == NULL)
5193                 return I40E_ERR_PARAM;
5194
5195         i40e_fill_default_direct_cmd_desc(&desc,
5196                                           i40e_aqc_opc_alternate_write_done);
5197
5198         cmd->cmd_flags = CPU_TO_LE16(bios_mode);
5199
5200         status = i40e_asq_send_command(hw, &desc, NULL, 0, NULL);
5201         if (!status && reset_needed)
5202                 *reset_needed = ((LE16_TO_CPU(cmd->cmd_flags) &
5203                                  I40E_AQ_ALTERNATE_RESET_NEEDED) != 0);
5204
5205         return status;
5206 }
5207
5208 /**
5209  *  i40e_aq_set_oem_mode
5210  *  @hw: pointer to the HW structure.
5211  *  @oem_mode: the OEM mode to be used
5212  *
5213  *  Sets the device to a specific operating mode. Currently the only supported
5214  *  mode is no_clp, which causes FW to refrain from using Alternate RAM.
5215  *
5216  **/
5217 enum i40e_status_code i40e_aq_set_oem_mode(struct i40e_hw *hw,
5218                 u8 oem_mode)
5219 {
5220         struct i40e_aq_desc desc;
5221         struct i40e_aqc_alternate_write_done *cmd =
5222                 (struct i40e_aqc_alternate_write_done *)&desc.params.raw;
5223         enum i40e_status_code status;
5224
5225         i40e_fill_default_direct_cmd_desc(&desc,
5226                                           i40e_aqc_opc_alternate_set_mode);
5227
5228         cmd->cmd_flags = CPU_TO_LE16(oem_mode);
5229
5230         status = i40e_asq_send_command(hw, &desc, NULL, 0, NULL);
5231
5232         return status;
5233 }
5234
5235 /**
5236  * i40e_aq_resume_port_tx
5237  * @hw: pointer to the hardware structure
5238  * @cmd_details: pointer to command details structure or NULL
5239  *
5240  * Resume port's Tx traffic
5241  **/
5242 enum i40e_status_code i40e_aq_resume_port_tx(struct i40e_hw *hw,
5243                                 struct i40e_asq_cmd_details *cmd_details)
5244 {
5245         struct i40e_aq_desc desc;
5246         enum i40e_status_code status;
5247
5248         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_resume_port_tx);
5249
5250         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
5251
5252         return status;
5253 }
5254
5255 /**
5256  * i40e_set_pci_config_data - store PCI bus info
5257  * @hw: pointer to hardware structure
5258  * @link_status: the link status word from PCI config space
5259  *
5260  * Stores the PCI bus info (speed, width, type) within the i40e_hw structure
5261  **/
5262 void i40e_set_pci_config_data(struct i40e_hw *hw, u16 link_status)
5263 {
5264         hw->bus.type = i40e_bus_type_pci_express;
5265
5266         switch (link_status & I40E_PCI_LINK_WIDTH) {
5267         case I40E_PCI_LINK_WIDTH_1:
5268                 hw->bus.width = i40e_bus_width_pcie_x1;
5269                 break;
5270         case I40E_PCI_LINK_WIDTH_2:
5271                 hw->bus.width = i40e_bus_width_pcie_x2;
5272                 break;
5273         case I40E_PCI_LINK_WIDTH_4:
5274                 hw->bus.width = i40e_bus_width_pcie_x4;
5275                 break;
5276         case I40E_PCI_LINK_WIDTH_8:
5277                 hw->bus.width = i40e_bus_width_pcie_x8;
5278                 break;
5279         default:
5280                 hw->bus.width = i40e_bus_width_unknown;
5281                 break;
5282         }
5283
5284         switch (link_status & I40E_PCI_LINK_SPEED) {
5285         case I40E_PCI_LINK_SPEED_2500:
5286                 hw->bus.speed = i40e_bus_speed_2500;
5287                 break;
5288         case I40E_PCI_LINK_SPEED_5000:
5289                 hw->bus.speed = i40e_bus_speed_5000;
5290                 break;
5291         case I40E_PCI_LINK_SPEED_8000:
5292                 hw->bus.speed = i40e_bus_speed_8000;
5293                 break;
5294         default:
5295                 hw->bus.speed = i40e_bus_speed_unknown;
5296                 break;
5297         }
5298 }
5299
5300 /**
5301  * i40e_read_bw_from_alt_ram
5302  * @hw: pointer to the hardware structure
5303  * @max_bw: pointer for max_bw read
5304  * @min_bw: pointer for min_bw read
5305  * @min_valid: pointer for bool that is true if min_bw is a valid value
5306  * @max_valid: pointer for bool that is true if max_bw is a valid value
5307  *
5308  * Read bw from the alternate ram for the given pf
5309  **/
5310 enum i40e_status_code i40e_read_bw_from_alt_ram(struct i40e_hw *hw,
5311                                         u32 *max_bw, u32 *min_bw,
5312                                         bool *min_valid, bool *max_valid)
5313 {
5314         enum i40e_status_code status;
5315         u32 max_bw_addr, min_bw_addr;
5316
5317         /* Calculate the address of the min/max bw registers */
5318         max_bw_addr = I40E_ALT_STRUCT_FIRST_PF_OFFSET +
5319                 I40E_ALT_STRUCT_MAX_BW_OFFSET +
5320                 (I40E_ALT_STRUCT_DWORDS_PER_PF*hw->pf_id);
5321         min_bw_addr = I40E_ALT_STRUCT_FIRST_PF_OFFSET +
5322                 I40E_ALT_STRUCT_MIN_BW_OFFSET +
5323                 (I40E_ALT_STRUCT_DWORDS_PER_PF*hw->pf_id);
5324
5325         /* Read the bandwidths from alt ram */
5326         status = i40e_aq_alternate_read(hw, max_bw_addr, max_bw,
5327                                         min_bw_addr, min_bw);
5328
5329         if (*min_bw & I40E_ALT_BW_VALID_MASK)
5330                 *min_valid = true;
5331         else
5332                 *min_valid = false;
5333
5334         if (*max_bw & I40E_ALT_BW_VALID_MASK)
5335                 *max_valid = true;
5336         else
5337                 *max_valid = false;
5338
5339         return status;
5340 }
5341
5342 /**
5343  * i40e_aq_configure_partition_bw
5344  * @hw: pointer to the hardware structure
5345  * @bw_data: Buffer holding valid pfs and bw limits
5346  * @cmd_details: pointer to command details
5347  *
5348  * Configure partitions guaranteed/max bw
5349  **/
5350 enum i40e_status_code i40e_aq_configure_partition_bw(struct i40e_hw *hw,
5351                         struct i40e_aqc_configure_partition_bw_data *bw_data,
5352                         struct i40e_asq_cmd_details *cmd_details)
5353 {
5354         enum i40e_status_code status;
5355         struct i40e_aq_desc desc;
5356         u16 bwd_size = sizeof(*bw_data);
5357
5358         i40e_fill_default_direct_cmd_desc(&desc,
5359                                 i40e_aqc_opc_configure_partition_bw);
5360
5361         /* Indirect command */
5362         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_BUF);
5363         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_RD);
5364
5365         if (bwd_size > I40E_AQ_LARGE_BUF)
5366                 desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
5367
5368         desc.datalen = CPU_TO_LE16(bwd_size);
5369
5370         status = i40e_asq_send_command(hw, &desc, bw_data, bwd_size, cmd_details);
5371
5372         return status;
5373 }
5374 #endif /* PF_DRIVER */
5375 #ifdef VF_DRIVER
5376
5377 /**
5378  * i40e_aq_send_msg_to_pf
5379  * @hw: pointer to the hardware structure
5380  * @v_opcode: opcodes for VF-PF communication
5381  * @v_retval: return error code
5382  * @msg: pointer to the msg buffer
5383  * @msglen: msg length
5384  * @cmd_details: pointer to command details
5385  *
5386  * Send message to PF driver using admin queue. By default, this message
5387  * is sent asynchronously, i.e. i40e_asq_send_command() does not wait for
5388  * completion before returning.
5389  **/
5390 enum i40e_status_code i40e_aq_send_msg_to_pf(struct i40e_hw *hw,
5391                                 enum i40e_virtchnl_ops v_opcode,
5392                                 enum i40e_status_code v_retval,
5393                                 u8 *msg, u16 msglen,
5394                                 struct i40e_asq_cmd_details *cmd_details)
5395 {
5396         struct i40e_aq_desc desc;
5397         struct i40e_asq_cmd_details details;
5398         enum i40e_status_code status;
5399
5400         i40e_fill_default_direct_cmd_desc(&desc, i40e_aqc_opc_send_msg_to_pf);
5401         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_SI);
5402         desc.cookie_high = CPU_TO_LE32(v_opcode);
5403         desc.cookie_low = CPU_TO_LE32(v_retval);
5404         if (msglen) {
5405                 desc.flags |= CPU_TO_LE16((u16)(I40E_AQ_FLAG_BUF
5406                                                 | I40E_AQ_FLAG_RD));
5407                 if (msglen > I40E_AQ_LARGE_BUF)
5408                         desc.flags |= CPU_TO_LE16((u16)I40E_AQ_FLAG_LB);
5409                 desc.datalen = CPU_TO_LE16(msglen);
5410         }
5411         if (!cmd_details) {
5412                 i40e_memset(&details, 0, sizeof(details), I40E_NONDMA_MEM);
5413                 details.async = true;
5414                 cmd_details = &details;
5415         }
5416         status = i40e_asq_send_command(hw, (struct i40e_aq_desc *)&desc, msg,
5417                                        msglen, cmd_details);
5418         return status;
5419 }
5420
5421 /**
5422  * i40e_vf_parse_hw_config
5423  * @hw: pointer to the hardware structure
5424  * @msg: pointer to the virtual channel VF resource structure
5425  *
5426  * Given a VF resource message from the PF, populate the hw struct
5427  * with appropriate information.
5428  **/
5429 void i40e_vf_parse_hw_config(struct i40e_hw *hw,
5430                              struct i40e_virtchnl_vf_resource *msg)
5431 {
5432         struct i40e_virtchnl_vsi_resource *vsi_res;
5433         int i;
5434
5435         vsi_res = &msg->vsi_res[0];
5436
5437         hw->dev_caps.num_vsis = msg->num_vsis;
5438         hw->dev_caps.num_rx_qp = msg->num_queue_pairs;
5439         hw->dev_caps.num_tx_qp = msg->num_queue_pairs;
5440         hw->dev_caps.num_msix_vectors_vf = msg->max_vectors;
5441         hw->dev_caps.dcb = msg->vf_offload_flags &
5442                            I40E_VIRTCHNL_VF_OFFLOAD_L2;
5443         hw->dev_caps.fcoe = (msg->vf_offload_flags &
5444                              I40E_VIRTCHNL_VF_OFFLOAD_FCOE) ? 1 : 0;
5445         hw->dev_caps.iwarp = (msg->vf_offload_flags &
5446                               I40E_VIRTCHNL_VF_OFFLOAD_IWARP) ? 1 : 0;
5447         for (i = 0; i < msg->num_vsis; i++) {
5448                 if (vsi_res->vsi_type == I40E_VSI_SRIOV) {
5449                         i40e_memcpy(hw->mac.perm_addr,
5450                                     vsi_res->default_mac_addr,
5451                                     I40E_ETH_LENGTH_OF_ADDRESS,
5452                                     I40E_NONDMA_TO_NONDMA);
5453                         i40e_memcpy(hw->mac.addr, vsi_res->default_mac_addr,
5454                                     I40E_ETH_LENGTH_OF_ADDRESS,
5455                                     I40E_NONDMA_TO_NONDMA);
5456                 }
5457                 vsi_res++;
5458         }
5459 }
5460
5461 /**
5462  * i40e_vf_reset
5463  * @hw: pointer to the hardware structure
5464  *
5465  * Send a VF_RESET message to the PF. Does not wait for response from PF
5466  * as none will be forthcoming. Immediately after calling this function,
5467  * the admin queue should be shut down and (optionally) reinitialized.
5468  **/
5469 enum i40e_status_code i40e_vf_reset(struct i40e_hw *hw)
5470 {
5471         return i40e_aq_send_msg_to_pf(hw, I40E_VIRTCHNL_OP_RESET_VF,
5472                                       I40E_SUCCESS, NULL, 0, NULL);
5473 }
5474 #endif /* VF_DRIVER */