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