drivers/common/sfc_efx/base/ef10_impl.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright(c) 2019-2020 Xilinx, Inc.
   4  * Copyright(c) 2015-2019 Solarflare Communications Inc.
   5  */
   6
   7 #ifndef _SYS_EF10_IMPL_H
   8 #define _SYS_EF10_IMPL_H
   9
  10 #ifdef  __cplusplus
  11 extern "C" {
  12 #endif
  13
  14 #define EF10_EVQ_MAXNEVS        32768
  15 #define EF10_EVQ_MINNEVS        512
  16
  17 #define EF10_RXQ_MAXNDESCS      4096
  18 #define EF10_RXQ_MINNDESCS      512
  19
  20 #define EF10_TXQ_MINNDESCS      512
  21
  22 #define EF10_EVQ_DESC_SIZE      (sizeof (efx_qword_t))
  23 #define EF10_RXQ_DESC_SIZE      (sizeof (efx_qword_t))
  24 #define EF10_TXQ_DESC_SIZE      (sizeof (efx_qword_t))
  25
  26 /* Number of hardware EVQ buffers (for compile-time resource dimensions) */
  27 #define EF10_EVQ_MAXNBUFS       (64)
  28
  29 /* Maximum independent of EFX_BUG35388_WORKAROUND. */
  30 #define EF10_TXQ_MAXNBUFS       8
  31
  32 #if EFSYS_OPT_HUNTINGTON
  33 # if (EF10_EVQ_MAXNBUFS < HUNT_EVQ_MAXNBUFS)
  34 #  error "EF10_EVQ_MAXNBUFS too small"
  35 # endif
  36 #endif /* EFSYS_OPT_HUNTINGTON */
  37 #if EFSYS_OPT_MEDFORD
  38 # if (EF10_EVQ_MAXNBUFS < MEDFORD_EVQ_MAXNBUFS)
  39 #  error "EF10_EVQ_MAXNBUFS too small"
  40 # endif
  41 #endif /* EFSYS_OPT_MEDFORD */
  42 #if EFSYS_OPT_MEDFORD2
  43 # if (EF10_EVQ_MAXNBUFS < MEDFORD2_EVQ_MAXNBUFS)
  44 #  error "EF10_EVQ_MAXNBUFS too small"
  45 # endif
  46 #endif /* EFSYS_OPT_MEDFORD2 */
  47
  48 /* Number of hardware PIO buffers (for compile-time resource dimensions) */
  49 #define EF10_MAX_PIOBUF_NBUFS   (16)
  50
  51 #if EFSYS_OPT_HUNTINGTON
  52 # if (EF10_MAX_PIOBUF_NBUFS < HUNT_PIOBUF_NBUFS)
  53 #  error "EF10_MAX_PIOBUF_NBUFS too small"
  54 # endif
  55 #endif /* EFSYS_OPT_HUNTINGTON */
  56 #if EFSYS_OPT_MEDFORD
  57 # if (EF10_MAX_PIOBUF_NBUFS < MEDFORD_PIOBUF_NBUFS)
  58 #  error "EF10_MAX_PIOBUF_NBUFS too small"
  59 # endif
  60 #endif /* EFSYS_OPT_MEDFORD */
  61 #if EFSYS_OPT_MEDFORD2
  62 # if (EF10_MAX_PIOBUF_NBUFS < MEDFORD2_PIOBUF_NBUFS)
  63 #  error "EF10_MAX_PIOBUF_NBUFS too small"
  64 # endif
  65 #endif /* EFSYS_OPT_MEDFORD2 */
  66
  67
  68
  69 /*
  70  * FIXME: This is just a power of 2 which fits in an MCDI v1 message, and could
  71  * possibly be increased, or the write size reported by newer firmware used
  72  * instead.
  73  */
  74 #define EF10_NVRAM_CHUNK 0x80
  75
  76 /*
  77  * Alignment requirement for value written to RX WPTR: the WPTR must be aligned
  78  * to an 8 descriptor boundary.
  79  */
  80 #define EF10_RX_WPTR_ALIGN 8
  81
  82 /*
  83  * Max byte offset into the packet the TCP header must start for the hardware
  84  * to be able to parse the packet correctly.
  85  */
  86 #define EF10_TCP_HEADER_OFFSET_LIMIT    208
  87
  88 /* Invalid RSS context handle */
  89 #define EF10_RSS_CONTEXT_INVALID        (0xffffffff)
  90
  91
  92 /* EV */
  93
  94 LIBEFX_INTERNAL
  95 extern  __checkReturn   efx_rc_t
  96 ef10_ev_init(
  97         __in            efx_nic_t *enp);
  98
  99 LIBEFX_INTERNAL
 100 extern                  void
 101 ef10_ev_fini(
 102         __in            efx_nic_t *enp);
 103
 104 LIBEFX_INTERNAL
 105 extern  __checkReturn   efx_rc_t
 106 ef10_ev_qcreate(
 107         __in            efx_nic_t *enp,
 108         __in            unsigned int index,
 109         __in            efsys_mem_t *esmp,
 110         __in            size_t ndescs,
 111         __in            uint32_t id,
 112         __in            uint32_t us,
 113         __in            uint32_t flags,
 114         __in            efx_evq_t *eep);
 115
 116 LIBEFX_INTERNAL
 117 extern                  void
 118 ef10_ev_qdestroy(
 119         __in            efx_evq_t *eep);
 120
 121 LIBEFX_INTERNAL
 122 extern  __checkReturn   efx_rc_t
 123 ef10_ev_qprime(
 124         __in            efx_evq_t *eep,
 125         __in            unsigned int count);
 126
 127 LIBEFX_INTERNAL
 128 extern                  void
 129 ef10_ev_qpost(
 130         __in    efx_evq_t *eep,
 131         __in    uint16_t data);
 132
 133 LIBEFX_INTERNAL
 134 extern  __checkReturn   efx_rc_t
 135 ef10_ev_qmoderate(
 136         __in            efx_evq_t *eep,
 137         __in            unsigned int us);
 138
 139 #if EFSYS_OPT_QSTATS
 140 LIBEFX_INTERNAL
 141 extern                  void
 142 ef10_ev_qstats_update(
 143         __in                            efx_evq_t *eep,
 144         __inout_ecount(EV_NQSTATS)      efsys_stat_t *stat);
 145 #endif /* EFSYS_OPT_QSTATS */
 146
 147 LIBEFX_INTERNAL
 148 extern                  void
 149 ef10_ev_rxlabel_init(
 150         __in            efx_evq_t *eep,
 151         __in            efx_rxq_t *erp,
 152         __in            unsigned int label,
 153         __in            efx_rxq_type_t type);
 154
 155 LIBEFX_INTERNAL
 156 extern                  void
 157 ef10_ev_rxlabel_fini(
 158         __in            efx_evq_t *eep,
 159         __in            unsigned int label);
 160
 161 LIBEFX_INTERNAL
 162 extern  __checkReturn   boolean_t
 163 ef10_ev_mcdi(
 164         __in            efx_evq_t *eep,
 165         __in            efx_qword_t *eqp,
 166         __in            const efx_ev_callbacks_t *eecp,
 167         __in_opt        void *arg);
 168
 169 /* INTR */
 170
 171 LIBEFX_INTERNAL
 172 extern  __checkReturn   efx_rc_t
 173 ef10_intr_init(
 174         __in            efx_nic_t *enp,
 175         __in            efx_intr_type_t type,
 176         __in            efsys_mem_t *esmp);
 177
 178 LIBEFX_INTERNAL
 179 extern                  void
 180 ef10_intr_enable(
 181         __in            efx_nic_t *enp);
 182
 183 LIBEFX_INTERNAL
 184 extern                  void
 185 ef10_intr_disable(
 186         __in            efx_nic_t *enp);
 187
 188 LIBEFX_INTERNAL
 189 extern                  void
 190 ef10_intr_disable_unlocked(
 191         __in            efx_nic_t *enp);
 192
 193 LIBEFX_INTERNAL
 194 extern  __checkReturn   efx_rc_t
 195 ef10_intr_trigger(
 196         __in            efx_nic_t *enp,
 197         __in            unsigned int level);
 198
 199 LIBEFX_INTERNAL
 200 extern                  void
 201 ef10_intr_status_line(
 202         __in            efx_nic_t *enp,
 203         __out           boolean_t *fatalp,
 204         __out           uint32_t *qmaskp);
 205
 206 LIBEFX_INTERNAL
 207 extern                  void
 208 ef10_intr_status_message(
 209         __in            efx_nic_t *enp,
 210         __in            unsigned int message,
 211         __out           boolean_t *fatalp);
 212
 213 LIBEFX_INTERNAL
 214 extern                  void
 215 ef10_intr_fatal(
 216         __in            efx_nic_t *enp);
 217
 218 LIBEFX_INTERNAL
 219 extern                  void
 220 ef10_intr_fini(
 221         __in            efx_nic_t *enp);
 222
 223 /* NIC */
 224
 225 LIBEFX_INTERNAL
 226 extern  __checkReturn   efx_rc_t
 227 efx_mcdi_vadaptor_alloc(
 228         __in            efx_nic_t *enp,
 229         __in            uint32_t port_id);
 230
 231 LIBEFX_INTERNAL
 232 extern  __checkReturn   efx_rc_t
 233 efx_mcdi_vadaptor_free(
 234         __in            efx_nic_t *enp,
 235         __in            uint32_t port_id);
 236
 237 LIBEFX_INTERNAL
 238 extern  __checkReturn   efx_rc_t
 239 ef10_upstream_port_vadaptor_alloc(
 240         __in            efx_nic_t *enp);
 241
 242 LIBEFX_INTERNAL
 243 extern  __checkReturn   efx_rc_t
 244 ef10_nic_probe(
 245         __in            efx_nic_t *enp);
 246
 247 LIBEFX_INTERNAL
 248 extern  __checkReturn   efx_rc_t
 249 ef10_nic_set_drv_limits(
 250         __inout         efx_nic_t *enp,
 251         __in            efx_drv_limits_t *edlp);
 252
 253 LIBEFX_INTERNAL
 254 extern  __checkReturn   efx_rc_t
 255 ef10_nic_get_vi_pool(
 256         __in            efx_nic_t *enp,
 257         __out           uint32_t *vi_countp);
 258
 259 LIBEFX_INTERNAL
 260 extern  __checkReturn   efx_rc_t
 261 ef10_nic_get_bar_region(
 262         __in            efx_nic_t *enp,
 263         __in            efx_nic_region_t region,
 264         __out           uint32_t *offsetp,
 265         __out           size_t *sizep);
 266
 267 LIBEFX_INTERNAL
 268 extern  __checkReturn   efx_rc_t
 269 ef10_nic_reset(
 270         __in            efx_nic_t *enp);
 271
 272 LIBEFX_INTERNAL
 273 extern  __checkReturn   efx_rc_t
 274 ef10_nic_init(
 275         __in            efx_nic_t *enp);
 276
 277 LIBEFX_INTERNAL
 278 extern  __checkReturn   boolean_t
 279 ef10_nic_hw_unavailable(
 280         __in            efx_nic_t *enp);
 281
 282 LIBEFX_INTERNAL
 283 extern                  void
 284 ef10_nic_set_hw_unavailable(
 285         __in            efx_nic_t *enp);
 286
 287 #if EFSYS_OPT_DIAG
 288
 289 LIBEFX_INTERNAL
 290 extern  __checkReturn   efx_rc_t
 291 ef10_nic_register_test(
 292         __in            efx_nic_t *enp);
 293
 294 #endif  /* EFSYS_OPT_DIAG */
 295
 296 LIBEFX_INTERNAL
 297 extern                  void
 298 ef10_nic_fini(
 299         __in            efx_nic_t *enp);
 300
 301 LIBEFX_INTERNAL
 302 extern                  void
 303 ef10_nic_unprobe(
 304         __in            efx_nic_t *enp);
 305
 306
 307 /* MAC */
 308
 309 LIBEFX_INTERNAL
 310 extern  __checkReturn   efx_rc_t
 311 ef10_mac_poll(
 312         __in            efx_nic_t *enp,
 313         __out           efx_link_mode_t *link_modep);
 314
 315 LIBEFX_INTERNAL
 316 extern  __checkReturn   efx_rc_t
 317 ef10_mac_up(
 318         __in            efx_nic_t *enp,
 319         __out           boolean_t *mac_upp);
 320
 321 LIBEFX_INTERNAL
 322 extern  __checkReturn   efx_rc_t
 323 ef10_mac_addr_set(
 324         __in    efx_nic_t *enp);
 325
 326 LIBEFX_INTERNAL
 327 extern  __checkReturn   efx_rc_t
 328 ef10_mac_pdu_set(
 329         __in    efx_nic_t *enp);
 330
 331 LIBEFX_INTERNAL
 332 extern  __checkReturn   efx_rc_t
 333 ef10_mac_pdu_get(
 334         __in    efx_nic_t *enp,
 335         __out   size_t *pdu);
 336
 337 LIBEFX_INTERNAL
 338 extern  __checkReturn   efx_rc_t
 339 ef10_mac_reconfigure(
 340         __in    efx_nic_t *enp);
 341
 342 LIBEFX_INTERNAL
 343 extern  __checkReturn   efx_rc_t
 344 ef10_mac_multicast_list_set(
 345         __in                            efx_nic_t *enp);
 346
 347 LIBEFX_INTERNAL
 348 extern  __checkReturn   efx_rc_t
 349 ef10_mac_filter_default_rxq_set(
 350         __in            efx_nic_t *enp,
 351         __in            efx_rxq_t *erp,
 352         __in            boolean_t using_rss);
 353
 354 LIBEFX_INTERNAL
 355 extern                  void
 356 ef10_mac_filter_default_rxq_clear(
 357         __in            efx_nic_t *enp);
 358
 359 #if EFSYS_OPT_LOOPBACK
 360
 361 LIBEFX_INTERNAL
 362 extern  __checkReturn   efx_rc_t
 363 ef10_mac_loopback_set(
 364         __in            efx_nic_t *enp,
 365         __in            efx_link_mode_t link_mode,
 366         __in            efx_loopback_type_t loopback_type);
 367
 368 #endif  /* EFSYS_OPT_LOOPBACK */
 369
 370 #if EFSYS_OPT_MAC_STATS
 371
 372 LIBEFX_INTERNAL
 373 extern  __checkReturn                   efx_rc_t
 374 ef10_mac_stats_get_mask(
 375         __in                            efx_nic_t *enp,
 376         __inout_bcount(mask_size)       uint32_t *maskp,
 377         __in                            size_t mask_size);
 378
 379 LIBEFX_INTERNAL
 380 extern  __checkReturn                   efx_rc_t
 381 ef10_mac_stats_update(
 382         __in                            efx_nic_t *enp,
 383         __in                            efsys_mem_t *esmp,
 384         __inout_ecount(EFX_MAC_NSTATS)  efsys_stat_t *stat,
 385         __inout_opt                     uint32_t *generationp);
 386
 387 #endif  /* EFSYS_OPT_MAC_STATS */
 388
 389
 390 /* MCDI */
 391
 392 #if EFSYS_OPT_MCDI
 393
 394 LIBEFX_INTERNAL
 395 extern  __checkReturn   efx_rc_t
 396 ef10_mcdi_init(
 397         __in            efx_nic_t *enp,
 398         __in            const efx_mcdi_transport_t *mtp);
 399
 400 LIBEFX_INTERNAL
 401 extern                  void
 402 ef10_mcdi_fini(
 403         __in            efx_nic_t *enp);
 404
 405 LIBEFX_INTERNAL
 406 extern                  void
 407 ef10_mcdi_send_request(
 408         __in                    efx_nic_t *enp,
 409         __in_bcount(hdr_len)    void *hdrp,
 410         __in                    size_t hdr_len,
 411         __in_bcount(sdu_len)    void *sdup,
 412         __in                    size_t sdu_len);
 413
 414 LIBEFX_INTERNAL
 415 extern  __checkReturn   boolean_t
 416 ef10_mcdi_poll_response(
 417         __in            efx_nic_t *enp);
 418
 419 LIBEFX_INTERNAL
 420 extern                  void
 421 ef10_mcdi_read_response(
 422         __in                    efx_nic_t *enp,
 423         __out_bcount(length)    void *bufferp,
 424         __in                    size_t offset,
 425         __in                    size_t length);
 426
 427 LIBEFX_INTERNAL
 428 extern                  efx_rc_t
 429 ef10_mcdi_poll_reboot(
 430         __in            efx_nic_t *enp);
 431
 432 LIBEFX_INTERNAL
 433 extern  __checkReturn   efx_rc_t
 434 ef10_mcdi_feature_supported(
 435         __in            efx_nic_t *enp,
 436         __in            efx_mcdi_feature_id_t id,
 437         __out           boolean_t *supportedp);
 438
 439 LIBEFX_INTERNAL
 440 extern                  void
 441 ef10_mcdi_get_timeout(
 442         __in            efx_nic_t *enp,
 443         __in            efx_mcdi_req_t *emrp,
 444         __out           uint32_t *timeoutp);
 445
 446 #endif /* EFSYS_OPT_MCDI */
 447
 448 /* NVRAM */
 449
 450 #if EFSYS_OPT_NVRAM || EFSYS_OPT_VPD
 451
 452 LIBEFX_INTERNAL
 453 extern  __checkReturn           efx_rc_t
 454 ef10_nvram_buf_read_tlv(
 455         __in                            efx_nic_t *enp,
 456         __in_bcount(max_seg_size)       caddr_t seg_data,
 457         __in                            size_t max_seg_size,
 458         __in                            uint32_t tag,
 459         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
 460         __out                           size_t *sizep);
 461
 462 LIBEFX_INTERNAL
 463 extern  __checkReturn           efx_rc_t
 464 ef10_nvram_buf_write_tlv(
 465         __inout_bcount(partn_size)      caddr_t partn_data,
 466         __in                            size_t partn_size,
 467         __in                            uint32_t tag,
 468         __in_bcount(tag_size)           caddr_t tag_data,
 469         __in                            size_t tag_size,
 470         __out                           size_t *total_lengthp);
 471
 472 LIBEFX_INTERNAL
 473 extern  __checkReturn           efx_rc_t
 474 ef10_nvram_partn_read_tlv(
 475         __in                            efx_nic_t *enp,
 476         __in                            uint32_t partn,
 477         __in                            uint32_t tag,
 478         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
 479         __out                           size_t *sizep);
 480
 481 LIBEFX_INTERNAL
 482 extern  __checkReturn           efx_rc_t
 483 ef10_nvram_partn_write_tlv(
 484         __in                    efx_nic_t *enp,
 485         __in                    uint32_t partn,
 486         __in                    uint32_t tag,
 487         __in_bcount(size)       caddr_t data,
 488         __in                    size_t size);
 489
 490 LIBEFX_INTERNAL
 491 extern  __checkReturn           efx_rc_t
 492 ef10_nvram_partn_write_segment_tlv(
 493         __in                    efx_nic_t *enp,
 494         __in                    uint32_t partn,
 495         __in                    uint32_t tag,
 496         __in_bcount(size)       caddr_t data,
 497         __in                    size_t size,
 498         __in                    boolean_t all_segments);
 499
 500 LIBEFX_INTERNAL
 501 extern  __checkReturn           efx_rc_t
 502 ef10_nvram_partn_lock(
 503         __in                    efx_nic_t *enp,
 504         __in                    uint32_t partn);
 505
 506 LIBEFX_INTERNAL
 507 extern  __checkReturn           efx_rc_t
 508 ef10_nvram_partn_unlock(
 509         __in                    efx_nic_t *enp,
 510         __in                    uint32_t partn,
 511         __out_opt               uint32_t *resultp);
 512
 513 #endif /* EFSYS_OPT_NVRAM || EFSYS_OPT_VPD */
 514
 515 #if EFSYS_OPT_NVRAM
 516
 517 #if EFSYS_OPT_DIAG
 518
 519 LIBEFX_INTERNAL
 520 extern  __checkReturn           efx_rc_t
 521 ef10_nvram_test(
 522         __in                    efx_nic_t *enp);
 523
 524 #endif  /* EFSYS_OPT_DIAG */
 525
 526 LIBEFX_INTERNAL
 527 extern  __checkReturn           efx_rc_t
 528 ef10_nvram_type_to_partn(
 529         __in                    efx_nic_t *enp,
 530         __in                    efx_nvram_type_t type,
 531         __out                   uint32_t *partnp);
 532
 533 LIBEFX_INTERNAL
 534 extern  __checkReturn           efx_rc_t
 535 ef10_nvram_partn_size(
 536         __in                    efx_nic_t *enp,
 537         __in                    uint32_t partn,
 538         __out                   size_t *sizep);
 539
 540 LIBEFX_INTERNAL
 541 extern  __checkReturn           efx_rc_t
 542 ef10_nvram_partn_info(
 543         __in                    efx_nic_t *enp,
 544         __in                    uint32_t partn,
 545         __out                   efx_nvram_info_t * enip);
 546
 547 LIBEFX_INTERNAL
 548 extern  __checkReturn           efx_rc_t
 549 ef10_nvram_partn_rw_start(
 550         __in                    efx_nic_t *enp,
 551         __in                    uint32_t partn,
 552         __out                   size_t *chunk_sizep);
 553
 554 LIBEFX_INTERNAL
 555 extern  __checkReturn           efx_rc_t
 556 ef10_nvram_partn_read_mode(
 557         __in                    efx_nic_t *enp,
 558         __in                    uint32_t partn,
 559         __in                    unsigned int offset,
 560         __out_bcount(size)      caddr_t data,
 561         __in                    size_t size,
 562         __in                    uint32_t mode);
 563
 564 LIBEFX_INTERNAL
 565 extern  __checkReturn           efx_rc_t
 566 ef10_nvram_partn_read(
 567         __in                    efx_nic_t *enp,
 568         __in                    uint32_t partn,
 569         __in                    unsigned int offset,
 570         __out_bcount(size)      caddr_t data,
 571         __in                    size_t size);
 572
 573 LIBEFX_INTERNAL
 574 extern  __checkReturn           efx_rc_t
 575 ef10_nvram_partn_read_backup(
 576         __in                    efx_nic_t *enp,
 577         __in                    uint32_t partn,
 578         __in                    unsigned int offset,
 579         __out_bcount(size)      caddr_t data,
 580         __in                    size_t size);
 581
 582 LIBEFX_INTERNAL
 583 extern  __checkReturn           efx_rc_t
 584 ef10_nvram_partn_erase(
 585         __in                    efx_nic_t *enp,
 586         __in                    uint32_t partn,
 587         __in                    unsigned int offset,
 588         __in                    size_t size);
 589
 590 LIBEFX_INTERNAL
 591 extern  __checkReturn           efx_rc_t
 592 ef10_nvram_partn_write(
 593         __in                    efx_nic_t *enp,
 594         __in                    uint32_t partn,
 595         __in                    unsigned int offset,
 596         __in_bcount(size)       caddr_t data,
 597         __in                    size_t size);
 598
 599 LIBEFX_INTERNAL
 600 extern  __checkReturn           efx_rc_t
 601 ef10_nvram_partn_rw_finish(
 602         __in                    efx_nic_t *enp,
 603         __in                    uint32_t partn,
 604         __out_opt               uint32_t *verify_resultp);
 605
 606 LIBEFX_INTERNAL
 607 extern  __checkReturn           efx_rc_t
 608 ef10_nvram_partn_get_version(
 609         __in                    efx_nic_t *enp,
 610         __in                    uint32_t partn,
 611         __out                   uint32_t *subtypep,
 612         __out_ecount(4)         uint16_t version[4]);
 613
 614 LIBEFX_INTERNAL
 615 extern  __checkReturn           efx_rc_t
 616 ef10_nvram_partn_set_version(
 617         __in                    efx_nic_t *enp,
 618         __in                    uint32_t partn,
 619         __in_ecount(4)          uint16_t version[4]);
 620
 621 LIBEFX_INTERNAL
 622 extern  __checkReturn           efx_rc_t
 623 ef10_nvram_buffer_validate(
 624         __in                    uint32_t partn,
 625         __in_bcount(buffer_size)
 626                                 caddr_t bufferp,
 627         __in                    size_t buffer_size);
 628
 629 LIBEFX_INTERNAL
 630 extern                  void
 631 ef10_nvram_buffer_init(
 632         __out_bcount(buffer_size)
 633                                 caddr_t bufferp,
 634         __in                    size_t buffer_size);
 635
 636 LIBEFX_INTERNAL
 637 extern  __checkReturn           efx_rc_t
 638 ef10_nvram_buffer_create(
 639         __in                    uint32_t partn_type,
 640         __out_bcount(buffer_size)
 641                                 caddr_t bufferp,
 642         __in                    size_t buffer_size);
 643
 644 LIBEFX_INTERNAL
 645 extern  __checkReturn           efx_rc_t
 646 ef10_nvram_buffer_find_item_start(
 647         __in_bcount(buffer_size)
 648                                 caddr_t bufferp,
 649         __in                    size_t buffer_size,
 650         __out                   uint32_t *startp);
 651
 652 LIBEFX_INTERNAL
 653 extern  __checkReturn           efx_rc_t
 654 ef10_nvram_buffer_find_end(
 655         __in_bcount(buffer_size)
 656                                 caddr_t bufferp,
 657         __in                    size_t buffer_size,
 658         __in                    uint32_t offset,
 659         __out                   uint32_t *endp);
 660
 661 LIBEFX_INTERNAL
 662 extern  __checkReturn   __success(return != B_FALSE)    boolean_t
 663 ef10_nvram_buffer_find_item(
 664         __in_bcount(buffer_size)
 665                                 caddr_t bufferp,
 666         __in                    size_t buffer_size,
 667         __in                    uint32_t offset,
 668         __out                   uint32_t *startp,
 669         __out                   uint32_t *lengthp);
 670
 671 LIBEFX_INTERNAL
 672 extern  __checkReturn           efx_rc_t
 673 ef10_nvram_buffer_peek_item(
 674         __in_bcount(buffer_size)
 675                                 caddr_t bufferp,
 676         __in                    size_t buffer_size,
 677         __in                    uint32_t offset,
 678         __out                   uint32_t *tagp,
 679         __out                   uint32_t *lengthp,
 680         __out                   uint32_t *value_offsetp);
 681
 682 LIBEFX_INTERNAL
 683 extern  __checkReturn           efx_rc_t
 684 ef10_nvram_buffer_get_item(
 685         __in_bcount(buffer_size)
 686                                 caddr_t bufferp,
 687         __in                    size_t buffer_size,
 688         __in                    uint32_t offset,
 689         __in                    uint32_t length,
 690         __out                   uint32_t *tagp,
 691         __out_bcount_part(value_max_size, *lengthp)
 692                                 caddr_t valuep,
 693         __in                    size_t value_max_size,
 694         __out                   uint32_t *lengthp);
 695
 696 LIBEFX_INTERNAL
 697 extern  __checkReturn           efx_rc_t
 698 ef10_nvram_buffer_insert_item(
 699         __in_bcount(buffer_size)
 700                                 caddr_t bufferp,
 701         __in                    size_t buffer_size,
 702         __in                    uint32_t offset,
 703         __in                    uint32_t tag,
 704         __in_bcount(length)     caddr_t valuep,
 705         __in                    uint32_t length,
 706         __out                   uint32_t *lengthp);
 707
 708 LIBEFX_INTERNAL
 709 extern  __checkReturn           efx_rc_t
 710 ef10_nvram_buffer_modify_item(
 711         __in_bcount(buffer_size)
 712                                 caddr_t bufferp,
 713         __in                    size_t buffer_size,
 714         __in                    uint32_t offset,
 715         __in                    uint32_t tag,
 716         __in_bcount(length)     caddr_t valuep,
 717         __in                    uint32_t length,
 718         __out                   uint32_t *lengthp);
 719
 720 LIBEFX_INTERNAL
 721 extern  __checkReturn           efx_rc_t
 722 ef10_nvram_buffer_delete_item(
 723         __in_bcount(buffer_size)
 724                                 caddr_t bufferp,
 725         __in                    size_t buffer_size,
 726         __in                    uint32_t offset,
 727         __in                    uint32_t length,
 728         __in                    uint32_t end);
 729
 730 LIBEFX_INTERNAL
 731 extern  __checkReturn           efx_rc_t
 732 ef10_nvram_buffer_finish(
 733         __in_bcount(buffer_size)
 734                                 caddr_t bufferp,
 735         __in                    size_t buffer_size);
 736
 737 #endif  /* EFSYS_OPT_NVRAM */
 738
 739
 740 /* PHY */
 741
 742 typedef struct ef10_link_state_s {
 743         efx_phy_link_state_t    epls;
 744 #if EFSYS_OPT_LOOPBACK
 745         efx_loopback_type_t     els_loopback;
 746 #endif
 747         boolean_t               els_mac_up;
 748 } ef10_link_state_t;
 749
 750 LIBEFX_INTERNAL
 751 extern                  void
 752 ef10_phy_link_ev(
 753         __in            efx_nic_t *enp,
 754         __in            efx_qword_t *eqp,
 755         __out           efx_link_mode_t *link_modep);
 756
 757 LIBEFX_INTERNAL
 758 extern  __checkReturn   efx_rc_t
 759 ef10_phy_get_link(
 760         __in            efx_nic_t *enp,
 761         __out           ef10_link_state_t *elsp);
 762
 763 LIBEFX_INTERNAL
 764 extern  __checkReturn   efx_rc_t
 765 ef10_phy_power(
 766         __in            efx_nic_t *enp,
 767         __in            boolean_t on);
 768
 769 LIBEFX_INTERNAL
 770 extern  __checkReturn   efx_rc_t
 771 ef10_phy_reconfigure(
 772         __in            efx_nic_t *enp);
 773
 774 LIBEFX_INTERNAL
 775 extern  __checkReturn   efx_rc_t
 776 ef10_phy_verify(
 777         __in            efx_nic_t *enp);
 778
 779 LIBEFX_INTERNAL
 780 extern  __checkReturn   efx_rc_t
 781 ef10_phy_oui_get(
 782         __in            efx_nic_t *enp,
 783         __out           uint32_t *ouip);
 784
 785 LIBEFX_INTERNAL
 786 extern  __checkReturn   efx_rc_t
 787 ef10_phy_link_state_get(
 788         __in            efx_nic_t *enp,
 789         __out           efx_phy_link_state_t *eplsp);
 790
 791 #if EFSYS_OPT_PHY_STATS
 792
 793 LIBEFX_INTERNAL
 794 extern  __checkReturn                   efx_rc_t
 795 ef10_phy_stats_update(
 796         __in                            efx_nic_t *enp,
 797         __in                            efsys_mem_t *esmp,
 798         __inout_ecount(EFX_PHY_NSTATS)  uint32_t *stat);
 799
 800 #endif  /* EFSYS_OPT_PHY_STATS */
 801
 802 #if EFSYS_OPT_BIST
 803
 804 LIBEFX_INTERNAL
 805 extern  __checkReturn           efx_rc_t
 806 ef10_bist_enable_offline(
 807         __in                    efx_nic_t *enp);
 808
 809 LIBEFX_INTERNAL
 810 extern  __checkReturn           efx_rc_t
 811 ef10_bist_start(
 812         __in                    efx_nic_t *enp,
 813         __in                    efx_bist_type_t type);
 814
 815 LIBEFX_INTERNAL
 816 extern  __checkReturn           efx_rc_t
 817 ef10_bist_poll(
 818         __in                    efx_nic_t *enp,
 819         __in                    efx_bist_type_t type,
 820         __out                   efx_bist_result_t *resultp,
 821         __out_opt __drv_when(count > 0, __notnull)
 822         uint32_t        *value_maskp,
 823         __out_ecount_opt(count) __drv_when(count > 0, __notnull)
 824         unsigned long   *valuesp,
 825         __in                    size_t count);
 826
 827 LIBEFX_INTERNAL
 828 extern                          void
 829 ef10_bist_stop(
 830         __in                    efx_nic_t *enp,
 831         __in                    efx_bist_type_t type);
 832
 833 #endif  /* EFSYS_OPT_BIST */
 834
 835 /* TX */
 836
 837 LIBEFX_INTERNAL
 838 extern  __checkReturn   efx_rc_t
 839 ef10_tx_init(
 840         __in            efx_nic_t *enp);
 841
 842 LIBEFX_INTERNAL
 843 extern                  void
 844 ef10_tx_fini(
 845         __in            efx_nic_t *enp);
 846
 847 LIBEFX_INTERNAL
 848 extern  __checkReturn   efx_rc_t
 849 ef10_tx_qcreate(
 850         __in            efx_nic_t *enp,
 851         __in            unsigned int index,
 852         __in            unsigned int label,
 853         __in            efsys_mem_t *esmp,
 854         __in            size_t ndescs,
 855         __in            uint32_t id,
 856         __in            uint16_t flags,
 857         __in            efx_evq_t *eep,
 858         __in            efx_txq_t *etp,
 859         __out           unsigned int *addedp);
 860
 861 LIBEFX_INTERNAL
 862 extern          void
 863 ef10_tx_qdestroy(
 864         __in            efx_txq_t *etp);
 865
 866 LIBEFX_INTERNAL
 867 extern  __checkReturn           efx_rc_t
 868 ef10_tx_qpost(
 869         __in                    efx_txq_t *etp,
 870         __in_ecount(ndescs)     efx_buffer_t *ebp,
 871         __in                    unsigned int ndescs,
 872         __in                    unsigned int completed,
 873         __inout                 unsigned int *addedp);
 874
 875 LIBEFX_INTERNAL
 876 extern                  void
 877 ef10_tx_qpush(
 878         __in            efx_txq_t *etp,
 879         __in            unsigned int added,
 880         __in            unsigned int pushed);
 881
 882 #if EFSYS_OPT_RX_PACKED_STREAM
 883 LIBEFX_INTERNAL
 884 extern                  void
 885 ef10_rx_qpush_ps_credits(
 886         __in            efx_rxq_t *erp);
 887
 888 LIBEFX_INTERNAL
 889 extern  __checkReturn   uint8_t *
 890 ef10_rx_qps_packet_info(
 891         __in            efx_rxq_t *erp,
 892         __in            uint8_t *buffer,
 893         __in            uint32_t buffer_length,
 894         __in            uint32_t current_offset,
 895         __out           uint16_t *lengthp,
 896         __out           uint32_t *next_offsetp,
 897         __out           uint32_t *timestamp);
 898 #endif
 899
 900 LIBEFX_INTERNAL
 901 extern  __checkReturn   efx_rc_t
 902 ef10_tx_qpace(
 903         __in            efx_txq_t *etp,
 904         __in            unsigned int ns);
 905
 906 LIBEFX_INTERNAL
 907 extern  __checkReturn   efx_rc_t
 908 ef10_tx_qflush(
 909         __in            efx_txq_t *etp);
 910
 911 LIBEFX_INTERNAL
 912 extern                  void
 913 ef10_tx_qenable(
 914         __in            efx_txq_t *etp);
 915
 916 LIBEFX_INTERNAL
 917 extern  __checkReturn   efx_rc_t
 918 ef10_tx_qpio_enable(
 919         __in            efx_txq_t *etp);
 920
 921 LIBEFX_INTERNAL
 922 extern                  void
 923 ef10_tx_qpio_disable(
 924         __in            efx_txq_t *etp);
 925
 926 LIBEFX_INTERNAL
 927 extern  __checkReturn   efx_rc_t
 928 ef10_tx_qpio_write(
 929         __in                    efx_txq_t *etp,
 930         __in_ecount(buf_length) uint8_t *buffer,
 931         __in                    size_t buf_length,
 932         __in                    size_t pio_buf_offset);
 933
 934 LIBEFX_INTERNAL
 935 extern  __checkReturn   efx_rc_t
 936 ef10_tx_qpio_post(
 937         __in                    efx_txq_t *etp,
 938         __in                    size_t pkt_length,
 939         __in                    unsigned int completed,
 940         __inout                 unsigned int *addedp);
 941
 942 LIBEFX_INTERNAL
 943 extern  __checkReturn   efx_rc_t
 944 ef10_tx_qdesc_post(
 945         __in            efx_txq_t *etp,
 946         __in_ecount(n)  efx_desc_t *ed,
 947         __in            unsigned int n,
 948         __in            unsigned int completed,
 949         __inout         unsigned int *addedp);
 950
 951 LIBEFX_INTERNAL
 952 extern  void
 953 ef10_tx_qdesc_dma_create(
 954         __in    efx_txq_t *etp,
 955         __in    efsys_dma_addr_t addr,
 956         __in    size_t size,
 957         __in    boolean_t eop,
 958         __out   efx_desc_t *edp);
 959
 960 LIBEFX_INTERNAL
 961 extern  void
 962 ef10_tx_qdesc_tso_create(
 963         __in    efx_txq_t *etp,
 964         __in    uint16_t ipv4_id,
 965         __in    uint32_t tcp_seq,
 966         __in    uint8_t  tcp_flags,
 967         __out   efx_desc_t *edp);
 968
 969 LIBEFX_INTERNAL
 970 extern  void
 971 ef10_tx_qdesc_tso2_create(
 972         __in                    efx_txq_t *etp,
 973         __in                    uint16_t ipv4_id,
 974         __in                    uint16_t outer_ipv4_id,
 975         __in                    uint32_t tcp_seq,
 976         __in                    uint16_t tcp_mss,
 977         __out_ecount(count)     efx_desc_t *edp,
 978         __in                    int count);
 979
 980 LIBEFX_INTERNAL
 981 extern  void
 982 ef10_tx_qdesc_vlantci_create(
 983         __in    efx_txq_t *etp,
 984         __in    uint16_t vlan_tci,
 985         __out   efx_desc_t *edp);
 986
 987 LIBEFX_INTERNAL
 988 extern  void
 989 ef10_tx_qdesc_checksum_create(
 990         __in    efx_txq_t *etp,
 991         __in    uint16_t flags,
 992         __out   efx_desc_t *edp);
 993
 994 #if EFSYS_OPT_QSTATS
 995
 996 LIBEFX_INTERNAL
 997 extern                  void
 998 ef10_tx_qstats_update(
 999         __in                            efx_txq_t *etp,
1000         __inout_ecount(TX_NQSTATS)      efsys_stat_t *stat);
1001
1002 #endif /* EFSYS_OPT_QSTATS */
1003
1004 typedef uint32_t        efx_piobuf_handle_t;
1005
1006 #define EFX_PIOBUF_HANDLE_INVALID       ((efx_piobuf_handle_t)-1)
1007
1008 LIBEFX_INTERNAL
1009 extern  __checkReturn   efx_rc_t
1010 ef10_nic_pio_alloc(
1011         __inout         efx_nic_t *enp,
1012         __out           uint32_t *bufnump,
1013         __out           efx_piobuf_handle_t *handlep,
1014         __out           uint32_t *blknump,
1015         __out           uint32_t *offsetp,
1016         __out           size_t *sizep);
1017
1018 LIBEFX_INTERNAL
1019 extern  __checkReturn   efx_rc_t
1020 ef10_nic_pio_free(
1021         __inout         efx_nic_t *enp,
1022         __in            uint32_t bufnum,
1023         __in            uint32_t blknum);
1024
1025 LIBEFX_INTERNAL
1026 extern  __checkReturn   efx_rc_t
1027 ef10_nic_pio_link(
1028         __inout         efx_nic_t *enp,
1029         __in            uint32_t vi_index,
1030         __in            efx_piobuf_handle_t handle);
1031
1032 LIBEFX_INTERNAL
1033 extern  __checkReturn   efx_rc_t
1034 ef10_nic_pio_unlink(
1035         __inout         efx_nic_t *enp,
1036         __in            uint32_t vi_index);
1037
1038
1039 /* VPD */
1040
1041 #if EFSYS_OPT_VPD
1042
1043 LIBEFX_INTERNAL
1044 extern  __checkReturn           efx_rc_t
1045 ef10_vpd_init(
1046         __in                    efx_nic_t *enp);
1047
1048 LIBEFX_INTERNAL
1049 extern  __checkReturn           efx_rc_t
1050 ef10_vpd_size(
1051         __in                    efx_nic_t *enp,
1052         __out                   size_t *sizep);
1053
1054 LIBEFX_INTERNAL
1055 extern  __checkReturn           efx_rc_t
1056 ef10_vpd_read(
1057         __in                    efx_nic_t *enp,
1058         __out_bcount(size)      caddr_t data,
1059         __in                    size_t size);
1060
1061 LIBEFX_INTERNAL
1062 extern  __checkReturn           efx_rc_t
1063 ef10_vpd_verify(
1064         __in                    efx_nic_t *enp,
1065         __in_bcount(size)       caddr_t data,
1066         __in                    size_t size);
1067
1068 LIBEFX_INTERNAL
1069 extern  __checkReturn           efx_rc_t
1070 ef10_vpd_reinit(
1071         __in                    efx_nic_t *enp,
1072         __in_bcount(size)       caddr_t data,
1073         __in                    size_t size);
1074
1075 LIBEFX_INTERNAL
1076 extern  __checkReturn           efx_rc_t
1077 ef10_vpd_get(
1078         __in                    efx_nic_t *enp,
1079         __in_bcount(size)       caddr_t data,
1080         __in                    size_t size,
1081         __inout                 efx_vpd_value_t *evvp);
1082
1083 LIBEFX_INTERNAL
1084 extern  __checkReturn           efx_rc_t
1085 ef10_vpd_set(
1086         __in                    efx_nic_t *enp,
1087         __in_bcount(size)       caddr_t data,
1088         __in                    size_t size,
1089         __in                    efx_vpd_value_t *evvp);
1090
1091 LIBEFX_INTERNAL
1092 extern  __checkReturn           efx_rc_t
1093 ef10_vpd_next(
1094         __in                    efx_nic_t *enp,
1095         __in_bcount(size)       caddr_t data,
1096         __in                    size_t size,
1097         __out                   efx_vpd_value_t *evvp,
1098         __inout                 unsigned int *contp);
1099
1100 LIBEFX_INTERNAL
1101 extern __checkReturn            efx_rc_t
1102 ef10_vpd_write(
1103         __in                    efx_nic_t *enp,
1104         __in_bcount(size)       caddr_t data,
1105         __in                    size_t size);
1106
1107 LIBEFX_INTERNAL
1108 extern                          void
1109 ef10_vpd_fini(
1110         __in                    efx_nic_t *enp);
1111
1112 #endif  /* EFSYS_OPT_VPD */
1113
1114
1115 /* RX */
1116
1117 LIBEFX_INTERNAL
1118 extern  __checkReturn   efx_rc_t
1119 ef10_rx_init(
1120         __in            efx_nic_t *enp);
1121
1122 #if EFSYS_OPT_RX_SCATTER
1123 LIBEFX_INTERNAL
1124 extern  __checkReturn   efx_rc_t
1125 ef10_rx_scatter_enable(
1126         __in            efx_nic_t *enp,
1127         __in            unsigned int buf_size);
1128 #endif  /* EFSYS_OPT_RX_SCATTER */
1129
1130
1131 #if EFSYS_OPT_RX_SCALE
1132
1133 LIBEFX_INTERNAL
1134 extern  __checkReturn   efx_rc_t
1135 ef10_rx_scale_context_alloc(
1136         __in            efx_nic_t *enp,
1137         __in            efx_rx_scale_context_type_t type,
1138         __in            uint32_t num_queues,
1139         __out           uint32_t *rss_contextp);
1140
1141 LIBEFX_INTERNAL
1142 extern  __checkReturn   efx_rc_t
1143 ef10_rx_scale_context_free(
1144         __in            efx_nic_t *enp,
1145         __in            uint32_t rss_context);
1146
1147 LIBEFX_INTERNAL
1148 extern  __checkReturn   efx_rc_t
1149 ef10_rx_scale_mode_set(
1150         __in            efx_nic_t *enp,
1151         __in            uint32_t rss_context,
1152         __in            efx_rx_hash_alg_t alg,
1153         __in            efx_rx_hash_type_t type,
1154         __in            boolean_t insert);
1155
1156 LIBEFX_INTERNAL
1157 extern  __checkReturn   efx_rc_t
1158 ef10_rx_scale_key_set(
1159         __in            efx_nic_t *enp,
1160         __in            uint32_t rss_context,
1161         __in_ecount(n)  uint8_t *key,
1162         __in            size_t n);
1163
1164 LIBEFX_INTERNAL
1165 extern  __checkReturn   efx_rc_t
1166 ef10_rx_scale_tbl_set(
1167         __in            efx_nic_t *enp,
1168         __in            uint32_t rss_context,
1169         __in_ecount(n)  unsigned int *table,
1170         __in            size_t n);
1171
1172 LIBEFX_INTERNAL
1173 extern  __checkReturn   uint32_t
1174 ef10_rx_prefix_hash(
1175         __in            efx_nic_t *enp,
1176         __in            efx_rx_hash_alg_t func,
1177         __in            uint8_t *buffer);
1178
1179 #endif /* EFSYS_OPT_RX_SCALE */
1180
1181 LIBEFX_INTERNAL
1182 extern  __checkReturn   efx_rc_t
1183 ef10_rx_prefix_pktlen(
1184         __in            efx_nic_t *enp,
1185         __in            uint8_t *buffer,
1186         __out           uint16_t *lengthp);
1187
1188 LIBEFX_INTERNAL
1189 extern                          void
1190 ef10_rx_qpost(
1191         __in                    efx_rxq_t *erp,
1192         __in_ecount(ndescs)     efsys_dma_addr_t *addrp,
1193         __in                    size_t size,
1194         __in                    unsigned int ndescs,
1195         __in                    unsigned int completed,
1196         __in                    unsigned int added);
1197
1198 LIBEFX_INTERNAL
1199 extern                  void
1200 ef10_rx_qpush(
1201         __in            efx_rxq_t *erp,
1202         __in            unsigned int added,
1203         __inout         unsigned int *pushedp);
1204
1205 LIBEFX_INTERNAL
1206 extern  __checkReturn   efx_rc_t
1207 ef10_rx_qflush(
1208         __in            efx_rxq_t *erp);
1209
1210 LIBEFX_INTERNAL
1211 extern          void
1212 ef10_rx_qenable(
1213         __in            efx_rxq_t *erp);
1214
1215 union efx_rxq_type_data_u;
1216
1217 LIBEFX_INTERNAL
1218 extern  __checkReturn   efx_rc_t
1219 ef10_rx_qcreate(
1220         __in            efx_nic_t *enp,
1221         __in            unsigned int index,
1222         __in            unsigned int label,
1223         __in            efx_rxq_type_t type,
1224         __in_opt        const union efx_rxq_type_data_u *type_data,
1225         __in            efsys_mem_t *esmp,
1226         __in            size_t ndescs,
1227         __in            uint32_t id,
1228         __in            unsigned int flags,
1229         __in            efx_evq_t *eep,
1230         __in            efx_rxq_t *erp);
1231
1232 LIBEFX_INTERNAL
1233 extern                  void
1234 ef10_rx_qdestroy(
1235         __in            efx_rxq_t *erp);
1236
1237 LIBEFX_INTERNAL
1238 extern                  void
1239 ef10_rx_fini(
1240         __in            efx_nic_t *enp);
1241
1242 #if EFSYS_OPT_FILTER
1243
1244 enum efx_filter_replacement_policy_e;
1245
1246 typedef struct ef10_filter_handle_s {
1247         uint32_t        efh_lo;
1248         uint32_t        efh_hi;
1249 } ef10_filter_handle_t;
1250
1251 typedef struct ef10_filter_entry_s {
1252         uintptr_t efe_spec; /* pointer to filter spec plus busy bit */
1253         ef10_filter_handle_t efe_handle;
1254 } ef10_filter_entry_t;
1255
1256 /*
1257  * BUSY flag indicates that an update is in progress.
1258  * AUTO_OLD flag is used to mark and sweep MAC packet filters.
1259  */
1260 #define EFX_EF10_FILTER_FLAG_BUSY       1U
1261 #define EFX_EF10_FILTER_FLAG_AUTO_OLD   2U
1262 #define EFX_EF10_FILTER_FLAGS           3U
1263
1264 /*
1265  * Size of the hash table used by the driver. Doesn't need to be the
1266  * same size as the hardware's table.
1267  */
1268 #define EFX_EF10_FILTER_TBL_ROWS 8192
1269
1270 /* Only need to allow for one directed and one unknown unicast filter */
1271 #define EFX_EF10_FILTER_UNICAST_FILTERS_MAX     2
1272
1273 /* Allow for the broadcast address to be added to the multicast list */
1274 #define EFX_EF10_FILTER_MULTICAST_FILTERS_MAX   (EFX_MAC_MULTICAST_LIST_MAX + 1)
1275
1276 /*
1277  * For encapsulated packets, there is one filter each for each combination of
1278  * IPv4 or IPv6 outer frame, VXLAN, GENEVE or NVGRE packet type, and unicast or
1279  * multicast inner frames.
1280  */
1281 #define EFX_EF10_FILTER_ENCAP_FILTERS_MAX       12
1282
1283 typedef struct ef10_filter_table_s {
1284         ef10_filter_entry_t     eft_entry[EFX_EF10_FILTER_TBL_ROWS];
1285         efx_rxq_t               *eft_default_rxq;
1286         boolean_t               eft_using_rss;
1287         uint32_t                eft_unicst_filter_indexes[
1288             EFX_EF10_FILTER_UNICAST_FILTERS_MAX];
1289         uint32_t                eft_unicst_filter_count;
1290         uint32_t                eft_mulcst_filter_indexes[
1291             EFX_EF10_FILTER_MULTICAST_FILTERS_MAX];
1292         uint32_t                eft_mulcst_filter_count;
1293         boolean_t               eft_using_all_mulcst;
1294         uint32_t                eft_encap_filter_indexes[
1295             EFX_EF10_FILTER_ENCAP_FILTERS_MAX];
1296         uint32_t                eft_encap_filter_count;
1297 } ef10_filter_table_t;
1298
1299 LIBEFX_INTERNAL
1300 extern  __checkReturn   efx_rc_t
1301 ef10_filter_init(
1302         __in            efx_nic_t *enp);
1303
1304 LIBEFX_INTERNAL
1305 extern                  void
1306 ef10_filter_fini(
1307         __in            efx_nic_t *enp);
1308
1309 LIBEFX_INTERNAL
1310 extern  __checkReturn   efx_rc_t
1311 ef10_filter_restore(
1312         __in            efx_nic_t *enp);
1313
1314 LIBEFX_INTERNAL
1315 extern  __checkReturn   efx_rc_t
1316 ef10_filter_add(
1317         __in            efx_nic_t *enp,
1318         __inout         efx_filter_spec_t *spec,
1319         __in            enum efx_filter_replacement_policy_e policy);
1320
1321 LIBEFX_INTERNAL
1322 extern  __checkReturn   efx_rc_t
1323 ef10_filter_delete(
1324         __in            efx_nic_t *enp,
1325         __inout         efx_filter_spec_t *spec);
1326
1327 LIBEFX_INTERNAL
1328 extern  __checkReturn   efx_rc_t
1329 ef10_filter_supported_filters(
1330         __in                            efx_nic_t *enp,
1331         __out_ecount(buffer_length)     uint32_t *buffer,
1332         __in                            size_t buffer_length,
1333         __out                           size_t *list_lengthp);
1334
1335 LIBEFX_INTERNAL
1336 extern  __checkReturn   efx_rc_t
1337 ef10_filter_reconfigure(
1338         __in                            efx_nic_t *enp,
1339         __in_ecount(6)                  uint8_t const *mac_addr,
1340         __in                            boolean_t all_unicst,
1341         __in                            boolean_t mulcst,
1342         __in                            boolean_t all_mulcst,
1343         __in                            boolean_t brdcst,
1344         __in_ecount(6*count)            uint8_t const *addrs,
1345         __in                            uint32_t count);
1346
1347 LIBEFX_INTERNAL
1348 extern          void
1349 ef10_filter_get_default_rxq(
1350         __in            efx_nic_t *enp,
1351         __out           efx_rxq_t **erpp,
1352         __out           boolean_t *using_rss);
1353
1354 LIBEFX_INTERNAL
1355 extern          void
1356 ef10_filter_default_rxq_set(
1357         __in            efx_nic_t *enp,
1358         __in            efx_rxq_t *erp,
1359         __in            boolean_t using_rss);
1360
1361 LIBEFX_INTERNAL
1362 extern          void
1363 ef10_filter_default_rxq_clear(
1364         __in            efx_nic_t *enp);
1365
1366
1367 #endif /* EFSYS_OPT_FILTER */
1368
1369 LIBEFX_INTERNAL
1370 extern  __checkReturn                   efx_rc_t
1371 efx_mcdi_get_function_info(
1372         __in                            efx_nic_t *enp,
1373         __out                           uint32_t *pfp,
1374         __out_opt                       uint32_t *vfp);
1375
1376 LIBEFX_INTERNAL
1377 extern  __checkReturn           efx_rc_t
1378 efx_mcdi_privilege_mask(
1379         __in                    efx_nic_t *enp,
1380         __in                    uint32_t pf,
1381         __in                    uint32_t vf,
1382         __out                   uint32_t *maskp);
1383
1384 LIBEFX_INTERNAL
1385 extern  __checkReturn   efx_rc_t
1386 efx_mcdi_get_port_assignment(
1387         __in            efx_nic_t *enp,
1388         __out           uint32_t *portp);
1389
1390 LIBEFX_INTERNAL
1391 extern  __checkReturn   efx_rc_t
1392 efx_mcdi_get_port_modes(
1393         __in            efx_nic_t *enp,
1394         __out           uint32_t *modesp,
1395         __out_opt       uint32_t *current_modep,
1396         __out_opt       uint32_t *default_modep);
1397
1398 LIBEFX_INTERNAL
1399 extern  __checkReturn   efx_rc_t
1400 ef10_nic_get_port_mode_bandwidth(
1401         __in            efx_nic_t *enp,
1402         __out           uint32_t *bandwidth_mbpsp);
1403
1404 LIBEFX_INTERNAL
1405 extern  __checkReturn   efx_rc_t
1406 efx_mcdi_get_mac_address_pf(
1407         __in                    efx_nic_t *enp,
1408         __out_ecount_opt(6)     uint8_t mac_addrp[6]);
1409
1410 LIBEFX_INTERNAL
1411 extern  __checkReturn   efx_rc_t
1412 efx_mcdi_get_mac_address_vf(
1413         __in                    efx_nic_t *enp,
1414         __out_ecount_opt(6)     uint8_t mac_addrp[6]);
1415
1416 LIBEFX_INTERNAL
1417 extern  __checkReturn   efx_rc_t
1418 efx_mcdi_get_clock(
1419         __in            efx_nic_t *enp,
1420         __out           uint32_t *sys_freqp,
1421         __out           uint32_t *dpcpu_freqp);
1422
1423
1424 LIBEFX_INTERNAL
1425 extern  __checkReturn   efx_rc_t
1426 efx_mcdi_get_rxdp_config(
1427         __in            efx_nic_t *enp,
1428         __out           uint32_t *end_paddingp);
1429
1430 LIBEFX_INTERNAL
1431 extern  __checkReturn   efx_rc_t
1432 efx_mcdi_get_vector_cfg(
1433         __in            efx_nic_t *enp,
1434         __out_opt       uint32_t *vec_basep,
1435         __out_opt       uint32_t *pf_nvecp,
1436         __out_opt       uint32_t *vf_nvecp);
1437
1438 LIBEFX_INTERNAL
1439 extern  __checkReturn   efx_rc_t
1440 efx_mcdi_alloc_vis(
1441         __in            efx_nic_t *enp,
1442         __in            uint32_t min_vi_count,
1443         __in            uint32_t max_vi_count,
1444         __out           uint32_t *vi_basep,
1445         __out           uint32_t *vi_countp,
1446         __out           uint32_t *vi_shiftp);
1447
1448 LIBEFX_INTERNAL
1449 extern  __checkReturn   efx_rc_t
1450 efx_mcdi_free_vis(
1451         __in            efx_nic_t *enp);
1452
1453 LIBEFX_INTERNAL
1454 extern  __checkReturn           efx_rc_t
1455 ef10_get_privilege_mask(
1456         __in                    efx_nic_t *enp,
1457         __out                   uint32_t *maskp);
1458
1459 LIBEFX_INTERNAL
1460 extern  __checkReturn   efx_rc_t
1461 efx_mcdi_nic_board_cfg(
1462         __in            efx_nic_t *enp);
1463
1464 LIBEFX_INTERNAL
1465 extern  __checkReturn   efx_rc_t
1466 efx_mcdi_entity_reset(
1467         __in            efx_nic_t *enp);
1468
1469 #if EFSYS_OPT_FW_SUBVARIANT_AWARE
1470
1471 LIBEFX_INTERNAL
1472 extern  __checkReturn   efx_rc_t
1473 efx_mcdi_get_nic_global(
1474         __in            efx_nic_t *enp,
1475         __in            uint32_t key,
1476         __out           uint32_t *valuep);
1477
1478 LIBEFX_INTERNAL
1479 extern  __checkReturn   efx_rc_t
1480 efx_mcdi_set_nic_global(
1481         __in            efx_nic_t *enp,
1482         __in            uint32_t key,
1483         __in            uint32_t value);
1484
1485 #endif  /* EFSYS_OPT_FW_SUBVARIANT_AWARE */
1486
1487 #if EFSYS_OPT_EVB
1488 LIBEFX_INTERNAL
1489 extern  __checkReturn   efx_rc_t
1490 ef10_evb_init(
1491         __in            efx_nic_t *enp);
1492
1493 LIBEFX_INTERNAL
1494 extern                  void
1495 ef10_evb_fini(
1496         __in            efx_nic_t *enp);
1497
1498 LIBEFX_INTERNAL
1499 extern  __checkReturn   efx_rc_t
1500 ef10_evb_vswitch_alloc(
1501         __in            efx_nic_t *enp,
1502         __out           efx_vswitch_id_t *vswitch_idp);
1503
1504
1505 LIBEFX_INTERNAL
1506 extern  __checkReturn   efx_rc_t
1507 ef10_evb_vswitch_free(
1508         __in            efx_nic_t *enp,
1509         __in            efx_vswitch_id_t vswitch_id);
1510
1511 LIBEFX_INTERNAL
1512 extern  __checkReturn   efx_rc_t
1513 ef10_evb_vport_alloc(
1514         __in            efx_nic_t *enp,
1515         __in            efx_vswitch_id_t vswitch_id,
1516         __in            efx_vport_type_t vport_type,
1517         __in            uint16_t vid,
1518         __in            boolean_t vlan_restrict,
1519         __out           efx_vport_id_t *vport_idp);
1520
1521
1522 LIBEFX_INTERNAL
1523 extern  __checkReturn   efx_rc_t
1524 ef10_evb_vport_free(
1525         __in            efx_nic_t *enp,
1526         __in            efx_vswitch_id_t vswitch_id,
1527         __in            efx_vport_id_t vport_id);
1528
1529 LIBEFX_INTERNAL
1530 extern  __checkReturn   efx_rc_t
1531 ef10_evb_vport_mac_addr_add(
1532         __in            efx_nic_t *enp,
1533         __in            efx_vswitch_id_t vswitch_id,
1534         __in            efx_vport_id_t vport_id,
1535         __in_ecount(6)  uint8_t *addrp);
1536
1537 LIBEFX_INTERNAL
1538 extern  __checkReturn   efx_rc_t
1539 ef10_evb_vport_mac_addr_del(
1540         __in            efx_nic_t *enp,
1541         __in            efx_vswitch_id_t vswitch_id,
1542         __in            efx_vport_id_t vport_id,
1543         __in_ecount(6)  uint8_t *addrp);
1544
1545 LIBEFX_INTERNAL
1546 extern  __checkReturn   efx_rc_t
1547 ef10_evb_vadaptor_alloc(
1548         __in            efx_nic_t *enp,
1549         __in            efx_vswitch_id_t vswitch_id,
1550         __in            efx_vport_id_t vport_id);
1551
1552
1553 LIBEFX_INTERNAL
1554 extern __checkReturn    efx_rc_t
1555 ef10_evb_vadaptor_free(
1556         __in            efx_nic_t *enp,
1557         __in            efx_vswitch_id_t vswitch_id,
1558         __in            efx_vport_id_t vport_id);
1559
1560 LIBEFX_INTERNAL
1561 extern  __checkReturn   efx_rc_t
1562 ef10_evb_vport_assign(
1563         __in            efx_nic_t *enp,
1564         __in            efx_vswitch_id_t vswitch_id,
1565         __in            efx_vport_id_t vport_id,
1566         __in            uint32_t vf_index);
1567
1568 LIBEFX_INTERNAL
1569 extern  __checkReturn                           efx_rc_t
1570 ef10_evb_vport_reconfigure(
1571         __in                                    efx_nic_t *enp,
1572         __in                                    efx_vswitch_id_t vswitch_id,
1573         __in                                    efx_vport_id_t vport_id,
1574         __in_opt                                uint16_t *vidp,
1575         __in_bcount_opt(EFX_MAC_ADDR_LEN)       uint8_t *addrp,
1576         __out_opt                               boolean_t *fn_resetp);
1577
1578 LIBEFX_INTERNAL
1579 extern  __checkReturn   efx_rc_t
1580 ef10_evb_vport_stats(
1581         __in            efx_nic_t *enp,
1582         __in            efx_vswitch_id_t vswitch_id,
1583         __in            efx_vport_id_t vport_id,
1584         __out           efsys_mem_t *esmp);
1585
1586 #endif  /* EFSYS_OPT_EVB */
1587
1588 #if EFSYS_OPT_MCDI_PROXY_AUTH_SERVER
1589 LIBEFX_INTERNAL
1590 extern  __checkReturn   efx_rc_t
1591 ef10_proxy_auth_init(
1592         __in            efx_nic_t *enp);
1593
1594 LIBEFX_INTERNAL
1595 extern                  void
1596 ef10_proxy_auth_fini(
1597         __in            efx_nic_t *enp);
1598
1599 LIBEFX_INTERNAL
1600 extern  __checkReturn           efx_rc_t
1601 ef10_proxy_auth_mc_config(
1602         __in                    efx_nic_t *enp,
1603         __in                    efsys_mem_t *request_bufferp,
1604         __in                    efsys_mem_t *response_bufferp,
1605         __in                    efsys_mem_t *status_bufferp,
1606         __in                    uint32_t block_cnt,
1607         __in_ecount(op_count)   uint32_t *op_listp,
1608         __in                    size_t op_count);
1609
1610 LIBEFX_INTERNAL
1611 extern  __checkReturn   efx_rc_t
1612 ef10_proxy_auth_disable(
1613         __in            efx_nic_t *enp);
1614
1615 LIBEFX_INTERNAL
1616 extern  __checkReturn   efx_rc_t
1617 ef10_proxy_auth_privilege_modify(
1618         __in            efx_nic_t *enp,
1619         __in            uint32_t fn_group,
1620         __in            uint32_t pf_index,
1621         __in            uint32_t vf_index,
1622         __in            uint32_t add_privileges_mask,
1623         __in            uint32_t remove_privileges_mask);
1624
1625 LIBEFX_INTERNAL
1626 extern  __checkReturn   efx_rc_t
1627 ef10_proxy_auth_set_privilege_mask(
1628         __in            efx_nic_t *enp,
1629         __in            uint32_t vf_index,
1630         __in            uint32_t mask,
1631         __in            uint32_t value);
1632
1633 LIBEFX_INTERNAL
1634 extern  __checkReturn   efx_rc_t
1635 ef10_proxy_auth_complete_request(
1636         __in            efx_nic_t *enp,
1637         __in            uint32_t fn_index,
1638         __in            uint32_t proxy_result,
1639         __in            uint32_t handle);
1640
1641 LIBEFX_INTERNAL
1642 extern  __checkReturn   efx_rc_t
1643 ef10_proxy_auth_exec_cmd(
1644         __in            efx_nic_t *enp,
1645         __inout         efx_proxy_cmd_params_t *paramsp);
1646
1647 LIBEFX_INTERNAL
1648 extern  __checkReturn   efx_rc_t
1649 ef10_proxy_auth_get_privilege_mask(
1650         __in            efx_nic_t *enp,
1651         __in            uint32_t pf_index,
1652         __in            uint32_t vf_index,
1653         __out           uint32_t *maskp);
1654
1655 #endif  /* EFSYS_OPT_MCDI_PROXY_AUTH_SERVER */
1656
1657 #if EFSYS_OPT_RX_PACKED_STREAM
1658
1659 /* Data space per credit in packed stream mode */
1660 #define EFX_RX_PACKED_STREAM_MEM_PER_CREDIT (1 << 16)
1661
1662 /*
1663  * Received packets are always aligned at this boundary. Also there always
1664  * exists a gap of this size between packets.
1665  * (see SF-112241-TC, 4.5)
1666  */
1667 #define EFX_RX_PACKED_STREAM_ALIGNMENT 64
1668
1669 /*
1670  * Size of a pseudo-header prepended to received packets
1671  * in packed stream mode
1672  */
1673 #define EFX_RX_PACKED_STREAM_RX_PREFIX_SIZE 8
1674
1675 /* Minimum space for packet in packed stream mode */
1676 #define EFX_RX_PACKED_STREAM_MIN_PACKET_SPACE           \
1677         EFX_P2ROUNDUP(size_t,                           \
1678             EFX_RX_PACKED_STREAM_RX_PREFIX_SIZE +       \
1679             EFX_MAC_PDU_MIN +                           \
1680             EFX_RX_PACKED_STREAM_ALIGNMENT,             \
1681             EFX_RX_PACKED_STREAM_ALIGNMENT)
1682
1683 /* Maximum number of credits */
1684 #define EFX_RX_PACKED_STREAM_MAX_CREDITS 127
1685
1686 #endif /* EFSYS_OPT_RX_PACKED_STREAM */
1687
1688 #if EFSYS_OPT_RX_ES_SUPER_BUFFER
1689
1690 /*
1691  * Maximum DMA length and buffer stride alignment.
1692  * (see SF-119419-TC, 3.2)
1693  */
1694 #define EFX_RX_ES_SUPER_BUFFER_BUF_ALIGNMENT    64
1695
1696 #endif
1697
1698 #ifdef  __cplusplus
1699 }
1700 #endif
1701
1702 #endif  /* _SYS_EF10_IMPL_H */