drivers/net/ethernet/qlogic/qed/qed_l2.h

   1 /* QLogic qed NIC Driver
   2  * Copyright (c) 2015-2017  QLogic Corporation
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and /or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32 #ifndef _QED_L2_H
  33 #define _QED_L2_H
  34 #include <linux/types.h>
  35 #include <linux/io.h>
  36 #include <linux/kernel.h>
  37 #include <linux/slab.h>
  38 #include <linux/qed/qed_eth_if.h>
  39 #include "qed.h"
  40 #include "qed_hw.h"
  41 #include "qed_sp.h"
  42 struct qed_rss_params {
  43         u8 update_rss_config;
  44         u8 rss_enable;
  45         u8 rss_eng_id;
  46         u8 update_rss_capabilities;
  47         u8 update_rss_ind_table;
  48         u8 update_rss_key;
  49         u8 rss_caps;
  50         u8 rss_table_size_log;
  51
  52         /* Indirection table consist of rx queue handles */
  53         void *rss_ind_table[QED_RSS_IND_TABLE_SIZE];
  54         u32 rss_key[QED_RSS_KEY_SIZE];
  55 };
  56
  57 struct qed_sge_tpa_params {
  58         u8 max_buffers_per_cqe;
  59
  60         u8 update_tpa_en_flg;
  61         u8 tpa_ipv4_en_flg;
  62         u8 tpa_ipv6_en_flg;
  63         u8 tpa_ipv4_tunn_en_flg;
  64         u8 tpa_ipv6_tunn_en_flg;
  65
  66         u8 update_tpa_param_flg;
  67         u8 tpa_pkt_split_flg;
  68         u8 tpa_hdr_data_split_flg;
  69         u8 tpa_gro_consistent_flg;
  70         u8 tpa_max_aggs_num;
  71         u16 tpa_max_size;
  72         u16 tpa_min_size_to_start;
  73         u16 tpa_min_size_to_cont;
  74 };
  75
  76 enum qed_filter_opcode {
  77         QED_FILTER_ADD,
  78         QED_FILTER_REMOVE,
  79         QED_FILTER_MOVE,
  80         QED_FILTER_REPLACE,     /* Delete all MACs and add new one instead */
  81         QED_FILTER_FLUSH,       /* Removes all filters */
  82 };
  83
  84 enum qed_filter_ucast_type {
  85         QED_FILTER_MAC,
  86         QED_FILTER_VLAN,
  87         QED_FILTER_MAC_VLAN,
  88         QED_FILTER_INNER_MAC,
  89         QED_FILTER_INNER_VLAN,
  90         QED_FILTER_INNER_PAIR,
  91         QED_FILTER_INNER_MAC_VNI_PAIR,
  92         QED_FILTER_MAC_VNI_PAIR,
  93         QED_FILTER_VNI,
  94 };
  95
  96 struct qed_filter_ucast {
  97         enum qed_filter_opcode opcode;
  98         enum qed_filter_ucast_type type;
  99         u8 is_rx_filter;
 100         u8 is_tx_filter;
 101         u8 vport_to_add_to;
 102         u8 vport_to_remove_from;
 103         unsigned char mac[ETH_ALEN];
 104         u8 assert_on_error;
 105         u16 vlan;
 106         u32 vni;
 107 };
 108
 109 struct qed_filter_mcast {
 110         /* MOVE is not supported for multicast */
 111         enum qed_filter_opcode opcode;
 112         u8 vport_to_add_to;
 113         u8 vport_to_remove_from;
 114         u8 num_mc_addrs;
 115 #define QED_MAX_MC_ADDRS        64
 116         unsigned char mac[QED_MAX_MC_ADDRS][ETH_ALEN];
 117 };
 118
 119 /**
 120  * @brief qed_eth_rx_queue_stop - This ramrod closes an Rx queue
 121  *
 122  * @param p_hwfn
 123  * @param p_rxq                 Handler of queue to close
 124  * @param eq_completion_only    If True completion will be on
 125  *                              EQe, if False completion will be
 126  *                              on EQe if p_hwfn opaque
 127  *                              different from the RXQ opaque
 128  *                              otherwise on CQe.
 129  * @param cqe_completion        If True completion will be
 130  *                              receive on CQe.
 131  * @return int
 132  */
 133 int
 134 qed_eth_rx_queue_stop(struct qed_hwfn *p_hwfn,
 135                       void *p_rxq,
 136                       bool eq_completion_only, bool cqe_completion);
 137
 138 /**
 139  * @brief qed_eth_tx_queue_stop - closes a Tx queue
 140  *
 141  * @param p_hwfn
 142  * @param p_txq - handle to Tx queue needed to be closed
 143  *
 144  * @return int
 145  */
 146 int qed_eth_tx_queue_stop(struct qed_hwfn *p_hwfn, void *p_txq);
 147
 148 enum qed_tpa_mode {
 149         QED_TPA_MODE_NONE,
 150         QED_TPA_MODE_UNUSED,
 151         QED_TPA_MODE_GRO,
 152         QED_TPA_MODE_MAX
 153 };
 154
 155 struct qed_sp_vport_start_params {
 156         enum qed_tpa_mode tpa_mode;
 157         bool remove_inner_vlan;
 158         bool tx_switching;
 159         bool handle_ptp_pkts;
 160         bool only_untagged;
 161         bool drop_ttl0;
 162         u8 max_buffers_per_cqe;
 163         u32 concrete_fid;
 164         u16 opaque_fid;
 165         u8 vport_id;
 166         u16 mtu;
 167         bool check_mac;
 168         bool check_ethtype;
 169 };
 170
 171 int qed_sp_eth_vport_start(struct qed_hwfn *p_hwfn,
 172                            struct qed_sp_vport_start_params *p_params);
 173
 174
 175 struct qed_filter_accept_flags {
 176         u8      update_rx_mode_config;
 177         u8      update_tx_mode_config;
 178         u8      rx_accept_filter;
 179         u8      tx_accept_filter;
 180 #define QED_ACCEPT_NONE         0x01
 181 #define QED_ACCEPT_UCAST_MATCHED        0x02
 182 #define QED_ACCEPT_UCAST_UNMATCHED      0x04
 183 #define QED_ACCEPT_MCAST_MATCHED        0x08
 184 #define QED_ACCEPT_MCAST_UNMATCHED      0x10
 185 #define QED_ACCEPT_BCAST                0x20
 186 };
 187
 188 struct qed_sp_vport_update_params {
 189         u16                             opaque_fid;
 190         u8                              vport_id;
 191         u8                              update_vport_active_rx_flg;
 192         u8                              vport_active_rx_flg;
 193         u8                              update_vport_active_tx_flg;
 194         u8                              vport_active_tx_flg;
 195         u8                              update_inner_vlan_removal_flg;
 196         u8                              inner_vlan_removal_flg;
 197         u8                              silent_vlan_removal_flg;
 198         u8                              update_default_vlan_enable_flg;
 199         u8                              default_vlan_enable_flg;
 200         u8                              update_default_vlan_flg;
 201         u16                             default_vlan;
 202         u8                              update_tx_switching_flg;
 203         u8                              tx_switching_flg;
 204         u8                              update_approx_mcast_flg;
 205         u8                              update_anti_spoofing_en_flg;
 206         u8                              anti_spoofing_en;
 207         u8                              update_accept_any_vlan_flg;
 208         u8                              accept_any_vlan;
 209         unsigned long                   bins[8];
 210         struct qed_rss_params           *rss_params;
 211         struct qed_filter_accept_flags  accept_flags;
 212         struct qed_sge_tpa_params       *sge_tpa_params;
 213 };
 214
 215 int qed_sp_vport_update(struct qed_hwfn *p_hwfn,
 216                         struct qed_sp_vport_update_params *p_params,
 217                         enum spq_mode comp_mode,
 218                         struct qed_spq_comp_cb *p_comp_data);
 219
 220 /**
 221  * @brief qed_sp_vport_stop -
 222  *
 223  * This ramrod closes a VPort after all its RX and TX queues are terminated.
 224  * An Assert is generated if any queues are left open.
 225  *
 226  * @param p_hwfn
 227  * @param opaque_fid
 228  * @param vport_id VPort ID
 229  *
 230  * @return int
 231  */
 232 int qed_sp_vport_stop(struct qed_hwfn *p_hwfn, u16 opaque_fid, u8 vport_id);
 233
 234 int qed_sp_eth_filter_ucast(struct qed_hwfn *p_hwfn,
 235                             u16 opaque_fid,
 236                             struct qed_filter_ucast *p_filter_cmd,
 237                             enum spq_mode comp_mode,
 238                             struct qed_spq_comp_cb *p_comp_data);
 239
 240 /**
 241  * @brief qed_sp_rx_eth_queues_update -
 242  *
 243  * This ramrod updates an RX queue. It is used for setting the active state
 244  * of the queue and updating the TPA and SGE parameters.
 245  *
 246  * @note At the moment - only used by non-linux VFs.
 247  *
 248  * @param p_hwfn
 249  * @param pp_rxq_handlers       An array of queue handlers to be updated.
 250  * @param num_rxqs              number of queues to update.
 251  * @param complete_cqe_flg      Post completion to the CQE Ring if set
 252  * @param complete_event_flg    Post completion to the Event Ring if set
 253  * @param comp_mode
 254  * @param p_comp_data
 255  *
 256  * @return int
 257  */
 258
 259 int
 260 qed_sp_eth_rx_queues_update(struct qed_hwfn *p_hwfn,
 261                             void **pp_rxq_handlers,
 262                             u8 num_rxqs,
 263                             u8 complete_cqe_flg,
 264                             u8 complete_event_flg,
 265                             enum spq_mode comp_mode,
 266                             struct qed_spq_comp_cb *p_comp_data);
 267
 268 void qed_get_vport_stats(struct qed_dev *cdev, struct qed_eth_stats *stats);
 269
 270 void qed_reset_vport_stats(struct qed_dev *cdev);
 271
 272 struct qed_queue_cid {
 273         /* 'Relative' is a relative term ;-). Usually the indices [not counting
 274          * SBs] would be PF-relative, but there are some cases where that isn't
 275          * the case - specifically for a PF configuring its VF indices it's
 276          * possible some fields [E.g., stats-id] in 'rel' would already be abs.
 277          */
 278         struct qed_queue_start_common_params rel;
 279         struct qed_queue_start_common_params abs;
 280         u32 cid;
 281         u16 opaque_fid;
 282
 283         /* VFs queues are mapped differently, so we need to know the
 284          * relative queue associated with them [0-based].
 285          * Notice this is relevant on the *PF* queue-cid of its VF's queues,
 286          * and not on the VF itself.
 287          */
 288         bool is_vf;
 289         u8 vf_qid;
 290
 291         /* Legacy VFs might have Rx producer located elsewhere */
 292         bool b_legacy_vf;
 293
 294         struct qed_hwfn *p_owner;
 295 };
 296
 297 void qed_eth_queue_cid_release(struct qed_hwfn *p_hwfn,
 298                                struct qed_queue_cid *p_cid);
 299
 300 struct qed_queue_cid *_qed_eth_queue_to_cid(struct qed_hwfn *p_hwfn,
 301                                             u16 opaque_fid,
 302                                             u32 cid,
 303                                             u8 vf_qid,
 304                                             struct qed_queue_start_common_params
 305                                             *p_params);
 306
 307 int
 308 qed_sp_eth_vport_start(struct qed_hwfn *p_hwfn,
 309                        struct qed_sp_vport_start_params *p_params);
 310
 311 /**
 312  * @brief - Starts an Rx queue, when queue_cid is already prepared
 313  *
 314  * @param p_hwfn
 315  * @param p_cid
 316  * @param bd_max_bytes
 317  * @param bd_chain_phys_addr
 318  * @param cqe_pbl_addr
 319  * @param cqe_pbl_size
 320  *
 321  * @return int
 322  */
 323 int
 324 qed_eth_rxq_start_ramrod(struct qed_hwfn *p_hwfn,
 325                          struct qed_queue_cid *p_cid,
 326                          u16 bd_max_bytes,
 327                          dma_addr_t bd_chain_phys_addr,
 328                          dma_addr_t cqe_pbl_addr, u16 cqe_pbl_size);
 329
 330 /**
 331  * @brief - Starts a Tx queue, where queue_cid is already prepared
 332  *
 333  * @param p_hwfn
 334  * @param p_cid
 335  * @param pbl_addr
 336  * @param pbl_size
 337  * @param p_pq_params - parameters for choosing the PQ for this Tx queue
 338  *
 339  * @return int
 340  */
 341 int
 342 qed_eth_txq_start_ramrod(struct qed_hwfn *p_hwfn,
 343                          struct qed_queue_cid *p_cid,
 344                          dma_addr_t pbl_addr, u16 pbl_size, u16 pq_id);
 345
 346 u8 qed_mcast_bin_from_mac(u8 *mac);
 347
 348 #endif /* _QED_L2_H */