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