drivers/scsi/elx/efct/efct_hw.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (C) 2021 Broadcom. All Rights Reserved. The term
   4  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
   5  */
   6
   7 #ifndef _EFCT_HW_H
   8 #define _EFCT_HW_H
   9
  10 #include "../libefc_sli/sli4.h"
  11
  12 /*
  13  * EFCT PCI IDs
  14  */
  15 #define EFCT_VENDOR_ID                  0x10df
  16 /* LightPulse 16Gb x 4 FC (lancer-g6) */
  17 #define EFCT_DEVICE_LANCER_G6           0xe307
  18 /* LightPulse 32Gb x 4 FC (lancer-g7) */
  19 #define EFCT_DEVICE_LANCER_G7           0xf407
  20
  21 /*Default RQ entries len used by driver*/
  22 #define EFCT_HW_RQ_ENTRIES_MIN          512
  23 #define EFCT_HW_RQ_ENTRIES_DEF          1024
  24 #define EFCT_HW_RQ_ENTRIES_MAX          4096
  25
  26 /*Defines the size of the RQ buffers used for each RQ*/
  27 #define EFCT_HW_RQ_SIZE_HDR             128
  28 #define EFCT_HW_RQ_SIZE_PAYLOAD         1024
  29
  30 /*Define the maximum number of multi-receive queues*/
  31 #define EFCT_HW_MAX_MRQS                8
  32
  33 /*
  34  * Define count of when to set the WQEC bit in a submitted
  35  * WQE, causing a consummed/released completion to be posted.
  36  */
  37 #define EFCT_HW_WQEC_SET_COUNT          32
  38
  39 /*Send frame timeout in seconds*/
  40 #define EFCT_HW_SEND_FRAME_TIMEOUT      10
  41
  42 /*
  43  * FDT Transfer Hint value, reads greater than this value
  44  * will be segmented to implement fairness. A value of zero disables
  45  * the feature.
  46  */
  47 #define EFCT_HW_FDT_XFER_HINT           8192
  48
  49 #define EFCT_HW_TIMECHECK_ITERATIONS    100
  50 #define EFCT_HW_MAX_NUM_MQ              1
  51 #define EFCT_HW_MAX_NUM_RQ              32
  52 #define EFCT_HW_MAX_NUM_EQ              16
  53 #define EFCT_HW_MAX_NUM_WQ              32
  54 #define EFCT_HW_DEF_NUM_EQ              1
  55
  56 #define OCE_HW_MAX_NUM_MRQ_PAIRS        16
  57
  58 #define EFCT_HW_MQ_DEPTH                128
  59 #define EFCT_HW_EQ_DEPTH                1024
  60
  61 /*
  62  * A CQ will be assinged to each WQ
  63  * (CQ must have 2X entries of the WQ for abort
  64  * processing), plus a separate one for each RQ PAIR and one for MQ
  65  */
  66 #define EFCT_HW_MAX_NUM_CQ \
  67         ((EFCT_HW_MAX_NUM_WQ * 2) + 1 + (OCE_HW_MAX_NUM_MRQ_PAIRS * 2))
  68
  69 #define EFCT_HW_Q_HASH_SIZE             128
  70 #define EFCT_HW_RQ_HEADER_SIZE          128
  71 #define EFCT_HW_RQ_HEADER_INDEX         0
  72
  73 #define EFCT_HW_REQUE_XRI_REGTAG        65534
  74
  75 /* Options for efct_hw_command() */
  76 enum efct_cmd_opts {
  77         /* command executes synchronously and busy-waits for completion */
  78         EFCT_CMD_POLL,
  79         /* command executes asynchronously. Uses callback */
  80         EFCT_CMD_NOWAIT,
  81 };
  82
  83 enum efct_hw_reset {
  84         EFCT_HW_RESET_FUNCTION,
  85         EFCT_HW_RESET_FIRMWARE,
  86         EFCT_HW_RESET_MAX
  87 };
  88
  89 enum efct_hw_topo {
  90         EFCT_HW_TOPOLOGY_AUTO,
  91         EFCT_HW_TOPOLOGY_NPORT,
  92         EFCT_HW_TOPOLOGY_LOOP,
  93         EFCT_HW_TOPOLOGY_NONE,
  94         EFCT_HW_TOPOLOGY_MAX
  95 };
  96
  97 /* pack fw revision values into a single uint64_t */
  98 #define HW_FWREV(a, b, c, d) (((uint64_t)(a) << 48) | ((uint64_t)(b) << 32) \
  99                         | ((uint64_t)(c) << 16) | ((uint64_t)(d)))
 100
 101 #define EFCT_FW_VER_STR(a, b, c, d) (#a "." #b "." #c "." #d)
 102
 103 enum efct_hw_io_type {
 104         EFCT_HW_ELS_REQ,
 105         EFCT_HW_ELS_RSP,
 106         EFCT_HW_FC_CT,
 107         EFCT_HW_FC_CT_RSP,
 108         EFCT_HW_BLS_ACC,
 109         EFCT_HW_BLS_RJT,
 110         EFCT_HW_IO_TARGET_READ,
 111         EFCT_HW_IO_TARGET_WRITE,
 112         EFCT_HW_IO_TARGET_RSP,
 113         EFCT_HW_IO_DNRX_REQUEUE,
 114         EFCT_HW_IO_MAX,
 115 };
 116
 117 enum efct_hw_io_state {
 118         EFCT_HW_IO_STATE_FREE,
 119         EFCT_HW_IO_STATE_INUSE,
 120         EFCT_HW_IO_STATE_WAIT_FREE,
 121         EFCT_HW_IO_STATE_WAIT_SEC_HIO,
 122 };
 123
 124 #define EFCT_TARGET_WRITE_SKIPS 1
 125 #define EFCT_TARGET_READ_SKIPS  2
 126
 127 struct efct_hw;
 128 struct efct_io;
 129
 130 #define EFCT_CMD_CTX_POOL_SZ    32
 131 /**
 132  * HW command context.
 133  * Stores the state for the asynchronous commands sent to the hardware.
 134  */
 135 struct efct_command_ctx {
 136         struct list_head        list_entry;
 137         int (*cb)(struct efct_hw *hw, int status, u8 *mqe, void *arg);
 138         void                    *arg;   /* Argument for callback */
 139         /* buffer holding command / results */
 140         u8                      buf[SLI4_BMBX_SIZE];
 141         void                    *ctx;   /* upper layer context */
 142 };
 143
 144 struct efct_hw_sgl {
 145         uintptr_t               addr;
 146         size_t                  len;
 147 };
 148
 149 union efct_hw_io_param_u {
 150         struct sli_bls_params bls;
 151         struct sli_els_params els;
 152         struct sli_ct_params fc_ct;
 153         struct sli_fcp_tgt_params fcp_tgt;
 154 };
 155
 156 /* WQ steering mode */
 157 enum efct_hw_wq_steering {
 158         EFCT_HW_WQ_STEERING_CLASS,
 159         EFCT_HW_WQ_STEERING_REQUEST,
 160         EFCT_HW_WQ_STEERING_CPU,
 161 };
 162
 163 /* HW wqe object */
 164 struct efct_hw_wqe {
 165         struct list_head        list_entry;
 166         bool                    abort_wqe_submit_needed;
 167         bool                    send_abts;
 168         u32                     id;
 169         u32                     abort_reqtag;
 170         u8                      *wqebuf;
 171 };
 172
 173 struct efct_hw_io;
 174 /* Typedef for HW "done" callback */
 175 typedef int (*efct_hw_done_t)(struct efct_hw_io *, u32 len, int status,
 176                               u32 ext, void *ul_arg);
 177
 178 /**
 179  * HW IO object.
 180  *
 181  * Stores the per-IO information necessary
 182  * for both SLI and efct.
 183  * @ref:                reference counter for hw io object
 184  * @state:              state of IO: free, busy, wait_free
 185  * @list_entry          used for busy, wait_free, free lists
 186  * @wqe                 Work queue object, with link for pending
 187  * @hw                  pointer back to hardware context
 188  * @xfer_rdy            transfer ready data
 189  * @type                IO type
 190  * @xbusy               Exchange is active in FW
 191  * @abort_in_progress   if TRUE, abort is in progress
 192  * @status_saved        if TRUE, latched status should be returned
 193  * @wq_class            WQ class if steering mode is Class
 194  * @reqtag              request tag for this HW IO
 195  * @wq                  WQ assigned to the exchange
 196  * @done                Function called on IO completion
 197  * @arg                 argument passed to IO done callback
 198  * @abort_done          Function called on abort completion
 199  * @abort_arg           argument passed to abort done callback
 200  * @wq_steering         WQ steering mode request
 201  * @saved_status        Saved status
 202  * @saved_len           Status length
 203  * @saved_ext           Saved extended status
 204  * @eq                  EQ on which this HIO came up
 205  * @sge_offset          SGE data offset
 206  * @def_sgl_count       Count of SGEs in default SGL
 207  * @abort_reqtag        request tag for an abort of this HW IO
 208  * @indicator           Exchange indicator
 209  * @def_sgl             default SGL
 210  * @sgl                 pointer to current active SGL
 211  * @sgl_count           count of SGEs in io->sgl
 212  * @first_data_sge      index of first data SGE
 213  * @n_sge               number of active SGEs
 214  */
 215 struct efct_hw_io {
 216         struct kref             ref;
 217         enum efct_hw_io_state   state;
 218         void                    (*release)(struct kref *arg);
 219         struct list_head        list_entry;
 220         struct efct_hw_wqe      wqe;
 221
 222         struct efct_hw          *hw;
 223         struct efc_dma          xfer_rdy;
 224         u16                     type;
 225         bool                    xbusy;
 226         int                     abort_in_progress;
 227         bool                    status_saved;
 228         u8                      wq_class;
 229         u16                     reqtag;
 230
 231         struct hw_wq            *wq;
 232         efct_hw_done_t          done;
 233         void                    *arg;
 234         efct_hw_done_t          abort_done;
 235         void                    *abort_arg;
 236
 237         enum efct_hw_wq_steering wq_steering;
 238
 239         u32                     saved_status;
 240         u32                     saved_len;
 241         u32                     saved_ext;
 242
 243         struct hw_eq            *eq;
 244         u32                     sge_offset;
 245         u32                     def_sgl_count;
 246         u32                     abort_reqtag;
 247         u32                     indicator;
 248         struct efc_dma          def_sgl;
 249         struct efc_dma          *sgl;
 250         u32                     sgl_count;
 251         u32                     first_data_sge;
 252         u32                     n_sge;
 253 };
 254
 255 enum efct_hw_port {
 256         EFCT_HW_PORT_INIT,
 257         EFCT_HW_PORT_SHUTDOWN,
 258 };
 259
 260 /* Node group rpi reference */
 261 struct efct_hw_rpi_ref {
 262         atomic_t rpi_count;
 263         atomic_t rpi_attached;
 264 };
 265
 266 enum efct_hw_link_stat {
 267         EFCT_HW_LINK_STAT_LINK_FAILURE_COUNT,
 268         EFCT_HW_LINK_STAT_LOSS_OF_SYNC_COUNT,
 269         EFCT_HW_LINK_STAT_LOSS_OF_SIGNAL_COUNT,
 270         EFCT_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT,
 271         EFCT_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT,
 272         EFCT_HW_LINK_STAT_CRC_COUNT,
 273         EFCT_HW_LINK_STAT_PRIMITIVE_SEQ_TIMEOUT_COUNT,
 274         EFCT_HW_LINK_STAT_ELASTIC_BUFFER_OVERRUN_COUNT,
 275         EFCT_HW_LINK_STAT_ARB_TIMEOUT_COUNT,
 276         EFCT_HW_LINK_STAT_ADVERTISED_RCV_B2B_CREDIT,
 277         EFCT_HW_LINK_STAT_CURR_RCV_B2B_CREDIT,
 278         EFCT_HW_LINK_STAT_ADVERTISED_XMIT_B2B_CREDIT,
 279         EFCT_HW_LINK_STAT_CURR_XMIT_B2B_CREDIT,
 280         EFCT_HW_LINK_STAT_RCV_EOFA_COUNT,
 281         EFCT_HW_LINK_STAT_RCV_EOFDTI_COUNT,
 282         EFCT_HW_LINK_STAT_RCV_EOFNI_COUNT,
 283         EFCT_HW_LINK_STAT_RCV_SOFF_COUNT,
 284         EFCT_HW_LINK_STAT_RCV_DROPPED_NO_AER_COUNT,
 285         EFCT_HW_LINK_STAT_RCV_DROPPED_NO_RPI_COUNT,
 286         EFCT_HW_LINK_STAT_RCV_DROPPED_NO_XRI_COUNT,
 287         EFCT_HW_LINK_STAT_MAX,
 288 };
 289
 290 enum efct_hw_host_stat {
 291         EFCT_HW_HOST_STAT_TX_KBYTE_COUNT,
 292         EFCT_HW_HOST_STAT_RX_KBYTE_COUNT,
 293         EFCT_HW_HOST_STAT_TX_FRAME_COUNT,
 294         EFCT_HW_HOST_STAT_RX_FRAME_COUNT,
 295         EFCT_HW_HOST_STAT_TX_SEQ_COUNT,
 296         EFCT_HW_HOST_STAT_RX_SEQ_COUNT,
 297         EFCT_HW_HOST_STAT_TOTAL_EXCH_ORIG,
 298         EFCT_HW_HOST_STAT_TOTAL_EXCH_RESP,
 299         EFCT_HW_HOSY_STAT_RX_P_BSY_COUNT,
 300         EFCT_HW_HOST_STAT_RX_F_BSY_COUNT,
 301         EFCT_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_RQ_BUF_COUNT,
 302         EFCT_HW_HOST_STAT_EMPTY_RQ_TIMEOUT_COUNT,
 303         EFCT_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_XRI_COUNT,
 304         EFCT_HW_HOST_STAT_EMPTY_XRI_POOL_COUNT,
 305         EFCT_HW_HOST_STAT_MAX,
 306 };
 307
 308 enum efct_hw_state {
 309         EFCT_HW_STATE_UNINITIALIZED,
 310         EFCT_HW_STATE_QUEUES_ALLOCATED,
 311         EFCT_HW_STATE_ACTIVE,
 312         EFCT_HW_STATE_RESET_IN_PROGRESS,
 313         EFCT_HW_STATE_TEARDOWN_IN_PROGRESS,
 314 };
 315
 316 struct efct_hw_link_stat_counts {
 317         u8              overflow;
 318         u32             counter;
 319 };
 320
 321 struct efct_hw_host_stat_counts {
 322         u32             counter;
 323 };
 324
 325 /* Structure used for the hash lookup of queue IDs */
 326 struct efct_queue_hash {
 327         bool            in_use;
 328         u16             id;
 329         u16             index;
 330 };
 331
 332 /* WQ callback object */
 333 struct hw_wq_callback {
 334         u16             instance_index; /* use for request tag */
 335         void (*callback)(void *arg, u8 *cqe, int status);
 336         void            *arg;
 337         struct list_head list_entry;
 338 };
 339
 340 struct reqtag_pool {
 341         spinlock_t lock;        /* pool lock */
 342         struct hw_wq_callback *tags[U16_MAX];
 343         struct list_head freelist;
 344 };
 345
 346 struct efct_hw_config {
 347         u32             n_eq;
 348         u32             n_cq;
 349         u32             n_mq;
 350         u32             n_rq;
 351         u32             n_wq;
 352         u32             n_io;
 353         u32             n_sgl;
 354         u32             speed;
 355         u32             topology;
 356         /* size of the buffers for first burst */
 357         u32             rq_default_buffer_size;
 358         u8              esoc;
 359         /* MRQ RQ selection policy */
 360         u8              rq_selection_policy;
 361         /* RQ quanta if rq_selection_policy == 2 */
 362         u8              rr_quanta;
 363         u32             filter_def[SLI4_CMD_REG_FCFI_NUM_RQ_CFG];
 364 };
 365
 366 struct efct_hw {
 367         struct efct             *os;
 368         struct sli4             sli;
 369         u16                     ulp_start;
 370         u16                     ulp_max;
 371         u32                     dump_size;
 372         enum efct_hw_state      state;
 373         bool                    hw_setup_called;
 374         u8                      sliport_healthcheck;
 375         u16                     fcf_indicator;
 376
 377         /* HW configuration */
 378         struct efct_hw_config   config;
 379
 380         /* calculated queue sizes for each type */
 381         u32                     num_qentries[SLI4_QTYPE_MAX];
 382
 383         /* Storage for SLI queue objects */
 384         struct sli4_queue       wq[EFCT_HW_MAX_NUM_WQ];
 385         struct sli4_queue       rq[EFCT_HW_MAX_NUM_RQ];
 386         u16                     hw_rq_lookup[EFCT_HW_MAX_NUM_RQ];
 387         struct sli4_queue       mq[EFCT_HW_MAX_NUM_MQ];
 388         struct sli4_queue       cq[EFCT_HW_MAX_NUM_CQ];
 389         struct sli4_queue       eq[EFCT_HW_MAX_NUM_EQ];
 390
 391         /* HW queue */
 392         u32                     eq_count;
 393         u32                     cq_count;
 394         u32                     mq_count;
 395         u32                     wq_count;
 396         u32                     rq_count;
 397         u32                     cmd_head_count;
 398         struct list_head        eq_list;
 399
 400         struct efct_queue_hash  cq_hash[EFCT_HW_Q_HASH_SIZE];
 401         struct efct_queue_hash  rq_hash[EFCT_HW_Q_HASH_SIZE];
 402         struct efct_queue_hash  wq_hash[EFCT_HW_Q_HASH_SIZE];
 403
 404         /* Storage for HW queue objects */
 405         struct hw_wq            *hw_wq[EFCT_HW_MAX_NUM_WQ];
 406         struct hw_rq            *hw_rq[EFCT_HW_MAX_NUM_RQ];
 407         struct hw_mq            *hw_mq[EFCT_HW_MAX_NUM_MQ];
 408         struct hw_cq            *hw_cq[EFCT_HW_MAX_NUM_CQ];
 409         struct hw_eq            *hw_eq[EFCT_HW_MAX_NUM_EQ];
 410         /* count of hw_rq[] entries */
 411         u32                     hw_rq_count;
 412         /* count of multirq RQs */
 413         u32                     hw_mrq_count;
 414
 415         struct hw_wq            **wq_cpu_array;
 416
 417         /* Sequence objects used in incoming frame processing */
 418         struct efc_hw_sequence  *seq_pool;
 419
 420         /* Maintain an ordered, linked list of outstanding HW commands. */
 421         struct mutex            bmbx_lock;
 422         spinlock_t              cmd_lock;
 423         struct list_head        cmd_head;
 424         struct list_head        cmd_pending;
 425         mempool_t               *cmd_ctx_pool;
 426         mempool_t               *mbox_rqst_pool;
 427
 428         struct sli4_link_event  link;
 429
 430         /* pointer array of IO objects */
 431         struct efct_hw_io       **io;
 432         /* array of WQE buffs mapped to IO objects */
 433         u8                      *wqe_buffs;
 434
 435         /* IO lock to synchronize list access */
 436         spinlock_t              io_lock;
 437         /* List of IO objects in use */
 438         struct list_head        io_inuse;
 439         /* List of IO objects waiting to be freed */
 440         struct list_head        io_wait_free;
 441         /* List of IO objects available for allocation */
 442         struct list_head        io_free;
 443
 444         struct efc_dma          loop_map;
 445
 446         struct efc_dma          xfer_rdy;
 447
 448         struct efc_dma          rnode_mem;
 449
 450         atomic_t                io_alloc_failed_count;
 451
 452         /* stat: wq sumbit count */
 453         u32                     tcmd_wq_submit[EFCT_HW_MAX_NUM_WQ];
 454         /* stat: wq complete count */
 455         u32                     tcmd_wq_complete[EFCT_HW_MAX_NUM_WQ];
 456
 457         atomic_t                send_frame_seq_id;
 458         struct reqtag_pool      *wq_reqtag_pool;
 459 };
 460
 461 enum efct_hw_io_count_type {
 462         EFCT_HW_IO_INUSE_COUNT,
 463         EFCT_HW_IO_FREE_COUNT,
 464         EFCT_HW_IO_WAIT_FREE_COUNT,
 465         EFCT_HW_IO_N_TOTAL_IO_COUNT,
 466 };
 467
 468 /* HW queue data structures */
 469 struct hw_eq {
 470         struct list_head        list_entry;
 471         enum sli4_qtype         type;
 472         u32                     instance;
 473         u32                     entry_count;
 474         u32                     entry_size;
 475         struct efct_hw          *hw;
 476         struct sli4_queue       *queue;
 477         struct list_head        cq_list;
 478         u32                     use_count;
 479 };
 480
 481 struct hw_cq {
 482         struct list_head        list_entry;
 483         enum sli4_qtype         type;
 484         u32                     instance;
 485         u32                     entry_count;
 486         u32                     entry_size;
 487         struct hw_eq            *eq;
 488         struct sli4_queue       *queue;
 489         struct list_head        q_list;
 490         u32                     use_count;
 491 };
 492
 493 struct hw_q {
 494         struct list_head        list_entry;
 495         enum sli4_qtype         type;
 496 };
 497
 498 struct hw_mq {
 499         struct list_head        list_entry;
 500         enum sli4_qtype         type;
 501         u32                     instance;
 502
 503         u32                     entry_count;
 504         u32                     entry_size;
 505         struct hw_cq            *cq;
 506         struct sli4_queue       *queue;
 507
 508         u32                     use_count;
 509 };
 510
 511 struct hw_wq {
 512         struct list_head        list_entry;
 513         enum sli4_qtype         type;
 514         u32                     instance;
 515         struct efct_hw          *hw;
 516
 517         u32                     entry_count;
 518         u32                     entry_size;
 519         struct hw_cq            *cq;
 520         struct sli4_queue       *queue;
 521         u32                     class;
 522
 523         /* WQ consumed */
 524         u32                     wqec_set_count;
 525         u32                     wqec_count;
 526         u32                     free_count;
 527         u32                     total_submit_count;
 528         struct list_head        pending_list;
 529
 530         /* HW IO allocated for use with Send Frame */
 531         struct efct_hw_io       *send_frame_io;
 532
 533         /* Stats */
 534         u32                     use_count;
 535         u32                     wq_pending_count;
 536 };
 537
 538 struct hw_rq {
 539         struct list_head        list_entry;
 540         enum sli4_qtype         type;
 541         u32                     instance;
 542
 543         u32                     entry_count;
 544         u32                     use_count;
 545         u32                     hdr_entry_size;
 546         u32                     first_burst_entry_size;
 547         u32                     data_entry_size;
 548         bool                    is_mrq;
 549         u32                     base_mrq_id;
 550
 551         struct hw_cq            *cq;
 552
 553         u8                      filter_mask;
 554         struct sli4_queue       *hdr;
 555         struct sli4_queue       *first_burst;
 556         struct sli4_queue       *data;
 557
 558         struct efc_hw_rq_buffer *hdr_buf;
 559         struct efc_hw_rq_buffer *fb_buf;
 560         struct efc_hw_rq_buffer *payload_buf;
 561         /* RQ tracker for this RQ */
 562         struct efc_hw_sequence  **rq_tracker;
 563 };
 564
 565 struct efct_hw_send_frame_context {
 566         struct efct_hw          *hw;
 567         struct hw_wq_callback   *wqcb;
 568         struct efct_hw_wqe      wqe;
 569         void (*callback)(int status, void *arg);
 570         void                    *arg;
 571
 572         /* General purpose elements */
 573         struct efc_hw_sequence  *seq;
 574         struct efc_dma          payload;
 575 };
 576
 577 struct efct_hw_grp_hdr {
 578         u32                     size;
 579         __be32                  magic_number;
 580         u32                     word2;
 581         u8                      rev_name[128];
 582         u8                      date[12];
 583         u8                      revision[32];
 584 };
 585
 586 static inline int
 587 efct_hw_get_link_speed(struct efct_hw *hw) {
 588         return hw->link.speed;
 589 }
 590
 591 int
 592 efct_hw_setup(struct efct_hw *hw, void *os, struct pci_dev *pdev);
 593 int efct_hw_init(struct efct_hw *hw);
 594 int
 595 efct_hw_parse_filter(struct efct_hw *hw, void *value);
 596 int
 597 efct_hw_init_queues(struct efct_hw *hw);
 598 int
 599 efct_hw_map_wq_cpu(struct efct_hw *hw);
 600 uint64_t
 601 efct_get_wwnn(struct efct_hw *hw);
 602 uint64_t
 603 efct_get_wwpn(struct efct_hw *hw);
 604
 605 int efct_hw_rx_allocate(struct efct_hw *hw);
 606 int efct_hw_rx_post(struct efct_hw *hw);
 607 void efct_hw_rx_free(struct efct_hw *hw);
 608 int
 609 efct_hw_command(struct efct_hw *hw, u8 *cmd, u32 opts, void *cb,
 610                 void *arg);
 611 int
 612 efct_issue_mbox_rqst(void *base, void *cmd, void *cb, void *arg);
 613
 614 struct efct_hw_io *efct_hw_io_alloc(struct efct_hw *hw);
 615 int efct_hw_io_free(struct efct_hw *hw, struct efct_hw_io *io);
 616 u8 efct_hw_io_inuse(struct efct_hw *hw, struct efct_hw_io *io);
 617 int
 618 efct_hw_io_send(struct efct_hw *hw, enum efct_hw_io_type type,
 619                 struct efct_hw_io *io, union efct_hw_io_param_u *iparam,
 620                 void *cb, void *arg);
 621 int
 622 efct_hw_io_register_sgl(struct efct_hw *hw, struct efct_hw_io *io,
 623                         struct efc_dma *sgl,
 624                         u32 sgl_count);
 625 int
 626 efct_hw_io_init_sges(struct efct_hw *hw,
 627                      struct efct_hw_io *io, enum efct_hw_io_type type);
 628
 629 int
 630 efct_hw_io_add_sge(struct efct_hw *hw, struct efct_hw_io *io,
 631                    uintptr_t addr, u32 length);
 632 int
 633 efct_hw_io_abort(struct efct_hw *hw, struct efct_hw_io *io_to_abort,
 634                  bool send_abts, void *cb, void *arg);
 635 u32
 636 efct_hw_io_get_count(struct efct_hw *hw,
 637                      enum efct_hw_io_count_type io_count_type);
 638 struct efct_hw_io
 639 *efct_hw_io_lookup(struct efct_hw *hw, u32 indicator);
 640 void efct_hw_io_abort_all(struct efct_hw *hw);
 641 void efct_hw_io_free_internal(struct kref *arg);
 642
 643 /* HW WQ request tag API */
 644 struct reqtag_pool *efct_hw_reqtag_pool_alloc(struct efct_hw *hw);
 645 void efct_hw_reqtag_pool_free(struct efct_hw *hw);
 646 struct hw_wq_callback
 647 *efct_hw_reqtag_alloc(struct efct_hw *hw,
 648                         void (*callback)(void *arg, u8 *cqe,
 649                                          int status), void *arg);
 650 void
 651 efct_hw_reqtag_free(struct efct_hw *hw, struct hw_wq_callback *wqcb);
 652 struct hw_wq_callback
 653 *efct_hw_reqtag_get_instance(struct efct_hw *hw, u32 instance_index);
 654
 655 /* RQ completion handlers for RQ pair mode */
 656 int
 657 efct_hw_rqpair_process_rq(struct efct_hw *hw,
 658                           struct hw_cq *cq, u8 *cqe);
 659 int
 660 efct_hw_rqpair_sequence_free(struct efct_hw *hw, struct efc_hw_sequence *seq);
 661 static inline void
 662 efct_hw_sequence_copy(struct efc_hw_sequence *dst,
 663                       struct efc_hw_sequence *src)
 664 {
 665         /* Copy src to dst, then zero out the linked list link */
 666         *dst = *src;
 667 }
 668
 669 int
 670 efct_efc_hw_sequence_free(struct efc *efc, struct efc_hw_sequence *seq);
 671
 672 static inline int
 673 efct_hw_sequence_free(struct efct_hw *hw, struct efc_hw_sequence *seq)
 674 {
 675         /* Only RQ pair mode is supported */
 676         return efct_hw_rqpair_sequence_free(hw, seq);
 677 }
 678
 679 int
 680 efct_hw_eq_process(struct efct_hw *hw, struct hw_eq *eq,
 681                    u32 max_isr_time_msec);
 682 void efct_hw_cq_process(struct efct_hw *hw, struct hw_cq *cq);
 683 void
 684 efct_hw_wq_process(struct efct_hw *hw, struct hw_cq *cq,
 685                    u8 *cqe, int status, u16 rid);
 686 void
 687 efct_hw_xabt_process(struct efct_hw *hw, struct hw_cq *cq,
 688                      u8 *cqe, u16 rid);
 689 int
 690 efct_hw_process(struct efct_hw *hw, u32 vector, u32 max_isr_time_msec);
 691 int
 692 efct_hw_queue_hash_find(struct efct_queue_hash *hash, u16 id);
 693 int efct_hw_wq_write(struct hw_wq *wq, struct efct_hw_wqe *wqe);
 694 int
 695 efct_hw_send_frame(struct efct_hw *hw, struct fc_frame_header *hdr,
 696                    u8 sof, u8 eof, struct efc_dma *payload,
 697                 struct efct_hw_send_frame_context *ctx,
 698                 void (*callback)(void *arg, u8 *cqe, int status),
 699                 void *arg);
 700 int
 701 efct_els_hw_srrs_send(struct efc *efc, struct efc_disc_io *io);
 702 int
 703 efct_efc_bls_send(struct efc *efc, u32 type, struct sli_bls_params *bls);
 704 int
 705 efct_hw_bls_send(struct efct *efct, u32 type, struct sli_bls_params *bls_params,
 706                  void *cb, void *arg);
 707
 708 /* Function for retrieving link statistics */
 709 int
 710 efct_hw_get_link_stats(struct efct_hw *hw,
 711                        u8 req_ext_counters,
 712                        u8 clear_overflow_flags,
 713                        u8 clear_all_counters,
 714                        void (*efct_hw_link_stat_cb_t)(int status,
 715                                                       u32 num_counters,
 716                        struct efct_hw_link_stat_counts *counters, void *arg),
 717                        void *arg);
 718 /* Function for retrieving host statistics */
 719 int
 720 efct_hw_get_host_stats(struct efct_hw *hw,
 721                        u8 cc,
 722                        void (*efct_hw_host_stat_cb_t)(int status,
 723                                                       u32 num_counters,
 724                        struct efct_hw_host_stat_counts *counters, void *arg),
 725                        void *arg);
 726 int
 727 efct_hw_firmware_write(struct efct_hw *hw, struct efc_dma *dma,
 728                        u32 size, u32 offset, int last,
 729                        void (*cb)(int status, u32 bytes_written,
 730                                   u32 change_status, void *arg),
 731                        void *arg);
 732 typedef void (*efct_hw_async_cb_t)(struct efct_hw *hw, int status,
 733                                   u8 *mqe, void *arg);
 734 int
 735 efct_hw_async_call(struct efct_hw *hw, efct_hw_async_cb_t callback, void *arg);
 736
 737 struct hw_eq *efct_hw_new_eq(struct efct_hw *hw, u32 entry_count);
 738 struct hw_cq *efct_hw_new_cq(struct hw_eq *eq, u32 entry_count);
 739 u32
 740 efct_hw_new_cq_set(struct hw_eq *eqs[], struct hw_cq *cqs[],
 741                    u32 num_cqs, u32 entry_count);
 742 struct hw_mq *efct_hw_new_mq(struct hw_cq *cq, u32 entry_count);
 743 struct hw_wq
 744 *efct_hw_new_wq(struct hw_cq *cq, u32 entry_count);
 745 u32
 746 efct_hw_new_rq_set(struct hw_cq *cqs[], struct hw_rq *rqs[],
 747                    u32 num_rq_pairs, u32 entry_count);
 748 void efct_hw_del_eq(struct hw_eq *eq);
 749 void efct_hw_del_cq(struct hw_cq *cq);
 750 void efct_hw_del_mq(struct hw_mq *mq);
 751 void efct_hw_del_wq(struct hw_wq *wq);
 752 void efct_hw_del_rq(struct hw_rq *rq);
 753 void efct_hw_queue_teardown(struct efct_hw *hw);
 754 void efct_hw_teardown(struct efct_hw *hw);
 755 int
 756 efct_hw_reset(struct efct_hw *hw, enum efct_hw_reset reset);
 757
 758 int
 759 efct_hw_port_control(struct efct_hw *hw, enum efct_hw_port ctrl,
 760                      uintptr_t value,
 761                 void (*cb)(int status, uintptr_t value, void *arg),
 762                 void *arg);
 763
 764 #endif /* __EFCT_H__ */