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 /*
  46  * FIXME: This is just a power of 2 which fits in an MCDI v1 message, and could
  47  * possibly be increased, or the write size reported by newer firmware used
  48  * instead.
  49  */
  50 #define EF10_NVRAM_CHUNK 0x80
  51
  52 /* Alignment requirement for value written to RX WPTR:
  53  *  the WPTR must be aligned to an 8 descriptor boundary
  54  */
  55 #define EF10_RX_WPTR_ALIGN 8
  56
  57 /*
  58  * Max byte offset into the packet the TCP header must start for the hardware
  59  * to be able to parse the packet correctly.
  60  * FIXME: Move to ef10_impl.h when it is included in all driver builds.
  61  */
  62 #define EF10_TCP_HEADER_OFFSET_LIMIT    208
  63
  64 /* Invalid RSS context handle */
  65 #define EF10_RSS_CONTEXT_INVALID        (0xffffffff)
  66
  67
  68 /* EV */
  69
  70         __checkReturn   efx_rc_t
  71 ef10_ev_init(
  72         __in            efx_nic_t *enp);
  73
  74                         void
  75 ef10_ev_fini(
  76         __in            efx_nic_t *enp);
  77
  78         __checkReturn   efx_rc_t
  79 ef10_ev_qcreate(
  80         __in            efx_nic_t *enp,
  81         __in            unsigned int index,
  82         __in            efsys_mem_t *esmp,
  83         __in            size_t n,
  84         __in            uint32_t id,
  85         __in            efx_evq_t *eep);
  86
  87                         void
  88 ef10_ev_qdestroy(
  89         __in            efx_evq_t *eep);
  90
  91         __checkReturn   efx_rc_t
  92 ef10_ev_qprime(
  93         __in            efx_evq_t *eep,
  94         __in            unsigned int count);
  95
  96                         void
  97 ef10_ev_qpost(
  98         __in    efx_evq_t *eep,
  99         __in    uint16_t data);
 100
 101         __checkReturn   efx_rc_t
 102 ef10_ev_qmoderate(
 103         __in            efx_evq_t *eep,
 104         __in            unsigned int us);
 105
 106 #if EFSYS_OPT_QSTATS
 107                         void
 108 ef10_ev_qstats_update(
 109         __in                            efx_evq_t *eep,
 110         __inout_ecount(EV_NQSTATS)      efsys_stat_t *stat);
 111 #endif /* EFSYS_OPT_QSTATS */
 112
 113                 void
 114 ef10_ev_rxlabel_init(
 115         __in            efx_evq_t *eep,
 116         __in            efx_rxq_t *erp,
 117         __in            unsigned int label);
 118
 119                 void
 120 ef10_ev_rxlabel_fini(
 121         __in            efx_evq_t *eep,
 122         __in            unsigned int label);
 123
 124 /* INTR */
 125
 126         __checkReturn   efx_rc_t
 127 ef10_intr_init(
 128         __in            efx_nic_t *enp,
 129         __in            efx_intr_type_t type,
 130         __in            efsys_mem_t *esmp);
 131
 132                         void
 133 ef10_intr_enable(
 134         __in            efx_nic_t *enp);
 135
 136                         void
 137 ef10_intr_disable(
 138         __in            efx_nic_t *enp);
 139
 140                         void
 141 ef10_intr_disable_unlocked(
 142         __in            efx_nic_t *enp);
 143
 144         __checkReturn   efx_rc_t
 145 ef10_intr_trigger(
 146         __in            efx_nic_t *enp,
 147         __in            unsigned int level);
 148
 149                         void
 150 ef10_intr_status_line(
 151         __in            efx_nic_t *enp,
 152         __out           boolean_t *fatalp,
 153         __out           uint32_t *qmaskp);
 154
 155                         void
 156 ef10_intr_status_message(
 157         __in            efx_nic_t *enp,
 158         __in            unsigned int message,
 159         __out           boolean_t *fatalp);
 160
 161                         void
 162 ef10_intr_fatal(
 163         __in            efx_nic_t *enp);
 164                         void
 165 ef10_intr_fini(
 166         __in            efx_nic_t *enp);
 167
 168 /* NIC */
 169
 170 extern  __checkReturn   efx_rc_t
 171 ef10_nic_probe(
 172         __in            efx_nic_t *enp);
 173
 174 extern  __checkReturn   efx_rc_t
 175 hunt_board_cfg(
 176         __in            efx_nic_t *enp);
 177
 178 extern  __checkReturn   efx_rc_t
 179 ef10_nic_set_drv_limits(
 180         __inout         efx_nic_t *enp,
 181         __in            efx_drv_limits_t *edlp);
 182
 183 extern  __checkReturn   efx_rc_t
 184 ef10_nic_get_vi_pool(
 185         __in            efx_nic_t *enp,
 186         __out           uint32_t *vi_countp);
 187
 188 extern  __checkReturn   efx_rc_t
 189 ef10_nic_get_bar_region(
 190         __in            efx_nic_t *enp,
 191         __in            efx_nic_region_t region,
 192         __out           uint32_t *offsetp,
 193         __out           size_t *sizep);
 194
 195 extern  __checkReturn   efx_rc_t
 196 ef10_nic_reset(
 197         __in            efx_nic_t *enp);
 198
 199 extern  __checkReturn   efx_rc_t
 200 ef10_nic_init(
 201         __in            efx_nic_t *enp);
 202
 203 #if EFSYS_OPT_DIAG
 204
 205 extern  __checkReturn   efx_rc_t
 206 ef10_nic_register_test(
 207         __in            efx_nic_t *enp);
 208
 209 #endif  /* EFSYS_OPT_DIAG */
 210
 211 extern                  void
 212 ef10_nic_fini(
 213         __in            efx_nic_t *enp);
 214
 215 extern                  void
 216 ef10_nic_unprobe(
 217         __in            efx_nic_t *enp);
 218
 219
 220 /* MAC */
 221
 222 extern  __checkReturn   efx_rc_t
 223 hunt_mac_poll(
 224         __in            efx_nic_t *enp,
 225         __out           efx_link_mode_t *link_modep);
 226
 227 extern  __checkReturn   efx_rc_t
 228 hunt_mac_up(
 229         __in            efx_nic_t *enp,
 230         __out           boolean_t *mac_upp);
 231
 232 extern  __checkReturn   efx_rc_t
 233 hunt_mac_addr_set(
 234         __in    efx_nic_t *enp);
 235
 236 extern  __checkReturn   efx_rc_t
 237 hunt_mac_reconfigure(
 238         __in    efx_nic_t *enp);
 239
 240 extern  __checkReturn   efx_rc_t
 241 hunt_mac_multicast_list_set(
 242         __in                            efx_nic_t *enp);
 243
 244 extern  __checkReturn   efx_rc_t
 245 hunt_mac_filter_default_rxq_set(
 246         __in            efx_nic_t *enp,
 247         __in            efx_rxq_t *erp,
 248         __in            boolean_t using_rss);
 249
 250 extern                  void
 251 hunt_mac_filter_default_rxq_clear(
 252         __in            efx_nic_t *enp);
 253
 254 #if EFSYS_OPT_LOOPBACK
 255
 256 extern  __checkReturn   efx_rc_t
 257 hunt_mac_loopback_set(
 258         __in            efx_nic_t *enp,
 259         __in            efx_link_mode_t link_mode,
 260         __in            efx_loopback_type_t loopback_type);
 261
 262 #endif  /* EFSYS_OPT_LOOPBACK */
 263
 264 #if EFSYS_OPT_MAC_STATS
 265
 266 extern  __checkReturn                   efx_rc_t
 267 hunt_mac_stats_update(
 268         __in                            efx_nic_t *enp,
 269         __in                            efsys_mem_t *esmp,
 270         __inout_ecount(EFX_MAC_NSTATS)  efsys_stat_t *stat,
 271         __inout_opt                     uint32_t *generationp);
 272
 273 #endif  /* EFSYS_OPT_MAC_STATS */
 274
 275
 276 /* MCDI */
 277
 278 #if EFSYS_OPT_MCDI
 279
 280 extern  __checkReturn   efx_rc_t
 281 ef10_mcdi_init(
 282         __in            efx_nic_t *enp,
 283         __in            const efx_mcdi_transport_t *mtp);
 284
 285 extern                  void
 286 ef10_mcdi_fini(
 287         __in            efx_nic_t *enp);
 288
 289 extern                  void
 290 ef10_mcdi_send_request(
 291         __in            efx_nic_t *enp,
 292         __in            void *hdrp,
 293         __in            size_t hdr_len,
 294         __in            void *sdup,
 295         __in            size_t sdu_len);
 296
 297 extern  __checkReturn   boolean_t
 298 ef10_mcdi_poll_response(
 299         __in            efx_nic_t *enp);
 300
 301 extern                  void
 302 ef10_mcdi_read_response(
 303         __in                    efx_nic_t *enp,
 304         __out_bcount(length)    void *bufferp,
 305         __in                    size_t offset,
 306         __in                    size_t length);
 307
 308 extern                  void
 309 ef10_mcdi_request_copyout(
 310         __in            efx_nic_t *enp,
 311         __in            efx_mcdi_req_t *emrp);
 312
 313 extern                  efx_rc_t
 314 ef10_mcdi_poll_reboot(
 315         __in            efx_nic_t *enp);
 316
 317 extern  __checkReturn   efx_rc_t
 318 ef10_mcdi_feature_supported(
 319         __in            efx_nic_t *enp,
 320         __in            efx_mcdi_feature_id_t id,
 321         __out           boolean_t *supportedp);
 322
 323 #endif /* EFSYS_OPT_MCDI */
 324
 325 /* NVRAM */
 326
 327 #if EFSYS_OPT_NVRAM || EFSYS_OPT_VPD
 328
 329 extern  __checkReturn           efx_rc_t
 330 ef10_nvram_buf_read_tlv(
 331         __in                            efx_nic_t *enp,
 332         __in_bcount(max_seg_size)       caddr_t seg_data,
 333         __in                            size_t max_seg_size,
 334         __in                            uint32_t tag,
 335         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
 336         __out                           size_t *sizep);
 337
 338 extern  __checkReturn           efx_rc_t
 339 ef10_nvram_buf_write_tlv(
 340         __inout_bcount(partn_size)      caddr_t partn_data,
 341         __in                            size_t partn_size,
 342         __in                            uint32_t tag,
 343         __in_bcount(tag_size)           caddr_t tag_data,
 344         __in                            size_t tag_size,
 345         __out                           size_t *total_lengthp);
 346
 347 extern  __checkReturn           efx_rc_t
 348 ef10_nvram_partn_read_tlv(
 349         __in                            efx_nic_t *enp,
 350         __in                            uint32_t partn,
 351         __in                            uint32_t tag,
 352         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
 353         __out                           size_t *sizep);
 354
 355 extern  __checkReturn           efx_rc_t
 356 ef10_nvram_partn_write_tlv(
 357         __in                    efx_nic_t *enp,
 358         __in                    uint32_t partn,
 359         __in                    uint32_t tag,
 360         __in_bcount(size)       caddr_t data,
 361         __in                    size_t size);
 362
 363 extern  __checkReturn           efx_rc_t
 364 ef10_nvram_partn_write_segment_tlv(
 365         __in                    efx_nic_t *enp,
 366         __in                    uint32_t partn,
 367         __in                    uint32_t tag,
 368         __in_bcount(size)       caddr_t data,
 369         __in                    size_t size,
 370         __in                    boolean_t all_segments);
 371
 372 extern  __checkReturn           efx_rc_t
 373 ef10_nvram_partn_lock(
 374         __in                    efx_nic_t *enp,
 375         __in                    uint32_t partn);
 376
 377 extern  __checkReturn           efx_rc_t
 378 ef10_nvram_partn_read(
 379         __in                    efx_nic_t *enp,
 380         __in                    uint32_t partn,
 381         __in                    unsigned int offset,
 382         __out_bcount(size)      caddr_t data,
 383         __in                    size_t size);
 384
 385 extern  __checkReturn           efx_rc_t
 386 ef10_nvram_partn_erase(
 387         __in                    efx_nic_t *enp,
 388         __in                    uint32_t partn,
 389         __in                    unsigned int offset,
 390         __in                    size_t size);
 391
 392 extern  __checkReturn           efx_rc_t
 393 ef10_nvram_partn_write(
 394         __in                    efx_nic_t *enp,
 395         __in                    uint32_t partn,
 396         __in                    unsigned int offset,
 397         __out_bcount(size)      caddr_t data,
 398         __in                    size_t size);
 399
 400 extern                          void
 401 ef10_nvram_partn_unlock(
 402         __in                    efx_nic_t *enp,
 403         __in                    uint32_t partn);
 404
 405 #endif /* EFSYS_OPT_NVRAM || EFSYS_OPT_VPD */
 406
 407 #if EFSYS_OPT_NVRAM
 408
 409 #if EFSYS_OPT_DIAG
 410
 411 extern  __checkReturn           efx_rc_t
 412 ef10_nvram_test(
 413         __in                    efx_nic_t *enp);
 414
 415 #endif  /* EFSYS_OPT_DIAG */
 416
 417 extern  __checkReturn           efx_rc_t
 418 ef10_nvram_get_version(
 419         __in                    efx_nic_t *enp,
 420         __in                    efx_nvram_type_t type,
 421         __out                   uint32_t *subtypep,
 422         __out_ecount(4)         uint16_t version[4]);
 423
 424 extern  __checkReturn           efx_rc_t
 425 ef10_nvram_rw_start(
 426         __in                    efx_nic_t *enp,
 427         __in                    efx_nvram_type_t type,
 428         __out                   size_t *pref_chunkp);
 429
 430 extern  __checkReturn           efx_rc_t
 431 ef10_nvram_read_chunk(
 432         __in                    efx_nic_t *enp,
 433         __in                    efx_nvram_type_t type,
 434         __in                    unsigned int offset,
 435         __out_bcount(size)      caddr_t data,
 436         __in                    size_t size);
 437
 438 extern   __checkReturn          efx_rc_t
 439 ef10_nvram_erase(
 440         __in                    efx_nic_t *enp,
 441         __in                    efx_nvram_type_t type);
 442
 443 extern  __checkReturn           efx_rc_t
 444 ef10_nvram_write_chunk(
 445         __in                    efx_nic_t *enp,
 446         __in                    efx_nvram_type_t type,
 447         __in                    unsigned int offset,
 448         __in_bcount(size)       caddr_t data,
 449         __in                    size_t size);
 450
 451 extern                          void
 452 ef10_nvram_rw_finish(
 453         __in                    efx_nic_t *enp,
 454         __in                    efx_nvram_type_t type);
 455
 456 extern  __checkReturn           efx_rc_t
 457 ef10_nvram_partn_set_version(
 458         __in                    efx_nic_t *enp,
 459         __in                    uint32_t partn,
 460         __in_ecount(4)          uint16_t version[4]);
 461
 462 extern  __checkReturn           efx_rc_t
 463 ef10_nvram_set_version(
 464         __in                    efx_nic_t *enp,
 465         __in                    efx_nvram_type_t type,
 466         __in_ecount(4)          uint16_t version[4]);
 467
 468 extern  __checkReturn           efx_rc_t
 469 ef10_nvram_type_to_partn(
 470         __in                    efx_nic_t *enp,
 471         __in                    efx_nvram_type_t type,
 472         __out                   uint32_t *partnp);
 473
 474 extern  __checkReturn           efx_rc_t
 475 ef10_nvram_partn_size(
 476         __in                    efx_nic_t *enp,
 477         __in                    uint32_t partn,
 478         __out                   size_t *sizep);
 479
 480 #endif  /* EFSYS_OPT_NVRAM */
 481
 482
 483 /* PHY */
 484
 485 typedef struct hunt_link_state_s {
 486         uint32_t                hls_adv_cap_mask;
 487         uint32_t                hls_lp_cap_mask;
 488         unsigned int            hls_fcntl;
 489         efx_link_mode_t         hls_link_mode;
 490 #if EFSYS_OPT_LOOPBACK
 491         efx_loopback_type_t     hls_loopback;
 492 #endif
 493         boolean_t               hls_mac_up;
 494 } hunt_link_state_t;
 495
 496 extern                  void
 497 hunt_phy_link_ev(
 498         __in            efx_nic_t *enp,
 499         __in            efx_qword_t *eqp,
 500         __out           efx_link_mode_t *link_modep);
 501
 502 extern  __checkReturn   efx_rc_t
 503 hunt_phy_get_link(
 504         __in            efx_nic_t *enp,
 505         __out           hunt_link_state_t *hlsp);
 506
 507 extern  __checkReturn   efx_rc_t
 508 hunt_phy_power(
 509         __in            efx_nic_t *enp,
 510         __in            boolean_t on);
 511
 512 extern  __checkReturn   efx_rc_t
 513 hunt_phy_reconfigure(
 514         __in            efx_nic_t *enp);
 515
 516 extern  __checkReturn   efx_rc_t
 517 hunt_phy_verify(
 518         __in            efx_nic_t *enp);
 519
 520 extern  __checkReturn   efx_rc_t
 521 hunt_phy_oui_get(
 522         __in            efx_nic_t *enp,
 523         __out           uint32_t *ouip);
 524
 525 #if EFSYS_OPT_PHY_STATS
 526
 527 extern  __checkReturn                   efx_rc_t
 528 hunt_phy_stats_update(
 529         __in                            efx_nic_t *enp,
 530         __in                            efsys_mem_t *esmp,
 531         __inout_ecount(EFX_PHY_NSTATS)  uint32_t *stat);
 532
 533 #endif  /* EFSYS_OPT_PHY_STATS */
 534
 535 #if EFSYS_OPT_PHY_PROPS
 536
 537 #if EFSYS_OPT_NAMES
 538
 539 extern          const char *
 540 hunt_phy_prop_name(
 541         __in    efx_nic_t *enp,
 542         __in    unsigned int id);
 543
 544 #endif  /* EFSYS_OPT_NAMES */
 545
 546 extern  __checkReturn   efx_rc_t
 547 hunt_phy_prop_get(
 548         __in            efx_nic_t *enp,
 549         __in            unsigned int id,
 550         __in            uint32_t flags,
 551         __out           uint32_t *valp);
 552
 553 extern  __checkReturn   efx_rc_t
 554 hunt_phy_prop_set(
 555         __in            efx_nic_t *enp,
 556         __in            unsigned int id,
 557         __in            uint32_t val);
 558
 559 #endif  /* EFSYS_OPT_PHY_PROPS */
 560
 561 #if EFSYS_OPT_BIST
 562
 563 extern  __checkReturn           efx_rc_t
 564 hunt_bist_enable_offline(
 565         __in                    efx_nic_t *enp);
 566
 567 extern  __checkReturn           efx_rc_t
 568 hunt_bist_start(
 569         __in                    efx_nic_t *enp,
 570         __in                    efx_bist_type_t type);
 571
 572 extern  __checkReturn           efx_rc_t
 573 hunt_bist_poll(
 574         __in                    efx_nic_t *enp,
 575         __in                    efx_bist_type_t type,
 576         __out                   efx_bist_result_t *resultp,
 577         __out_opt __drv_when(count > 0, __notnull)
 578         uint32_t        *value_maskp,
 579         __out_ecount_opt(count) __drv_when(count > 0, __notnull)
 580         unsigned long   *valuesp,
 581         __in                    size_t count);
 582
 583 extern                          void
 584 hunt_bist_stop(
 585         __in                    efx_nic_t *enp,
 586         __in                    efx_bist_type_t type);
 587
 588 #endif  /* EFSYS_OPT_BIST */
 589
 590
 591 /* SRAM */
 592
 593 #if EFSYS_OPT_DIAG
 594
 595 extern  __checkReturn   efx_rc_t
 596 ef10_sram_test(
 597         __in            efx_nic_t *enp,
 598         __in            efx_sram_pattern_fn_t func);
 599
 600 #endif  /* EFSYS_OPT_DIAG */
 601
 602
 603 /* TX */
 604
 605 extern  __checkReturn   efx_rc_t
 606 ef10_tx_init(
 607         __in            efx_nic_t *enp);
 608
 609 extern                  void
 610 ef10_tx_fini(
 611         __in            efx_nic_t *enp);
 612
 613 extern  __checkReturn   efx_rc_t
 614 ef10_tx_qcreate(
 615         __in            efx_nic_t *enp,
 616         __in            unsigned int index,
 617         __in            unsigned int label,
 618         __in            efsys_mem_t *esmp,
 619         __in            size_t n,
 620         __in            uint32_t id,
 621         __in            uint16_t flags,
 622         __in            efx_evq_t *eep,
 623         __in            efx_txq_t *etp,
 624         __out           unsigned int *addedp);
 625
 626 extern          void
 627 ef10_tx_qdestroy(
 628         __in            efx_txq_t *etp);
 629
 630 extern  __checkReturn   efx_rc_t
 631 ef10_tx_qpost(
 632         __in            efx_txq_t *etp,
 633         __in_ecount(n)  efx_buffer_t *eb,
 634         __in            unsigned int n,
 635         __in            unsigned int completed,
 636         __inout         unsigned int *addedp);
 637
 638 extern                  void
 639 ef10_tx_qpush(
 640         __in            efx_txq_t *etp,
 641         __in            unsigned int added,
 642         __in            unsigned int pushed);
 643
 644 extern  __checkReturn   efx_rc_t
 645 ef10_tx_qpace(
 646         __in            efx_txq_t *etp,
 647         __in            unsigned int ns);
 648
 649 extern  __checkReturn   efx_rc_t
 650 ef10_tx_qflush(
 651         __in            efx_txq_t *etp);
 652
 653 extern                  void
 654 ef10_tx_qenable(
 655         __in            efx_txq_t *etp);
 656
 657 extern  __checkReturn   efx_rc_t
 658 ef10_tx_qpio_enable(
 659         __in            efx_txq_t *etp);
 660
 661 extern                  void
 662 ef10_tx_qpio_disable(
 663         __in            efx_txq_t *etp);
 664
 665 extern  __checkReturn   efx_rc_t
 666 ef10_tx_qpio_write(
 667         __in                    efx_txq_t *etp,
 668         __in_ecount(buf_length) uint8_t *buffer,
 669         __in                    size_t buf_length,
 670         __in                    size_t pio_buf_offset);
 671
 672 extern  __checkReturn   efx_rc_t
 673 ef10_tx_qpio_post(
 674         __in                    efx_txq_t *etp,
 675         __in                    size_t pkt_length,
 676         __in                    unsigned int completed,
 677         __inout                 unsigned int *addedp);
 678
 679 extern  __checkReturn   efx_rc_t
 680 ef10_tx_qdesc_post(
 681         __in            efx_txq_t *etp,
 682         __in_ecount(n)  efx_desc_t *ed,
 683         __in            unsigned int n,
 684         __in            unsigned int completed,
 685         __inout         unsigned int *addedp);
 686
 687 extern  void
 688 ef10_tx_qdesc_dma_create(
 689         __in    efx_txq_t *etp,
 690         __in    efsys_dma_addr_t addr,
 691         __in    size_t size,
 692         __in    boolean_t eop,
 693         __out   efx_desc_t *edp);
 694
 695 extern  void
 696 hunt_tx_qdesc_tso_create(
 697         __in    efx_txq_t *etp,
 698         __in    uint16_t ipv4_id,
 699         __in    uint32_t tcp_seq,
 700         __in    uint8_t  tcp_flags,
 701         __out   efx_desc_t *edp);
 702
 703 extern  void
 704 ef10_tx_qdesc_tso2_create(
 705         __in                    efx_txq_t *etp,
 706         __in                    uint16_t ipv4_id,
 707         __in                    uint32_t tcp_seq,
 708         __in                    uint16_t tcp_mss,
 709         __out_ecount(count)     efx_desc_t *edp,
 710         __in                    int count);
 711
 712 extern  void
 713 ef10_tx_qdesc_vlantci_create(
 714         __in    efx_txq_t *etp,
 715         __in    uint16_t vlan_tci,
 716         __out   efx_desc_t *edp);
 717
 718
 719 #if EFSYS_OPT_QSTATS
 720
 721 extern                  void
 722 ef10_tx_qstats_update(
 723         __in                            efx_txq_t *etp,
 724         __inout_ecount(TX_NQSTATS)      efsys_stat_t *stat);
 725
 726 #endif /* EFSYS_OPT_QSTATS */
 727
 728 /* PIO */
 729
 730 /* Missing register definitions */
 731 #ifndef ER_DZ_TX_PIOBUF_OFST
 732 #define ER_DZ_TX_PIOBUF_OFST 0x00001000
 733 #endif
 734 #ifndef ER_DZ_TX_PIOBUF_STEP
 735 #define ER_DZ_TX_PIOBUF_STEP 8192
 736 #endif
 737 #ifndef ER_DZ_TX_PIOBUF_ROWS
 738 #define ER_DZ_TX_PIOBUF_ROWS 2048
 739 #endif
 740
 741 #ifndef ER_DZ_TX_PIOBUF_SIZE
 742 #define ER_DZ_TX_PIOBUF_SIZE 2048
 743 #endif
 744
 745 #define HUNT_PIOBUF_NBUFS       (16)
 746 #define HUNT_PIOBUF_SIZE        (ER_DZ_TX_PIOBUF_SIZE)
 747
 748 #define HUNT_MIN_PIO_ALLOC_SIZE (HUNT_PIOBUF_SIZE / 32)
 749
 750 #define HUNT_LEGACY_PF_PRIVILEGE_MASK                                   \
 751         (MC_CMD_PRIVILEGE_MASK_IN_GRP_ADMIN                     |       \
 752         MC_CMD_PRIVILEGE_MASK_IN_GRP_LINK                       |       \
 753         MC_CMD_PRIVILEGE_MASK_IN_GRP_ONLOAD                     |       \
 754         MC_CMD_PRIVILEGE_MASK_IN_GRP_PTP                        |       \
 755         MC_CMD_PRIVILEGE_MASK_IN_GRP_INSECURE_FILTERS           |       \
 756         MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING               |       \
 757         MC_CMD_PRIVILEGE_MASK_IN_GRP_UNICAST                    |       \
 758         MC_CMD_PRIVILEGE_MASK_IN_GRP_MULTICAST                  |       \
 759         MC_CMD_PRIVILEGE_MASK_IN_GRP_BROADCAST                  |       \
 760         MC_CMD_PRIVILEGE_MASK_IN_GRP_ALL_MULTICAST              |       \
 761         MC_CMD_PRIVILEGE_MASK_IN_GRP_PROMISCUOUS)
 762
 763 #define HUNT_LEGACY_VF_PRIVILEGE_MASK   0
 764
 765 typedef uint32_t        efx_piobuf_handle_t;
 766
 767 #define EFX_PIOBUF_HANDLE_INVALID       ((efx_piobuf_handle_t) -1)
 768
 769 extern  __checkReturn   efx_rc_t
 770 ef10_nic_pio_alloc(
 771         __inout         efx_nic_t *enp,
 772         __out           uint32_t *bufnump,
 773         __out           efx_piobuf_handle_t *handlep,
 774         __out           uint32_t *blknump,
 775         __out           uint32_t *offsetp,
 776         __out           size_t *sizep);
 777
 778 extern  __checkReturn   efx_rc_t
 779 ef10_nic_pio_free(
 780         __inout         efx_nic_t *enp,
 781         __in            uint32_t bufnum,
 782         __in            uint32_t blknum);
 783
 784 extern  __checkReturn   efx_rc_t
 785 ef10_nic_pio_link(
 786         __inout         efx_nic_t *enp,
 787         __in            uint32_t vi_index,
 788         __in            efx_piobuf_handle_t handle);
 789
 790 extern  __checkReturn   efx_rc_t
 791 ef10_nic_pio_unlink(
 792         __inout         efx_nic_t *enp,
 793         __in            uint32_t vi_index);
 794
 795
 796 /* VPD */
 797
 798 #if EFSYS_OPT_VPD
 799
 800 extern  __checkReturn           efx_rc_t
 801 ef10_vpd_init(
 802         __in                    efx_nic_t *enp);
 803
 804 extern  __checkReturn           efx_rc_t
 805 ef10_vpd_size(
 806         __in                    efx_nic_t *enp,
 807         __out                   size_t *sizep);
 808
 809 extern  __checkReturn           efx_rc_t
 810 ef10_vpd_read(
 811         __in                    efx_nic_t *enp,
 812         __out_bcount(size)      caddr_t data,
 813         __in                    size_t size);
 814
 815 extern  __checkReturn           efx_rc_t
 816 ef10_vpd_verify(
 817         __in                    efx_nic_t *enp,
 818         __in_bcount(size)       caddr_t data,
 819         __in                    size_t size);
 820
 821 extern  __checkReturn           efx_rc_t
 822 ef10_vpd_reinit(
 823         __in                    efx_nic_t *enp,
 824         __in_bcount(size)       caddr_t data,
 825         __in                    size_t size);
 826
 827 extern  __checkReturn           efx_rc_t
 828 ef10_vpd_get(
 829         __in                    efx_nic_t *enp,
 830         __in_bcount(size)       caddr_t data,
 831         __in                    size_t size,
 832         __inout                 efx_vpd_value_t *evvp);
 833
 834 extern  __checkReturn           efx_rc_t
 835 ef10_vpd_set(
 836         __in                    efx_nic_t *enp,
 837         __in_bcount(size)       caddr_t data,
 838         __in                    size_t size,
 839         __in                    efx_vpd_value_t *evvp);
 840
 841 extern  __checkReturn           efx_rc_t
 842 ef10_vpd_next(
 843         __in                    efx_nic_t *enp,
 844         __in_bcount(size)       caddr_t data,
 845         __in                    size_t size,
 846         __out                   efx_vpd_value_t *evvp,
 847         __inout                 unsigned int *contp);
 848
 849 extern __checkReturn            efx_rc_t
 850 ef10_vpd_write(
 851         __in                    efx_nic_t *enp,
 852         __in_bcount(size)       caddr_t data,
 853         __in                    size_t size);
 854
 855 extern                          void
 856 ef10_vpd_fini(
 857         __in                    efx_nic_t *enp);
 858
 859 #endif  /* EFSYS_OPT_VPD */
 860
 861
 862 /* RX */
 863
 864 extern  __checkReturn   efx_rc_t
 865 ef10_rx_init(
 866         __in            efx_nic_t *enp);
 867
 868 #if EFSYS_OPT_RX_SCATTER
 869 extern  __checkReturn   efx_rc_t
 870 ef10_rx_scatter_enable(
 871         __in            efx_nic_t *enp,
 872         __in            unsigned int buf_size);
 873 #endif  /* EFSYS_OPT_RX_SCATTER */
 874
 875
 876 #if EFSYS_OPT_RX_SCALE
 877
 878 extern  __checkReturn   efx_rc_t
 879 ef10_rx_scale_mode_set(
 880         __in            efx_nic_t *enp,
 881         __in            efx_rx_hash_alg_t alg,
 882         __in            efx_rx_hash_type_t type,
 883         __in            boolean_t insert);
 884
 885 extern  __checkReturn   efx_rc_t
 886 ef10_rx_scale_key_set(
 887         __in            efx_nic_t *enp,
 888         __in_ecount(n)  uint8_t *key,
 889         __in            size_t n);
 890
 891 extern  __checkReturn   efx_rc_t
 892 ef10_rx_scale_tbl_set(
 893         __in            efx_nic_t *enp,
 894         __in_ecount(n)  unsigned int *table,
 895         __in            size_t n);
 896
 897 extern  __checkReturn   uint32_t
 898 ef10_rx_prefix_hash(
 899         __in            efx_nic_t *enp,
 900         __in            efx_rx_hash_alg_t func,
 901         __in            uint8_t *buffer);
 902
 903 #endif /* EFSYS_OPT_RX_SCALE */
 904
 905 extern  __checkReturn   efx_rc_t
 906 ef10_rx_prefix_pktlen(
 907         __in            efx_nic_t *enp,
 908         __in            uint8_t *buffer,
 909         __out           uint16_t *lengthp);
 910
 911 extern                  void
 912 ef10_rx_qpost(
 913         __in            efx_rxq_t *erp,
 914         __in_ecount(n)  efsys_dma_addr_t *addrp,
 915         __in            size_t size,
 916         __in            unsigned int n,
 917         __in            unsigned int completed,
 918         __in            unsigned int added);
 919
 920 extern                  void
 921 ef10_rx_qpush(
 922         __in            efx_rxq_t *erp,
 923         __in            unsigned int added,
 924         __inout         unsigned int *pushedp);
 925
 926 extern  __checkReturn   efx_rc_t
 927 ef10_rx_qflush(
 928         __in            efx_rxq_t *erp);
 929
 930 extern          void
 931 ef10_rx_qenable(
 932         __in            efx_rxq_t *erp);
 933
 934 extern  __checkReturn   efx_rc_t
 935 ef10_rx_qcreate(
 936         __in            efx_nic_t *enp,
 937         __in            unsigned int index,
 938         __in            unsigned int label,
 939         __in            efx_rxq_type_t type,
 940         __in            efsys_mem_t *esmp,
 941         __in            size_t n,
 942         __in            uint32_t id,
 943         __in            efx_evq_t *eep,
 944         __in            efx_rxq_t *erp);
 945
 946 extern                  void
 947 ef10_rx_qdestroy(
 948         __in            efx_rxq_t *erp);
 949
 950 extern                  void
 951 ef10_rx_fini(
 952         __in            efx_nic_t *enp);
 953
 954 #if EFSYS_OPT_FILTER
 955
 956 typedef struct ef10_filter_handle_s {
 957         uint32_t        efh_lo;
 958         uint32_t        efh_hi;
 959 } ef10_filter_handle_t;
 960
 961 typedef struct ef10_filter_entry_s {
 962         uintptr_t efe_spec; /* pointer to filter spec plus busy bit */
 963         ef10_filter_handle_t efe_handle;
 964 } ef10_filter_entry_t;
 965
 966 /*
 967  * BUSY flag indicates that an update is in progress.
 968  * AUTO_OLD flag is used to mark and sweep MAC packet filters.
 969  */
 970 #define EFX_EF10_FILTER_FLAG_BUSY       1U
 971 #define EFX_EF10_FILTER_FLAG_AUTO_OLD   2U
 972 #define EFX_EF10_FILTER_FLAGS           3U
 973
 974 /*
 975  * Size of the hash table used by the driver. Doesn't need to be the
 976  * same size as the hardware's table.
 977  */
 978 #define EFX_EF10_FILTER_TBL_ROWS 8192
 979
 980 /* Allow for the broadcast address to be added to the multicast list */
 981 #define EFX_EF10_FILTER_MULTICAST_FILTERS_MAX   (EFX_MAC_MULTICAST_LIST_MAX + 1)
 982
 983 typedef struct ef10_filter_table_s {
 984         ef10_filter_entry_t     eft_entry[EFX_EF10_FILTER_TBL_ROWS];
 985         efx_rxq_t *             eft_default_rxq;
 986         boolean_t               eft_using_rss;
 987         uint32_t                eft_unicst_filter_index;
 988         boolean_t               eft_unicst_filter_set;
 989         uint32_t                eft_mulcst_filter_indexes[
 990             EFX_EF10_FILTER_MULTICAST_FILTERS_MAX];
 991         uint32_t                eft_mulcst_filter_count;
 992 } ef10_filter_table_t;
 993
 994         __checkReturn   efx_rc_t
 995 ef10_filter_init(
 996         __in            efx_nic_t *enp);
 997
 998                         void
 999 ef10_filter_fini(
1000         __in            efx_nic_t *enp);
1001
1002         __checkReturn   efx_rc_t
1003 ef10_filter_restore(
1004         __in            efx_nic_t *enp);
1005
1006         __checkReturn   efx_rc_t
1007 ef10_filter_add(
1008         __in            efx_nic_t *enp,
1009         __inout         efx_filter_spec_t *spec,
1010         __in            boolean_t may_replace);
1011
1012         __checkReturn   efx_rc_t
1013 ef10_filter_delete(
1014         __in            efx_nic_t *enp,
1015         __inout         efx_filter_spec_t *spec);
1016
1017 extern  __checkReturn   efx_rc_t
1018 ef10_filter_supported_filters(
1019         __in            efx_nic_t *enp,
1020         __out           uint32_t *list,
1021         __out           size_t *length);
1022
1023 extern  __checkReturn   efx_rc_t
1024 ef10_filter_reconfigure(
1025         __in                            efx_nic_t *enp,
1026         __in_ecount(6)                  uint8_t const *mac_addr,
1027         __in                            boolean_t all_unicst,
1028         __in                            boolean_t mulcst,
1029         __in                            boolean_t all_mulcst,
1030         __in                            boolean_t brdcst,
1031         __in_ecount(6*count)            uint8_t const *addrs,
1032         __in                            int count);
1033
1034 extern          void
1035 ef10_filter_get_default_rxq(
1036         __in            efx_nic_t *enp,
1037         __out           efx_rxq_t **erpp,
1038         __out           boolean_t *using_rss);
1039
1040 extern          void
1041 ef10_filter_default_rxq_set(
1042         __in            efx_nic_t *enp,
1043         __in            efx_rxq_t *erp,
1044         __in            boolean_t using_rss);
1045
1046 extern          void
1047 ef10_filter_default_rxq_clear(
1048         __in            efx_nic_t *enp);
1049
1050
1051 #endif /* EFSYS_OPT_FILTER */
1052
1053 extern  __checkReturn                   efx_rc_t
1054 efx_mcdi_get_function_info(
1055         __in                            efx_nic_t *enp,
1056         __out                           uint32_t *pfp,
1057         __out_opt                       uint32_t *vfp);
1058
1059 extern  __checkReturn           efx_rc_t
1060 efx_mcdi_privilege_mask(
1061         __in                    efx_nic_t *enp,
1062         __in                    uint32_t pf,
1063         __in                    uint32_t vf,
1064         __out                   uint32_t *maskp);
1065
1066 #ifdef  __cplusplus
1067 }
1068 #endif
1069
1070 #endif  /* _SYS_HUNT_IMPL_H */