sys/dev/sfxge/common/hunt_impl.h

   1 /*-
   2  * Copyright (c) 2012-2015 Solarflare Communications Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright notice,
   9  *    this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright notice,
  11  *    this list of conditions and the following disclaimer in the documentation
  12  *    and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  24  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * The views and conclusions contained in the software and documentation are
  27  * those of the authors and should not be interpreted as representing official
  28  * policies, either expressed or implied, of the FreeBSD Project.
  29  *
  30  * $FreeBSD$
  31  */
  32
  33 #ifndef _SYS_HUNT_IMPL_H
  34 #define _SYS_HUNT_IMPL_H
  35
  36 #include "efx.h"
  37 #include "efx_regs.h"
  38 #include "efx_regs_ef10.h"
  39 #include "efx_mcdi.h"
  40
  41 #ifdef  __cplusplus
  42 extern "C" {
  43 #endif
  44
  45 #define HUNTINGTON_NVRAM_CHUNK 0x80
  46
  47 /* Alignment requirement for value written to RX WPTR:
  48  *  the WPTR must be aligned to an 8 descriptor boundary
  49  */
  50 #define HUNTINGTON_RX_WPTR_ALIGN 8
  51
  52 /* Invalid RSS context handle */
  53 #define HUNTINGTON_RSS_CONTEXT_INVALID  (0xffffffff)
  54
  55
  56 /* EV */
  57
  58         __checkReturn   efx_rc_t
  59 hunt_ev_init(
  60         __in            efx_nic_t *enp);
  61
  62                         void
  63 hunt_ev_fini(
  64         __in            efx_nic_t *enp);
  65
  66         __checkReturn   efx_rc_t
  67 hunt_ev_qcreate(
  68         __in            efx_nic_t *enp,
  69         __in            unsigned int index,
  70         __in            efsys_mem_t *esmp,
  71         __in            size_t n,
  72         __in            uint32_t id,
  73         __in            efx_evq_t *eep);
  74
  75                         void
  76 hunt_ev_qdestroy(
  77         __in            efx_evq_t *eep);
  78
  79         __checkReturn   efx_rc_t
  80 hunt_ev_qprime(
  81         __in            efx_evq_t *eep,
  82         __in            unsigned int count);
  83
  84                         void
  85 hunt_ev_qpost(
  86         __in    efx_evq_t *eep,
  87         __in    uint16_t data);
  88
  89         __checkReturn   efx_rc_t
  90 hunt_ev_qmoderate(
  91         __in            efx_evq_t *eep,
  92         __in            unsigned int us);
  93
  94 #if EFSYS_OPT_QSTATS
  95                         void
  96 hunt_ev_qstats_update(
  97         __in                            efx_evq_t *eep,
  98         __inout_ecount(EV_NQSTATS)      efsys_stat_t *stat);
  99 #endif /* EFSYS_OPT_QSTATS */
 100
 101                 void
 102 hunt_ev_rxlabel_init(
 103         __in            efx_evq_t *eep,
 104         __in            efx_rxq_t *erp,
 105         __in            unsigned int label);
 106
 107                 void
 108 hunt_ev_rxlabel_fini(
 109         __in            efx_evq_t *eep,
 110         __in            unsigned int label);
 111
 112 /* INTR */
 113
 114         __checkReturn   efx_rc_t
 115 hunt_intr_init(
 116         __in            efx_nic_t *enp,
 117         __in            efx_intr_type_t type,
 118         __in            efsys_mem_t *esmp);
 119
 120                         void
 121 hunt_intr_enable(
 122         __in            efx_nic_t *enp);
 123
 124                         void
 125 hunt_intr_disable(
 126         __in            efx_nic_t *enp);
 127
 128                         void
 129 hunt_intr_disable_unlocked(
 130         __in            efx_nic_t *enp);
 131
 132         __checkReturn   efx_rc_t
 133 hunt_intr_trigger(
 134         __in            efx_nic_t *enp,
 135         __in            unsigned int level);
 136
 137                         void
 138 hunt_intr_fini(
 139         __in            efx_nic_t *enp);
 140
 141 /* NIC */
 142
 143 extern  __checkReturn   efx_rc_t
 144 hunt_nic_probe(
 145         __in            efx_nic_t *enp);
 146
 147 extern  __checkReturn   efx_rc_t
 148 hunt_nic_set_drv_limits(
 149         __inout         efx_nic_t *enp,
 150         __in            efx_drv_limits_t *edlp);
 151
 152 extern  __checkReturn   efx_rc_t
 153 hunt_nic_get_vi_pool(
 154         __in            efx_nic_t *enp,
 155         __out           uint32_t *vi_countp);
 156
 157 extern  __checkReturn   efx_rc_t
 158 hunt_nic_get_bar_region(
 159         __in            efx_nic_t *enp,
 160         __in            efx_nic_region_t region,
 161         __out           uint32_t *offsetp,
 162         __out           size_t *sizep);
 163
 164 extern  __checkReturn   efx_rc_t
 165 hunt_nic_reset(
 166         __in            efx_nic_t *enp);
 167
 168 extern  __checkReturn   efx_rc_t
 169 hunt_nic_init(
 170         __in            efx_nic_t *enp);
 171
 172 #if EFSYS_OPT_DIAG
 173
 174 extern  __checkReturn   efx_rc_t
 175 hunt_nic_register_test(
 176         __in            efx_nic_t *enp);
 177
 178 #endif  /* EFSYS_OPT_DIAG */
 179
 180 extern                  void
 181 hunt_nic_fini(
 182         __in            efx_nic_t *enp);
 183
 184 extern                  void
 185 hunt_nic_unprobe(
 186         __in            efx_nic_t *enp);
 187
 188
 189 /* MAC */
 190
 191 extern  __checkReturn   efx_rc_t
 192 hunt_mac_poll(
 193         __in            efx_nic_t *enp,
 194         __out           efx_link_mode_t *link_modep);
 195
 196 extern  __checkReturn   efx_rc_t
 197 hunt_mac_up(
 198         __in            efx_nic_t *enp,
 199         __out           boolean_t *mac_upp);
 200
 201 extern  __checkReturn   efx_rc_t
 202 hunt_mac_addr_set(
 203         __in    efx_nic_t *enp);
 204
 205 extern  __checkReturn   efx_rc_t
 206 hunt_mac_reconfigure(
 207         __in    efx_nic_t *enp);
 208
 209 extern  __checkReturn   efx_rc_t
 210 hunt_mac_multicast_list_set(
 211         __in                            efx_nic_t *enp);
 212
 213 extern  __checkReturn   efx_rc_t
 214 hunt_mac_filter_default_rxq_set(
 215         __in            efx_nic_t *enp,
 216         __in            efx_rxq_t *erp,
 217         __in            boolean_t using_rss);
 218
 219 extern                  void
 220 hunt_mac_filter_default_rxq_clear(
 221         __in            efx_nic_t *enp);
 222
 223 #if EFSYS_OPT_LOOPBACK
 224
 225 extern  __checkReturn   efx_rc_t
 226 hunt_mac_loopback_set(
 227         __in            efx_nic_t *enp,
 228         __in            efx_link_mode_t link_mode,
 229         __in            efx_loopback_type_t loopback_type);
 230
 231 #endif  /* EFSYS_OPT_LOOPBACK */
 232
 233 #if EFSYS_OPT_MAC_STATS
 234
 235 extern  __checkReturn                   efx_rc_t
 236 hunt_mac_stats_update(
 237         __in                            efx_nic_t *enp,
 238         __in                            efsys_mem_t *esmp,
 239         __inout_ecount(EFX_MAC_NSTATS)  efsys_stat_t *stat,
 240         __inout_opt                     uint32_t *generationp);
 241
 242 #endif  /* EFSYS_OPT_MAC_STATS */
 243
 244
 245 /* MCDI */
 246
 247 #if EFSYS_OPT_MCDI
 248
 249 extern  __checkReturn   efx_rc_t
 250 hunt_mcdi_init(
 251         __in            efx_nic_t *enp,
 252         __in            const efx_mcdi_transport_t *mtp);
 253
 254 extern                  void
 255 hunt_mcdi_fini(
 256         __in            efx_nic_t *enp);
 257
 258 extern                  void
 259 hunt_mcdi_request_copyin(
 260         __in            efx_nic_t *enp,
 261         __in            efx_mcdi_req_t *emrp,
 262         __in            unsigned int seq,
 263         __in            boolean_t ev_cpl,
 264         __in            boolean_t new_epoch);
 265
 266 extern                  void
 267 hunt_mcdi_read_response(
 268         __in            efx_nic_t *enp,
 269         __out           void *bufferp,
 270         __in            size_t offset,
 271         __in            size_t length);
 272
 273 extern  __checkReturn   boolean_t
 274 hunt_mcdi_request_poll(
 275         __in            efx_nic_t *enp);
 276
 277 extern                  void
 278 hunt_mcdi_request_copyout(
 279         __in            efx_nic_t *enp,
 280         __in            efx_mcdi_req_t *emrp);
 281
 282 extern                  efx_rc_t
 283 hunt_mcdi_poll_reboot(
 284         __in            efx_nic_t *enp);
 285
 286 extern  __checkReturn   efx_rc_t
 287 hunt_mcdi_fw_update_supported(
 288         __in            efx_nic_t *enp,
 289         __out           boolean_t *supportedp);
 290
 291 extern  __checkReturn   efx_rc_t
 292 hunt_mcdi_macaddr_change_supported(
 293         __in            efx_nic_t *enp,
 294         __out           boolean_t *supportedp);
 295
 296 extern  __checkReturn   efx_rc_t
 297 hunt_mcdi_link_control_supported(
 298         __in            efx_nic_t *enp,
 299         __out           boolean_t *supportedp);
 300
 301 extern  __checkReturn   efx_rc_t
 302 hunt_mcdi_mac_spoofing_supported(
 303         __in            efx_nic_t *enp,
 304         __out           boolean_t *supportedp);
 305
 306
 307 #endif /* EFSYS_OPT_MCDI */
 308
 309 /* NVRAM */
 310
 311 #if EFSYS_OPT_NVRAM || EFSYS_OPT_VPD
 312
 313 extern  __checkReturn           efx_rc_t
 314 hunt_nvram_buf_read_tlv(
 315         __in                            efx_nic_t *enp,
 316         __in_bcount(max_seg_size)       caddr_t seg_data,
 317         __in                            size_t max_seg_size,
 318         __in                            uint32_t tag,
 319         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
 320         __out                           size_t *sizep);
 321
 322 extern  __checkReturn           efx_rc_t
 323 hunt_nvram_buf_write_tlv(
 324         __inout_bcount(partn_size)      caddr_t partn_data,
 325         __in                            size_t partn_size,
 326         __in                            uint32_t tag,
 327         __in_bcount(tag_size)           caddr_t tag_data,
 328         __in                            size_t tag_size,
 329         __out                           size_t *total_lengthp);
 330
 331 extern  __checkReturn           efx_rc_t
 332 hunt_nvram_partn_read_tlv(
 333         __in                            efx_nic_t *enp,
 334         __in                            uint32_t partn,
 335         __in                            uint32_t tag,
 336         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
 337         __out                           size_t *sizep);
 338
 339 extern  __checkReturn           efx_rc_t
 340 hunt_nvram_partn_write_tlv(
 341         __in                    efx_nic_t *enp,
 342         __in                    uint32_t partn,
 343         __in                    uint32_t tag,
 344         __in_bcount(size)       caddr_t data,
 345         __in                    size_t size);
 346
 347 extern  __checkReturn           efx_rc_t
 348 hunt_nvram_partn_write_segment_tlv(
 349         __in                    efx_nic_t *enp,
 350         __in                    uint32_t partn,
 351         __in                    uint32_t tag,
 352         __in_bcount(size)       caddr_t data,
 353         __in                    size_t size,
 354         __in                    boolean_t all_segments);
 355
 356 extern  __checkReturn           efx_rc_t
 357 hunt_nvram_partn_size(
 358         __in                    efx_nic_t *enp,
 359         __in                    unsigned int partn,
 360         __out                   size_t *sizep);
 361
 362 extern  __checkReturn           efx_rc_t
 363 hunt_nvram_partn_lock(
 364         __in                    efx_nic_t *enp,
 365         __in                    unsigned int partn);
 366
 367 extern  __checkReturn           efx_rc_t
 368 hunt_nvram_partn_read(
 369         __in                    efx_nic_t *enp,
 370         __in                    unsigned int partn,
 371         __in                    unsigned int offset,
 372         __out_bcount(size)      caddr_t data,
 373         __in                    size_t size);
 374
 375 extern  __checkReturn           efx_rc_t
 376 hunt_nvram_partn_erase(
 377         __in                    efx_nic_t *enp,
 378         __in                    unsigned int partn,
 379         __in                    unsigned int offset,
 380         __in                    size_t size);
 381
 382 extern  __checkReturn           efx_rc_t
 383 hunt_nvram_partn_write(
 384         __in                    efx_nic_t *enp,
 385         __in                    unsigned int partn,
 386         __in                    unsigned int offset,
 387         __out_bcount(size)      caddr_t data,
 388         __in                    size_t size);
 389
 390 extern                          void
 391 hunt_nvram_partn_unlock(
 392         __in                    efx_nic_t *enp,
 393         __in                    unsigned int partn);
 394
 395 #endif /* EFSYS_OPT_NVRAM || EFSYS_OPT_VPD */
 396
 397 #if EFSYS_OPT_NVRAM
 398
 399 #if EFSYS_OPT_DIAG
 400
 401 extern  __checkReturn           efx_rc_t
 402 hunt_nvram_test(
 403         __in                    efx_nic_t *enp);
 404
 405 #endif  /* EFSYS_OPT_DIAG */
 406
 407 extern  __checkReturn           efx_rc_t
 408 hunt_nvram_size(
 409         __in                    efx_nic_t *enp,
 410         __in                    efx_nvram_type_t type,
 411         __out                   size_t *sizep);
 412
 413 extern  __checkReturn           efx_rc_t
 414 hunt_nvram_get_version(
 415         __in                    efx_nic_t *enp,
 416         __in                    efx_nvram_type_t type,
 417         __out                   uint32_t *subtypep,
 418         __out_ecount(4)         uint16_t version[4]);
 419
 420 extern  __checkReturn           efx_rc_t
 421 hunt_nvram_rw_start(
 422         __in                    efx_nic_t *enp,
 423         __in                    efx_nvram_type_t type,
 424         __out                   size_t *pref_chunkp);
 425
 426 extern  __checkReturn           efx_rc_t
 427 hunt_nvram_read_chunk(
 428         __in                    efx_nic_t *enp,
 429         __in                    efx_nvram_type_t type,
 430         __in                    unsigned int offset,
 431         __out_bcount(size)      caddr_t data,
 432         __in                    size_t size);
 433
 434 extern   __checkReturn          efx_rc_t
 435 hunt_nvram_erase(
 436         __in                    efx_nic_t *enp,
 437         __in                    efx_nvram_type_t type);
 438
 439 extern  __checkReturn           efx_rc_t
 440 hunt_nvram_write_chunk(
 441         __in                    efx_nic_t *enp,
 442         __in                    efx_nvram_type_t type,
 443         __in                    unsigned int offset,
 444         __in_bcount(size)       caddr_t data,
 445         __in                    size_t size);
 446
 447 extern                          void
 448 hunt_nvram_rw_finish(
 449         __in                    efx_nic_t *enp,
 450         __in                    efx_nvram_type_t type);
 451
 452 extern  __checkReturn           efx_rc_t
 453 hunt_nvram_partn_set_version(
 454         __in                    efx_nic_t *enp,
 455         __in                    unsigned int partn,
 456         __in_ecount(4)          uint16_t version[4]);
 457
 458 extern  __checkReturn           efx_rc_t
 459 hunt_nvram_set_version(
 460         __in                    efx_nic_t *enp,
 461         __in                    efx_nvram_type_t type,
 462         __in_ecount(4)          uint16_t version[4]);
 463
 464 #endif  /* EFSYS_OPT_NVRAM */
 465
 466
 467 /* PHY */
 468
 469 typedef struct hunt_link_state_s {
 470         uint32_t                hls_adv_cap_mask;
 471         uint32_t                hls_lp_cap_mask;
 472         unsigned int            hls_fcntl;
 473         efx_link_mode_t         hls_link_mode;
 474 #if EFSYS_OPT_LOOPBACK
 475         efx_loopback_type_t     hls_loopback;
 476 #endif
 477         boolean_t               hls_mac_up;
 478 } hunt_link_state_t;
 479
 480 extern                  void
 481 hunt_phy_link_ev(
 482         __in            efx_nic_t *enp,
 483         __in            efx_qword_t *eqp,
 484         __out           efx_link_mode_t *link_modep);
 485
 486 extern  __checkReturn   efx_rc_t
 487 hunt_phy_get_link(
 488         __in            efx_nic_t *enp,
 489         __out           hunt_link_state_t *hlsp);
 490
 491 extern  __checkReturn   efx_rc_t
 492 hunt_phy_power(
 493         __in            efx_nic_t *enp,
 494         __in            boolean_t on);
 495
 496 extern  __checkReturn   efx_rc_t
 497 hunt_phy_reconfigure(
 498         __in            efx_nic_t *enp);
 499
 500 extern  __checkReturn   efx_rc_t
 501 hunt_phy_verify(
 502         __in            efx_nic_t *enp);
 503
 504 extern  __checkReturn   efx_rc_t
 505 hunt_phy_oui_get(
 506         __in            efx_nic_t *enp,
 507         __out           uint32_t *ouip);
 508
 509 #if EFSYS_OPT_PHY_STATS
 510
 511 extern  __checkReturn                   efx_rc_t
 512 hunt_phy_stats_update(
 513         __in                            efx_nic_t *enp,
 514         __in                            efsys_mem_t *esmp,
 515         __inout_ecount(EFX_PHY_NSTATS)  uint32_t *stat);
 516
 517 #endif  /* EFSYS_OPT_PHY_STATS */
 518
 519 #if EFSYS_OPT_PHY_PROPS
 520
 521 #if EFSYS_OPT_NAMES
 522
 523 extern          const char *
 524 hunt_phy_prop_name(
 525         __in    efx_nic_t *enp,
 526         __in    unsigned int id);
 527
 528 #endif  /* EFSYS_OPT_NAMES */
 529
 530 extern  __checkReturn   efx_rc_t
 531 hunt_phy_prop_get(
 532         __in            efx_nic_t *enp,
 533         __in            unsigned int id,
 534         __in            uint32_t flags,
 535         __out           uint32_t *valp);
 536
 537 extern  __checkReturn   efx_rc_t
 538 hunt_phy_prop_set(
 539         __in            efx_nic_t *enp,
 540         __in            unsigned int id,
 541         __in            uint32_t val);
 542
 543 #endif  /* EFSYS_OPT_PHY_PROPS */
 544
 545 #if EFSYS_OPT_BIST
 546
 547 extern  __checkReturn           efx_rc_t
 548 hunt_bist_enable_offline(
 549         __in                    efx_nic_t *enp);
 550
 551 extern  __checkReturn           efx_rc_t
 552 hunt_bist_start(
 553         __in                    efx_nic_t *enp,
 554         __in                    efx_bist_type_t type);
 555
 556 extern  __checkReturn           efx_rc_t
 557 hunt_bist_poll(
 558         __in                    efx_nic_t *enp,
 559         __in                    efx_bist_type_t type,
 560         __out                   efx_bist_result_t *resultp,
 561         __out_opt __drv_when(count > 0, __notnull)
 562         uint32_t        *value_maskp,
 563         __out_ecount_opt(count) __drv_when(count > 0, __notnull)
 564         unsigned long   *valuesp,
 565         __in                    size_t count);
 566
 567 extern                          void
 568 hunt_bist_stop(
 569         __in                    efx_nic_t *enp,
 570         __in                    efx_bist_type_t type);
 571
 572 #endif  /* EFSYS_OPT_BIST */
 573
 574
 575 /* SRAM */
 576
 577 #if EFSYS_OPT_DIAG
 578
 579 extern  __checkReturn   efx_rc_t
 580 hunt_sram_test(
 581         __in            efx_nic_t *enp,
 582         __in            efx_sram_pattern_fn_t func);
 583
 584 #endif  /* EFSYS_OPT_DIAG */
 585
 586
 587 /* TX */
 588
 589 extern  __checkReturn   efx_rc_t
 590 hunt_tx_init(
 591         __in            efx_nic_t *enp);
 592
 593 extern                  void
 594 hunt_tx_fini(
 595         __in            efx_nic_t *enp);
 596
 597 extern  __checkReturn   efx_rc_t
 598 hunt_tx_qcreate(
 599         __in            efx_nic_t *enp,
 600         __in            unsigned int index,
 601         __in            unsigned int label,
 602         __in            efsys_mem_t *esmp,
 603         __in            size_t n,
 604         __in            uint32_t id,
 605         __in            uint16_t flags,
 606         __in            efx_evq_t *eep,
 607         __in            efx_txq_t *etp,
 608         __out           unsigned int *addedp);
 609
 610 extern          void
 611 hunt_tx_qdestroy(
 612         __in            efx_txq_t *etp);
 613
 614 extern  __checkReturn   efx_rc_t
 615 hunt_tx_qpost(
 616         __in            efx_txq_t *etp,
 617         __in_ecount(n)  efx_buffer_t *eb,
 618         __in            unsigned int n,
 619         __in            unsigned int completed,
 620         __inout         unsigned int *addedp);
 621
 622 extern                  void
 623 hunt_tx_qpush(
 624         __in            efx_txq_t *etp,
 625         __in            unsigned int added,
 626         __in            unsigned int pushed);
 627
 628 extern  __checkReturn   efx_rc_t
 629 hunt_tx_qpace(
 630         __in            efx_txq_t *etp,
 631         __in            unsigned int ns);
 632
 633 extern  __checkReturn   efx_rc_t
 634 hunt_tx_qflush(
 635         __in            efx_txq_t *etp);
 636
 637 extern                  void
 638 hunt_tx_qenable(
 639         __in            efx_txq_t *etp);
 640
 641 extern  __checkReturn   efx_rc_t
 642 hunt_tx_qpio_enable(
 643         __in            efx_txq_t *etp);
 644
 645 extern                  void
 646 hunt_tx_qpio_disable(
 647         __in            efx_txq_t *etp);
 648
 649 extern  __checkReturn   efx_rc_t
 650 hunt_tx_qpio_write(
 651         __in                    efx_txq_t *etp,
 652         __in_ecount(buf_length) uint8_t *buffer,
 653         __in                    size_t buf_length,
 654         __in                    size_t pio_buf_offset);
 655
 656 extern  __checkReturn   efx_rc_t
 657 hunt_tx_qpio_post(
 658         __in                    efx_txq_t *etp,
 659         __in                    size_t pkt_length,
 660         __in                    unsigned int completed,
 661         __inout                 unsigned int *addedp);
 662
 663 extern  __checkReturn   efx_rc_t
 664 hunt_tx_qdesc_post(
 665         __in            efx_txq_t *etp,
 666         __in_ecount(n)  efx_desc_t *ed,
 667         __in            unsigned int n,
 668         __in            unsigned int completed,
 669         __inout         unsigned int *addedp);
 670
 671 extern  void
 672 hunt_tx_qdesc_dma_create(
 673         __in    efx_txq_t *etp,
 674         __in    efsys_dma_addr_t addr,
 675         __in    size_t size,
 676         __in    boolean_t eop,
 677         __out   efx_desc_t *edp);
 678
 679 extern  void
 680 hunt_tx_qdesc_tso_create(
 681         __in    efx_txq_t *etp,
 682         __in    uint16_t ipv4_id,
 683         __in    uint32_t tcp_seq,
 684         __in    uint8_t  tcp_flags,
 685         __out   efx_desc_t *edp);
 686
 687 extern  void
 688 hunt_tx_qdesc_vlantci_create(
 689         __in    efx_txq_t *etp,
 690         __in    uint16_t vlan_tci,
 691         __out   efx_desc_t *edp);
 692
 693
 694 #if EFSYS_OPT_QSTATS
 695
 696 extern                  void
 697 hunt_tx_qstats_update(
 698         __in                            efx_txq_t *etp,
 699         __inout_ecount(TX_NQSTATS)      efsys_stat_t *stat);
 700
 701 #endif /* EFSYS_OPT_QSTATS */
 702
 703 /* PIO */
 704
 705 /* Missing register definitions */
 706 #ifndef ER_DZ_TX_PIOBUF_OFST
 707 #define ER_DZ_TX_PIOBUF_OFST 0x00001000
 708 #endif
 709 #ifndef ER_DZ_TX_PIOBUF_STEP
 710 #define ER_DZ_TX_PIOBUF_STEP 8192
 711 #endif
 712 #ifndef ER_DZ_TX_PIOBUF_ROWS
 713 #define ER_DZ_TX_PIOBUF_ROWS 2048
 714 #endif
 715
 716 #ifndef ER_DZ_TX_PIOBUF_SIZE
 717 #define ER_DZ_TX_PIOBUF_SIZE 2048
 718 #endif
 719
 720 #define HUNT_PIOBUF_NBUFS       (16)
 721 #define HUNT_PIOBUF_SIZE        (ER_DZ_TX_PIOBUF_SIZE)
 722
 723 #define HUNT_MIN_PIO_ALLOC_SIZE (HUNT_PIOBUF_SIZE / 32)
 724
 725 #define HUNT_LEGACY_PF_PRIVILEGE_MASK                                   \
 726         (MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN                     |       \
 727         MC_CMD_PRIVILEGE_MASK_IN_GRP_LINK                       |       \
 728         MC_CMD_PRIVILEGE_MASK_IN_GRP_ONLOAD                     |       \
 729         MC_CMD_PRIVILEGE_MASK_IN_GRP_PTP                        |       \
 730         MC_CMD_PRIVILEGE_MASK_IN_GRP_INSECURE_FILTERS           |       \
 731         MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING               |       \
 732         MC_CMD_PRIVILEGE_MASK_IN_GRP_UNICAST                    |       \
 733         MC_CMD_PRIVILEGE_MASK_IN_GRP_MULTICAST                  |       \
 734         MC_CMD_PRIVILEGE_MASK_IN_GRP_BROADCAST                  |       \
 735         MC_CMD_PRIVILEGE_MASK_IN_GRP_ALL_MULTICAST              |       \
 736         MC_CMD_PRIVILEGE_MASK_IN_GRP_PROMISCUOUS)
 737
 738 #define HUNT_LEGACY_VF_PRIVILEGE_MASK   0
 739
 740 typedef uint32_t        efx_piobuf_handle_t;
 741
 742 #define EFX_PIOBUF_HANDLE_INVALID       ((efx_piobuf_handle_t) -1)
 743
 744 extern  __checkReturn   efx_rc_t
 745 hunt_nic_pio_alloc(
 746         __inout         efx_nic_t *enp,
 747         __out           uint32_t *bufnump,
 748         __out           efx_piobuf_handle_t *handlep,
 749         __out           uint32_t *blknump,
 750         __out           uint32_t *offsetp,
 751         __out           size_t *sizep);
 752
 753 extern  __checkReturn   efx_rc_t
 754 hunt_nic_pio_free(
 755         __inout         efx_nic_t *enp,
 756         __in            uint32_t bufnum,
 757         __in            uint32_t blknum);
 758
 759 extern  __checkReturn   efx_rc_t
 760 hunt_nic_pio_link(
 761         __inout         efx_nic_t *enp,
 762         __in            uint32_t vi_index,
 763         __in            efx_piobuf_handle_t handle);
 764
 765 extern  __checkReturn   efx_rc_t
 766 hunt_nic_pio_unlink(
 767         __inout         efx_nic_t *enp,
 768         __in            uint32_t vi_index);
 769
 770
 771 /* VPD */
 772
 773 #if EFSYS_OPT_VPD
 774
 775 extern  __checkReturn           efx_rc_t
 776 hunt_vpd_init(
 777         __in                    efx_nic_t *enp);
 778
 779 extern  __checkReturn           efx_rc_t
 780 hunt_vpd_size(
 781         __in                    efx_nic_t *enp,
 782         __out                   size_t *sizep);
 783
 784 extern  __checkReturn           efx_rc_t
 785 hunt_vpd_read(
 786         __in                    efx_nic_t *enp,
 787         __out_bcount(size)      caddr_t data,
 788         __in                    size_t size);
 789
 790 extern  __checkReturn           efx_rc_t
 791 hunt_vpd_verify(
 792         __in                    efx_nic_t *enp,
 793         __in_bcount(size)       caddr_t data,
 794         __in                    size_t size);
 795
 796 extern  __checkReturn           efx_rc_t
 797 hunt_vpd_reinit(
 798         __in                    efx_nic_t *enp,
 799         __in_bcount(size)       caddr_t data,
 800         __in                    size_t size);
 801
 802 extern  __checkReturn           efx_rc_t
 803 hunt_vpd_get(
 804         __in                    efx_nic_t *enp,
 805         __in_bcount(size)       caddr_t data,
 806         __in                    size_t size,
 807         __inout                 efx_vpd_value_t *evvp);
 808
 809 extern  __checkReturn           efx_rc_t
 810 hunt_vpd_set(
 811         __in                    efx_nic_t *enp,
 812         __in_bcount(size)       caddr_t data,
 813         __in                    size_t size,
 814         __in                    efx_vpd_value_t *evvp);
 815
 816 extern  __checkReturn           efx_rc_t
 817 hunt_vpd_next(
 818         __in                    efx_nic_t *enp,
 819         __in_bcount(size)       caddr_t data,
 820         __in                    size_t size,
 821         __out                   efx_vpd_value_t *evvp,
 822         __inout                 unsigned int *contp);
 823
 824 extern __checkReturn            efx_rc_t
 825 hunt_vpd_write(
 826         __in                    efx_nic_t *enp,
 827         __in_bcount(size)       caddr_t data,
 828         __in                    size_t size);
 829
 830 extern                          void
 831 hunt_vpd_fini(
 832         __in                    efx_nic_t *enp);
 833
 834 #endif  /* EFSYS_OPT_VPD */
 835
 836
 837 /* RX */
 838
 839 extern  __checkReturn   efx_rc_t
 840 hunt_rx_init(
 841         __in            efx_nic_t *enp);
 842
 843 #if EFSYS_OPT_RX_HDR_SPLIT
 844 extern  __checkReturn   efx_rc_t
 845 hunt_rx_hdr_split_enable(
 846         __in            efx_nic_t *enp,
 847         __in            unsigned int hdr_buf_size,
 848         __in            unsigned int pld_buf_size);
 849 #endif  /* EFSYS_OPT_RX_HDR_SPLIT */
 850
 851 #if EFSYS_OPT_RX_SCATTER
 852 extern  __checkReturn   efx_rc_t
 853 hunt_rx_scatter_enable(
 854         __in            efx_nic_t *enp,
 855         __in            unsigned int buf_size);
 856 #endif  /* EFSYS_OPT_RX_SCATTER */
 857
 858
 859 #if EFSYS_OPT_RX_SCALE
 860
 861 extern  __checkReturn   efx_rc_t
 862 hunt_rx_scale_mode_set(
 863         __in            efx_nic_t *enp,
 864         __in            efx_rx_hash_alg_t alg,
 865         __in            efx_rx_hash_type_t type,
 866         __in            boolean_t insert);
 867
 868 extern  __checkReturn   efx_rc_t
 869 hunt_rx_scale_key_set(
 870         __in            efx_nic_t *enp,
 871         __in_ecount(n)  uint8_t *key,
 872         __in            size_t n);
 873
 874 extern  __checkReturn   efx_rc_t
 875 hunt_rx_scale_tbl_set(
 876         __in            efx_nic_t *enp,
 877         __in_ecount(n)  unsigned int *table,
 878         __in            size_t n);
 879
 880 #endif /* EFSYS_OPT_RX_SCALE */
 881
 882 extern                  void
 883 hunt_rx_qpost(
 884         __in            efx_rxq_t *erp,
 885         __in_ecount(n)  efsys_dma_addr_t *addrp,
 886         __in            size_t size,
 887         __in            unsigned int n,
 888         __in            unsigned int completed,
 889         __in            unsigned int added);
 890
 891 extern                  void
 892 hunt_rx_qpush(
 893         __in            efx_rxq_t *erp,
 894         __in            unsigned int added,
 895         __inout         unsigned int *pushedp);
 896
 897 extern  __checkReturn   efx_rc_t
 898 hunt_rx_qflush(
 899         __in            efx_rxq_t *erp);
 900
 901 extern          void
 902 hunt_rx_qenable(
 903         __in            efx_rxq_t *erp);
 904
 905 extern  __checkReturn   efx_rc_t
 906 hunt_rx_qcreate(
 907         __in            efx_nic_t *enp,
 908         __in            unsigned int index,
 909         __in            unsigned int label,
 910         __in            efx_rxq_type_t type,
 911         __in            efsys_mem_t *esmp,
 912         __in            size_t n,
 913         __in            uint32_t id,
 914         __in            efx_evq_t *eep,
 915         __in            efx_rxq_t *erp);
 916
 917 extern                  void
 918 hunt_rx_qdestroy(
 919         __in            efx_rxq_t *erp);
 920
 921 extern                  void
 922 hunt_rx_fini(
 923         __in            efx_nic_t *enp);
 924
 925 #if EFSYS_OPT_FILTER
 926
 927 typedef struct hunt_filter_handle_s {
 928         uint32_t        hfh_lo;
 929         uint32_t        hfh_hi;
 930 } hunt_filter_handle_t;
 931
 932 typedef struct hunt_filter_entry_s {
 933         uintptr_t hfe_spec; /* pointer to filter spec plus busy bit */
 934         hunt_filter_handle_t hfe_handle;
 935 } hunt_filter_entry_t;
 936
 937 /*
 938  * BUSY flag indicates that an update is in progress.
 939  * AUTO_OLD flag is used to mark and sweep MAC packet filters.
 940  */
 941 #define EFX_HUNT_FILTER_FLAG_BUSY       1U
 942 #define EFX_HUNT_FILTER_FLAG_AUTO_OLD   2U
 943 #define EFX_HUNT_FILTER_FLAGS           3U
 944
 945 #define EFX_HUNT_FILTER_TBL_ROWS 8192
 946
 947 /* Allow for the broadcast address to be added to the multicast list */
 948 #define EFX_HUNT_FILTER_MULTICAST_FILTERS_MAX   (EFX_MAC_MULTICAST_LIST_MAX + 1)
 949
 950 typedef struct hunt_filter_table_s {
 951         hunt_filter_entry_t     hft_entry[EFX_HUNT_FILTER_TBL_ROWS];
 952         efx_rxq_t *             hft_default_rxq;
 953         boolean_t               hft_using_rss;
 954         uint32_t                hft_unicst_filter_index;
 955         boolean_t               hft_unicst_filter_set;
 956         uint32_t                hft_mulcst_filter_indexes[
 957             EFX_HUNT_FILTER_MULTICAST_FILTERS_MAX];
 958         uint32_t                hft_mulcst_filter_count;
 959 } hunt_filter_table_t;
 960
 961         __checkReturn   efx_rc_t
 962 hunt_filter_init(
 963         __in            efx_nic_t *enp);
 964
 965                         void
 966 hunt_filter_fini(
 967         __in            efx_nic_t *enp);
 968
 969         __checkReturn   efx_rc_t
 970 hunt_filter_restore(
 971         __in            efx_nic_t *enp);
 972
 973         __checkReturn   efx_rc_t
 974 hunt_filter_add(
 975         __in            efx_nic_t *enp,
 976         __inout         efx_filter_spec_t *spec,
 977         __in            boolean_t may_replace);
 978
 979         __checkReturn   efx_rc_t
 980 hunt_filter_delete(
 981         __in            efx_nic_t *enp,
 982         __inout         efx_filter_spec_t *spec);
 983
 984 extern  __checkReturn   efx_rc_t
 985 hunt_filter_supported_filters(
 986         __in            efx_nic_t *enp,
 987         __out           uint32_t *list,
 988         __out           size_t *length);
 989
 990 extern  __checkReturn   efx_rc_t
 991 hunt_filter_reconfigure(
 992         __in                            efx_nic_t *enp,
 993         __in_ecount(6)                  uint8_t const *mac_addr,
 994         __in                            boolean_t all_unicst,
 995         __in                            boolean_t mulcst,
 996         __in                            boolean_t all_mulcst,
 997         __in                            boolean_t brdcst,
 998         __in_ecount(6*count)            uint8_t const *addrs,
 999         __in                            int count);
1000
1001 extern          void
1002 hunt_filter_get_default_rxq(
1003         __in            efx_nic_t *enp,
1004         __out           efx_rxq_t **erpp,
1005         __out           boolean_t *using_rss);
1006
1007 extern          void
1008 hunt_filter_default_rxq_set(
1009         __in            efx_nic_t *enp,
1010         __in            efx_rxq_t *erp,
1011         __in            boolean_t using_rss);
1012
1013 extern          void
1014 hunt_filter_default_rxq_clear(
1015         __in            efx_nic_t *enp);
1016
1017
1018 #endif /* EFSYS_OPT_FILTER */
1019
1020 extern  __checkReturn                   efx_rc_t
1021 hunt_pktfilter_set(
1022         __in                            efx_nic_t *enp,
1023         __in                            boolean_t unicst,
1024         __in                            boolean_t brdcst);
1025
1026 #if EFSYS_OPT_MCAST_FILTER_LIST
1027
1028 extern  __checkReturn                   efx_rc_t
1029 hunt_pktfilter_mcast_set(
1030         __in                            efx_nic_t *enp,
1031         __in                            uint8_t const *addrs,
1032         __in                            int count);
1033
1034 #endif /* EFSYS_OPT_MCAST_FILTER_LIST */
1035
1036 extern  __checkReturn                   efx_rc_t
1037 hunt_pktfilter_mcast_all(
1038         __in                            efx_nic_t *enp);
1039
1040 extern  __checkReturn                   efx_rc_t
1041 efx_mcdi_get_function_info(
1042         __in                            efx_nic_t *enp,
1043         __out                           uint32_t *pfp,
1044         __out_opt                       uint32_t *vfp);
1045
1046 extern  __checkReturn           efx_rc_t
1047 efx_mcdi_privilege_mask(
1048         __in                    efx_nic_t *enp,
1049         __in                    uint32_t pf,
1050         __in                    uint32_t vf,
1051         __out                   uint32_t *maskp);
1052
1053 #ifdef  __cplusplus
1054 }
1055 #endif
1056
1057 #endif  /* _SYS_HUNT_IMPL_H */