drivers/common/sfc_efx/base/ef10_impl.h

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