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

   1 /* QLogic qed NIC Driver
   2  * Copyright (c) 2015 QLogic Corporation
   3  *
   4  * This software is available under the terms of the GNU General Public License
   5  * (GPL) Version 2, available from the file COPYING in the main directory of
   6  * this source tree.
   7  */
   8
   9 #ifndef _QED_SP_H
  10 #define _QED_SP_H
  11
  12 #include <linux/types.h>
  13 #include <linux/kernel.h>
  14 #include <linux/list.h>
  15 #include <linux/slab.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/qed/qed_chain.h>
  18 #include "qed.h"
  19 #include "qed_hsi.h"
  20
  21 enum spq_mode {
  22         QED_SPQ_MODE_BLOCK,     /* Client will poll a designated mem. address */
  23         QED_SPQ_MODE_CB,        /* Client supplies a callback */
  24         QED_SPQ_MODE_EBLOCK,    /* QED should block until completion */
  25 };
  26
  27 struct qed_spq_comp_cb {
  28         void    (*function)(struct qed_hwfn *,
  29                             void *,
  30                             union event_ring_data *,
  31                             u8 fw_return_code);
  32         void    *cookie;
  33 };
  34
  35 union ramrod_data {
  36         struct pf_start_ramrod_data pf_start;
  37 };
  38
  39 #define EQ_MAX_CREDIT   0xffffffff
  40
  41 enum spq_priority {
  42         QED_SPQ_PRIORITY_NORMAL,
  43         QED_SPQ_PRIORITY_HIGH,
  44 };
  45
  46 union qed_spq_req_comp {
  47         struct qed_spq_comp_cb  cb;
  48         u64                     *done_addr;
  49 };
  50
  51 struct qed_spq_comp_done {
  52         u64     done;
  53         u8      fw_return_code;
  54 };
  55
  56 struct qed_spq_entry {
  57         struct list_head                list;
  58
  59         u8                              flags;
  60
  61         /* HSI slow path element */
  62         struct slow_path_element        elem;
  63
  64         union ramrod_data               ramrod;
  65
  66         enum spq_priority               priority;
  67
  68         /* pending queue for this entry */
  69         struct list_head                *queue;
  70
  71         enum spq_mode                   comp_mode;
  72         struct qed_spq_comp_cb          comp_cb;
  73         struct qed_spq_comp_done        comp_done; /* SPQ_MODE_EBLOCK */
  74 };
  75
  76 struct qed_eq {
  77         struct qed_chain        chain;
  78         u8                      eq_sb_index;    /* index within the SB */
  79         __le16                  *p_fw_cons;     /* ptr to index value */
  80 };
  81
  82 struct qed_consq {
  83         struct qed_chain chain;
  84 };
  85
  86 struct qed_spq {
  87         spinlock_t              lock; /* SPQ lock */
  88
  89         struct list_head        unlimited_pending;
  90         struct list_head        pending;
  91         struct list_head        completion_pending;
  92         struct list_head        free_pool;
  93
  94         struct qed_chain        chain;
  95
  96         /* allocated dma-able memory for spq entries (+ramrod data) */
  97         dma_addr_t              p_phys;
  98         struct qed_spq_entry    *p_virt;
  99
 100         /* Used as index for completions (returns on EQ by FW) */
 101         u16                     echo_idx;
 102
 103         /* Statistics */
 104         u32                     unlimited_pending_count;
 105         u32                     normal_count;
 106         u32                     high_count;
 107         u32                     comp_sent_count;
 108         u32                     comp_count;
 109
 110         u32                     cid;
 111 };
 112
 113 /**
 114  * @brief qed_spq_post - Posts a Slow hwfn request to FW, or lacking that
 115  *        Pends it to the future list.
 116  *
 117  * @param p_hwfn
 118  * @param p_req
 119  *
 120  * @return int
 121  */
 122 int qed_spq_post(struct qed_hwfn *p_hwfn,
 123                  struct qed_spq_entry *p_ent,
 124                  u8 *fw_return_code);
 125
 126 /**
 127  * @brief qed_spq_allocate - Alloocates & initializes the SPQ and EQ.
 128  *
 129  * @param p_hwfn
 130  *
 131  * @return int
 132  */
 133 int qed_spq_alloc(struct qed_hwfn *p_hwfn);
 134
 135 /**
 136  * @brief qed_spq_setup - Reset the SPQ to its start state.
 137  *
 138  * @param p_hwfn
 139  */
 140 void qed_spq_setup(struct qed_hwfn *p_hwfn);
 141
 142 /**
 143  * @brief qed_spq_deallocate - Deallocates the given SPQ struct.
 144  *
 145  * @param p_hwfn
 146  */
 147 void qed_spq_free(struct qed_hwfn *p_hwfn);
 148
 149 /**
 150  * @brief qed_spq_get_entry - Obtain an entrry from the spq
 151  *        free pool list.
 152  *
 153  *
 154  *
 155  * @param p_hwfn
 156  * @param pp_ent
 157  *
 158  * @return int
 159  */
 160 int
 161 qed_spq_get_entry(struct qed_hwfn *p_hwfn,
 162                   struct qed_spq_entry **pp_ent);
 163
 164 /**
 165  * @brief qed_spq_return_entry - Return an entry to spq free
 166  *                                 pool list
 167  *
 168  * @param p_hwfn
 169  * @param p_ent
 170  */
 171 void qed_spq_return_entry(struct qed_hwfn *p_hwfn,
 172                           struct qed_spq_entry *p_ent);
 173 /**
 174  * @brief qed_eq_allocate - Allocates & initializes an EQ struct
 175  *
 176  * @param p_hwfn
 177  * @param num_elem number of elements in the eq
 178  *
 179  * @return struct qed_eq* - a newly allocated structure; NULL upon error.
 180  */
 181 struct qed_eq *qed_eq_alloc(struct qed_hwfn *p_hwfn,
 182                             u16 num_elem);
 183
 184 /**
 185  * @brief qed_eq_setup - Reset the SPQ to its start state.
 186  *
 187  * @param p_hwfn
 188  * @param p_eq
 189  */
 190 void qed_eq_setup(struct qed_hwfn *p_hwfn,
 191                   struct qed_eq *p_eq);
 192
 193 /**
 194  * @brief qed_eq_deallocate - deallocates the given EQ struct.
 195  *
 196  * @param p_hwfn
 197  * @param p_eq
 198  */
 199 void qed_eq_free(struct qed_hwfn *p_hwfn,
 200                  struct qed_eq *p_eq);
 201
 202 /**
 203  * @brief qed_eq_prod_update - update the FW with default EQ producer
 204  *
 205  * @param p_hwfn
 206  * @param prod
 207  */
 208 void qed_eq_prod_update(struct qed_hwfn *p_hwfn,
 209                         u16 prod);
 210
 211 /**
 212  * @brief qed_eq_completion - Completes currently pending EQ elements
 213  *
 214  * @param p_hwfn
 215  * @param cookie
 216  *
 217  * @return int
 218  */
 219 int qed_eq_completion(struct qed_hwfn *p_hwfn,
 220                       void *cookie);
 221
 222 /**
 223  * @brief qed_spq_completion - Completes a single event
 224  *
 225  * @param p_hwfn
 226  * @param echo - echo value from cookie (used for determining completion)
 227  * @param p_data - data from cookie (used in callback function if applicable)
 228  *
 229  * @return int
 230  */
 231 int qed_spq_completion(struct qed_hwfn *p_hwfn,
 232                        __le16 echo,
 233                        u8 fw_return_code,
 234                        union event_ring_data *p_data);
 235
 236 /**
 237  * @brief qed_spq_get_cid - Given p_hwfn, return cid for the hwfn's SPQ
 238  *
 239  * @param p_hwfn
 240  *
 241  * @return u32 - SPQ CID
 242  */
 243 u32 qed_spq_get_cid(struct qed_hwfn *p_hwfn);
 244
 245 /**
 246  * @brief qed_consq_alloc - Allocates & initializes an ConsQ
 247  *        struct
 248  *
 249  * @param p_hwfn
 250  *
 251  * @return struct qed_eq* - a newly allocated structure; NULL upon error.
 252  */
 253 struct qed_consq *qed_consq_alloc(struct qed_hwfn *p_hwfn);
 254
 255 /**
 256  * @brief qed_consq_setup - Reset the ConsQ to its start
 257  *        state.
 258  *
 259  * @param p_hwfn
 260  * @param p_eq
 261  */
 262 void qed_consq_setup(struct qed_hwfn *p_hwfn,
 263                      struct qed_consq *p_consq);
 264
 265 /**
 266  * @brief qed_consq_free - deallocates the given ConsQ struct.
 267  *
 268  * @param p_hwfn
 269  * @param p_eq
 270  */
 271 void qed_consq_free(struct qed_hwfn *p_hwfn,
 272                     struct qed_consq *p_consq);
 273
 274 /**
 275  * @file
 276  *
 277  * @brief Slow-hwfn low-level commands (Ramrods) function definitions.
 278  */
 279
 280 #define QED_SP_EQ_COMPLETION  0x01
 281 #define QED_SP_CQE_COMPLETION 0x02
 282
 283 struct qed_sp_init_request_params {
 284         size_t                  ramrod_data_size;
 285         enum spq_mode           comp_mode;
 286         struct qed_spq_comp_cb *p_comp_data;
 287 };
 288
 289 int qed_sp_init_request(struct qed_hwfn *p_hwfn,
 290                         struct qed_spq_entry **pp_ent,
 291                         u32 cid,
 292                         u16 opaque_fid,
 293                         u8 cmd,
 294                         u8 protocol,
 295                         struct qed_sp_init_request_params *p_params);
 296
 297 /**
 298  * @brief qed_sp_pf_start - PF Function Start Ramrod
 299  *
 300  * This ramrod is sent to initialize a physical function (PF). It will
 301  * configure the function related parameters and write its completion to the
 302  * event ring specified in the parameters.
 303  *
 304  * Ramrods complete on the common event ring for the PF. This ring is
 305  * allocated by the driver on host memory and its parameters are written
 306  * to the internal RAM of the UStorm by the Function Start Ramrod.
 307  *
 308  * @param p_hwfn
 309  * @param mode
 310  *
 311  * @return int
 312  */
 313
 314 int qed_sp_pf_start(struct qed_hwfn *p_hwfn,
 315                     enum mf_mode mode);
 316
 317 /**
 318  * @brief qed_sp_pf_stop - PF Function Stop Ramrod
 319  *
 320  * This ramrod is sent to close a Physical Function (PF). It is the last ramrod
 321  * sent and the last completion written to the PFs Event Ring. This ramrod also
 322  * deletes the context for the Slowhwfn connection on this PF.
 323  *
 324  * @note Not required for first packet.
 325  *
 326  * @param p_hwfn
 327  *
 328  * @return int
 329  */
 330
 331 int qed_sp_pf_stop(struct qed_hwfn *p_hwfn);
 332
 333 #endif