drivers/net/sfc/base/ef10_impl.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright (c) 2015-2018 Solarflare Communications Inc.
   4  * All rights reserved.
   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 #if (EFSYS_OPT_HUNTINGTON && EFSYS_OPT_MEDFORD)
  15 #define EF10_MAX_PIOBUF_NBUFS   MAX(HUNT_PIOBUF_NBUFS, MEDFORD_PIOBUF_NBUFS)
  16 #elif EFSYS_OPT_HUNTINGTON
  17 #define EF10_MAX_PIOBUF_NBUFS   HUNT_PIOBUF_NBUFS
  18 #elif EFSYS_OPT_MEDFORD
  19 #define EF10_MAX_PIOBUF_NBUFS   MEDFORD_PIOBUF_NBUFS
  20 #endif
  21
  22 /*
  23  * FIXME: This is just a power of 2 which fits in an MCDI v1 message, and could
  24  * possibly be increased, or the write size reported by newer firmware used
  25  * instead.
  26  */
  27 #define EF10_NVRAM_CHUNK 0x80
  28
  29 /*
  30  * Alignment requirement for value written to RX WPTR: the WPTR must be aligned
  31  * to an 8 descriptor boundary.
  32  */
  33 #define EF10_RX_WPTR_ALIGN 8
  34
  35 /*
  36  * Max byte offset into the packet the TCP header must start for the hardware
  37  * to be able to parse the packet correctly.
  38  */
  39 #define EF10_TCP_HEADER_OFFSET_LIMIT    208
  40
  41 /* Invalid RSS context handle */
  42 #define EF10_RSS_CONTEXT_INVALID        (0xffffffff)
  43
  44
  45 /* EV */
  46
  47         __checkReturn   efx_rc_t
  48 ef10_ev_init(
  49         __in            efx_nic_t *enp);
  50
  51                         void
  52 ef10_ev_fini(
  53         __in            efx_nic_t *enp);
  54
  55         __checkReturn   efx_rc_t
  56 ef10_ev_qcreate(
  57         __in            efx_nic_t *enp,
  58         __in            unsigned int index,
  59         __in            efsys_mem_t *esmp,
  60         __in            size_t ndescs,
  61         __in            uint32_t id,
  62         __in            uint32_t us,
  63         __in            uint32_t flags,
  64         __in            efx_evq_t *eep);
  65
  66                         void
  67 ef10_ev_qdestroy(
  68         __in            efx_evq_t *eep);
  69
  70         __checkReturn   efx_rc_t
  71 ef10_ev_qprime(
  72         __in            efx_evq_t *eep,
  73         __in            unsigned int count);
  74
  75                         void
  76 ef10_ev_qpost(
  77         __in    efx_evq_t *eep,
  78         __in    uint16_t data);
  79
  80         __checkReturn   efx_rc_t
  81 ef10_ev_qmoderate(
  82         __in            efx_evq_t *eep,
  83         __in            unsigned int us);
  84
  85 #if EFSYS_OPT_QSTATS
  86                         void
  87 ef10_ev_qstats_update(
  88         __in                            efx_evq_t *eep,
  89         __inout_ecount(EV_NQSTATS)      efsys_stat_t *stat);
  90 #endif /* EFSYS_OPT_QSTATS */
  91
  92                 void
  93 ef10_ev_rxlabel_init(
  94         __in            efx_evq_t *eep,
  95         __in            efx_rxq_t *erp,
  96         __in            unsigned int label,
  97         __in            efx_rxq_type_t type);
  98
  99                 void
 100 ef10_ev_rxlabel_fini(
 101         __in            efx_evq_t *eep,
 102         __in            unsigned int label);
 103
 104 /* INTR */
 105
 106         __checkReturn   efx_rc_t
 107 ef10_intr_init(
 108         __in            efx_nic_t *enp,
 109         __in            efx_intr_type_t type,
 110         __in            efsys_mem_t *esmp);
 111
 112                         void
 113 ef10_intr_enable(
 114         __in            efx_nic_t *enp);
 115
 116                         void
 117 ef10_intr_disable(
 118         __in            efx_nic_t *enp);
 119
 120                         void
 121 ef10_intr_disable_unlocked(
 122         __in            efx_nic_t *enp);
 123
 124         __checkReturn   efx_rc_t
 125 ef10_intr_trigger(
 126         __in            efx_nic_t *enp,
 127         __in            unsigned int level);
 128
 129                         void
 130 ef10_intr_status_line(
 131         __in            efx_nic_t *enp,
 132         __out           boolean_t *fatalp,
 133         __out           uint32_t *qmaskp);
 134
 135                         void
 136 ef10_intr_status_message(
 137         __in            efx_nic_t *enp,
 138         __in            unsigned int message,
 139         __out           boolean_t *fatalp);
 140
 141                         void
 142 ef10_intr_fatal(
 143         __in            efx_nic_t *enp);
 144                         void
 145 ef10_intr_fini(
 146         __in            efx_nic_t *enp);
 147
 148 /* NIC */
 149
 150 extern  __checkReturn   efx_rc_t
 151 ef10_nic_probe(
 152         __in            efx_nic_t *enp);
 153
 154 extern  __checkReturn   efx_rc_t
 155 ef10_nic_set_drv_limits(
 156         __inout         efx_nic_t *enp,
 157         __in            efx_drv_limits_t *edlp);
 158
 159 extern  __checkReturn   efx_rc_t
 160 ef10_nic_get_vi_pool(
 161         __in            efx_nic_t *enp,
 162         __out           uint32_t *vi_countp);
 163
 164 extern  __checkReturn   efx_rc_t
 165 ef10_nic_get_bar_region(
 166         __in            efx_nic_t *enp,
 167         __in            efx_nic_region_t region,
 168         __out           uint32_t *offsetp,
 169         __out           size_t *sizep);
 170
 171 extern  __checkReturn   efx_rc_t
 172 ef10_nic_reset(
 173         __in            efx_nic_t *enp);
 174
 175 extern  __checkReturn   efx_rc_t
 176 ef10_nic_init(
 177         __in            efx_nic_t *enp);
 178
 179 #if EFSYS_OPT_DIAG
 180
 181 extern  __checkReturn   efx_rc_t
 182 ef10_nic_register_test(
 183         __in            efx_nic_t *enp);
 184
 185 #endif  /* EFSYS_OPT_DIAG */
 186
 187 extern                  void
 188 ef10_nic_fini(
 189         __in            efx_nic_t *enp);
 190
 191 extern                  void
 192 ef10_nic_unprobe(
 193         __in            efx_nic_t *enp);
 194
 195
 196 /* MAC */
 197
 198 extern  __checkReturn   efx_rc_t
 199 ef10_mac_poll(
 200         __in            efx_nic_t *enp,
 201         __out           efx_link_mode_t *link_modep);
 202
 203 extern  __checkReturn   efx_rc_t
 204 ef10_mac_up(
 205         __in            efx_nic_t *enp,
 206         __out           boolean_t *mac_upp);
 207
 208 extern  __checkReturn   efx_rc_t
 209 ef10_mac_addr_set(
 210         __in    efx_nic_t *enp);
 211
 212 extern  __checkReturn   efx_rc_t
 213 ef10_mac_pdu_set(
 214         __in    efx_nic_t *enp);
 215
 216 extern  __checkReturn   efx_rc_t
 217 ef10_mac_pdu_get(
 218         __in    efx_nic_t *enp,
 219         __out   size_t *pdu);
 220
 221 extern  __checkReturn   efx_rc_t
 222 ef10_mac_reconfigure(
 223         __in    efx_nic_t *enp);
 224
 225 extern  __checkReturn   efx_rc_t
 226 ef10_mac_multicast_list_set(
 227         __in                            efx_nic_t *enp);
 228
 229 extern  __checkReturn   efx_rc_t
 230 ef10_mac_filter_default_rxq_set(
 231         __in            efx_nic_t *enp,
 232         __in            efx_rxq_t *erp,
 233         __in            boolean_t using_rss);
 234
 235 extern                  void
 236 ef10_mac_filter_default_rxq_clear(
 237         __in            efx_nic_t *enp);
 238
 239 #if EFSYS_OPT_LOOPBACK
 240
 241 extern  __checkReturn   efx_rc_t
 242 ef10_mac_loopback_set(
 243         __in            efx_nic_t *enp,
 244         __in            efx_link_mode_t link_mode,
 245         __in            efx_loopback_type_t loopback_type);
 246
 247 #endif  /* EFSYS_OPT_LOOPBACK */
 248
 249 #if EFSYS_OPT_MAC_STATS
 250
 251 extern  __checkReturn                   efx_rc_t
 252 ef10_mac_stats_get_mask(
 253         __in                            efx_nic_t *enp,
 254         __inout_bcount(mask_size)       uint32_t *maskp,
 255         __in                            size_t mask_size);
 256
 257 extern  __checkReturn                   efx_rc_t
 258 ef10_mac_stats_update(
 259         __in                            efx_nic_t *enp,
 260         __in                            efsys_mem_t *esmp,
 261         __inout_ecount(EFX_MAC_NSTATS)  efsys_stat_t *stat,
 262         __inout_opt                     uint32_t *generationp);
 263
 264 #endif  /* EFSYS_OPT_MAC_STATS */
 265
 266
 267 /* MCDI */
 268
 269 #if EFSYS_OPT_MCDI
 270
 271 extern  __checkReturn   efx_rc_t
 272 ef10_mcdi_init(
 273         __in            efx_nic_t *enp,
 274         __in            const efx_mcdi_transport_t *mtp);
 275
 276 extern                  void
 277 ef10_mcdi_fini(
 278         __in            efx_nic_t *enp);
 279
 280 extern                  void
 281 ef10_mcdi_send_request(
 282         __in                    efx_nic_t *enp,
 283         __in_bcount(hdr_len)    void *hdrp,
 284         __in                    size_t hdr_len,
 285         __in_bcount(sdu_len)    void *sdup,
 286         __in                    size_t sdu_len);
 287
 288 extern  __checkReturn   boolean_t
 289 ef10_mcdi_poll_response(
 290         __in            efx_nic_t *enp);
 291
 292 extern                  void
 293 ef10_mcdi_read_response(
 294         __in                    efx_nic_t *enp,
 295         __out_bcount(length)    void *bufferp,
 296         __in                    size_t offset,
 297         __in                    size_t length);
 298
 299 extern                  efx_rc_t
 300 ef10_mcdi_poll_reboot(
 301         __in            efx_nic_t *enp);
 302
 303 extern  __checkReturn   efx_rc_t
 304 ef10_mcdi_feature_supported(
 305         __in            efx_nic_t *enp,
 306         __in            efx_mcdi_feature_id_t id,
 307         __out           boolean_t *supportedp);
 308
 309 extern                  void
 310 ef10_mcdi_get_timeout(
 311         __in            efx_nic_t *enp,
 312         __in            efx_mcdi_req_t *emrp,
 313         __out           uint32_t *timeoutp);
 314
 315 #endif /* EFSYS_OPT_MCDI */
 316
 317 /* NVRAM */
 318
 319 #if EFSYS_OPT_NVRAM || EFSYS_OPT_VPD
 320
 321 extern  __checkReturn           efx_rc_t
 322 ef10_nvram_buf_read_tlv(
 323         __in                            efx_nic_t *enp,
 324         __in_bcount(max_seg_size)       caddr_t seg_data,
 325         __in                            size_t max_seg_size,
 326         __in                            uint32_t tag,
 327         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
 328         __out                           size_t *sizep);
 329
 330 extern  __checkReturn           efx_rc_t
 331 ef10_nvram_buf_write_tlv(
 332         __inout_bcount(partn_size)      caddr_t partn_data,
 333         __in                            size_t partn_size,
 334         __in                            uint32_t tag,
 335         __in_bcount(tag_size)           caddr_t tag_data,
 336         __in                            size_t tag_size,
 337         __out                           size_t *total_lengthp);
 338
 339 extern  __checkReturn           efx_rc_t
 340 ef10_nvram_partn_read_tlv(
 341         __in                            efx_nic_t *enp,
 342         __in                            uint32_t partn,
 343         __in                            uint32_t tag,
 344         __deref_out_bcount_opt(*sizep)  caddr_t *datap,
 345         __out                           size_t *sizep);
 346
 347 extern  __checkReturn           efx_rc_t
 348 ef10_nvram_partn_write_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
 355 extern  __checkReturn           efx_rc_t
 356 ef10_nvram_partn_write_segment_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         __in                    boolean_t all_segments);
 363
 364 extern  __checkReturn           efx_rc_t
 365 ef10_nvram_partn_lock(
 366         __in                    efx_nic_t *enp,
 367         __in                    uint32_t partn);
 368
 369 extern  __checkReturn           efx_rc_t
 370 ef10_nvram_partn_unlock(
 371         __in                    efx_nic_t *enp,
 372         __in                    uint32_t partn,
 373         __out_opt               uint32_t *resultp);
 374
 375 #endif /* EFSYS_OPT_NVRAM || EFSYS_OPT_VPD */
 376
 377 #if EFSYS_OPT_NVRAM
 378
 379 #if EFSYS_OPT_DIAG
 380
 381 extern  __checkReturn           efx_rc_t
 382 ef10_nvram_test(
 383         __in                    efx_nic_t *enp);
 384
 385 #endif  /* EFSYS_OPT_DIAG */
 386
 387 extern  __checkReturn           efx_rc_t
 388 ef10_nvram_type_to_partn(
 389         __in                    efx_nic_t *enp,
 390         __in                    efx_nvram_type_t type,
 391         __out                   uint32_t *partnp);
 392
 393 extern  __checkReturn           efx_rc_t
 394 ef10_nvram_partn_size(
 395         __in                    efx_nic_t *enp,
 396         __in                    uint32_t partn,
 397         __out                   size_t *sizep);
 398
 399 extern  __checkReturn           efx_rc_t
 400 ef10_nvram_partn_rw_start(
 401         __in                    efx_nic_t *enp,
 402         __in                    uint32_t partn,
 403         __out                   size_t *chunk_sizep);
 404
 405 extern  __checkReturn           efx_rc_t
 406 ef10_nvram_partn_read_mode(
 407         __in                    efx_nic_t *enp,
 408         __in                    uint32_t partn,
 409         __in                    unsigned int offset,
 410         __out_bcount(size)      caddr_t data,
 411         __in                    size_t size,
 412         __in                    uint32_t mode);
 413
 414 extern  __checkReturn           efx_rc_t
 415 ef10_nvram_partn_read(
 416         __in                    efx_nic_t *enp,
 417         __in                    uint32_t partn,
 418         __in                    unsigned int offset,
 419         __out_bcount(size)      caddr_t data,
 420         __in                    size_t size);
 421
 422 extern  __checkReturn           efx_rc_t
 423 ef10_nvram_partn_read_backup(
 424         __in                    efx_nic_t *enp,
 425         __in                    uint32_t partn,
 426         __in                    unsigned int offset,
 427         __out_bcount(size)      caddr_t data,
 428         __in                    size_t size);
 429
 430 extern  __checkReturn           efx_rc_t
 431 ef10_nvram_partn_erase(
 432         __in                    efx_nic_t *enp,
 433         __in                    uint32_t partn,
 434         __in                    unsigned int offset,
 435         __in                    size_t size);
 436
 437 extern  __checkReturn           efx_rc_t
 438 ef10_nvram_partn_write(
 439         __in                    efx_nic_t *enp,
 440         __in                    uint32_t partn,
 441         __in                    unsigned int offset,
 442         __out_bcount(size)      caddr_t data,
 443         __in                    size_t size);
 444
 445 extern  __checkReturn           efx_rc_t
 446 ef10_nvram_partn_rw_finish(
 447         __in                    efx_nic_t *enp,
 448         __in                    uint32_t partn,
 449         __out_opt               uint32_t *verify_resultp);
 450
 451 extern  __checkReturn           efx_rc_t
 452 ef10_nvram_partn_get_version(
 453         __in                    efx_nic_t *enp,
 454         __in                    uint32_t partn,
 455         __out                   uint32_t *subtypep,
 456         __out_ecount(4)         uint16_t version[4]);
 457
 458 extern  __checkReturn           efx_rc_t
 459 ef10_nvram_partn_set_version(
 460         __in                    efx_nic_t *enp,
 461         __in                    uint32_t partn,
 462         __in_ecount(4)          uint16_t version[4]);
 463
 464 extern  __checkReturn           efx_rc_t
 465 ef10_nvram_buffer_validate(
 466         __in                    efx_nic_t *enp,
 467         __in                    uint32_t partn,
 468         __in_bcount(buffer_size)
 469                                 caddr_t bufferp,
 470         __in                    size_t buffer_size);
 471
 472 extern  __checkReturn           efx_rc_t
 473 ef10_nvram_buffer_create(
 474         __in                    efx_nic_t *enp,
 475         __in                    uint16_t partn_type,
 476         __in_bcount(buffer_size)
 477                                 caddr_t bufferp,
 478         __in                    size_t buffer_size);
 479
 480 extern  __checkReturn           efx_rc_t
 481 ef10_nvram_buffer_find_item_start(
 482         __in_bcount(buffer_size)
 483                                 caddr_t bufferp,
 484         __in                    size_t buffer_size,
 485         __out                   uint32_t *startp);
 486
 487 extern  __checkReturn           efx_rc_t
 488 ef10_nvram_buffer_find_end(
 489         __in_bcount(buffer_size)
 490                                 caddr_t bufferp,
 491         __in                    size_t buffer_size,
 492         __in                    uint32_t offset,
 493         __out                   uint32_t *endp);
 494
 495 extern  __checkReturn   __success(return != B_FALSE)    boolean_t
 496 ef10_nvram_buffer_find_item(
 497         __in_bcount(buffer_size)
 498                                 caddr_t bufferp,
 499         __in                    size_t buffer_size,
 500         __in                    uint32_t offset,
 501         __out                   uint32_t *startp,
 502         __out                   uint32_t *lengthp);
 503
 504 extern  __checkReturn           efx_rc_t
 505 ef10_nvram_buffer_get_item(
 506         __in_bcount(buffer_size)
 507                                 caddr_t bufferp,
 508         __in                    size_t buffer_size,
 509         __in                    uint32_t offset,
 510         __in                    uint32_t length,
 511         __out_bcount_part(item_max_size, *lengthp)
 512                                 caddr_t itemp,
 513         __in                    size_t item_max_size,
 514         __out                   uint32_t *lengthp);
 515
 516 extern  __checkReturn           efx_rc_t
 517 ef10_nvram_buffer_insert_item(
 518         __in_bcount(buffer_size)
 519                                 caddr_t bufferp,
 520         __in                    size_t buffer_size,
 521         __in                    uint32_t offset,
 522         __in_bcount(length)     caddr_t keyp,
 523         __in                    uint32_t length,
 524         __out                   uint32_t *lengthp);
 525
 526 extern  __checkReturn           efx_rc_t
 527 ef10_nvram_buffer_delete_item(
 528         __in_bcount(buffer_size)
 529                                 caddr_t bufferp,
 530         __in                    size_t buffer_size,
 531         __in                    uint32_t offset,
 532         __in                    uint32_t length,
 533         __in                    uint32_t end);
 534
 535 extern  __checkReturn           efx_rc_t
 536 ef10_nvram_buffer_finish(
 537         __in_bcount(buffer_size)
 538                                 caddr_t bufferp,
 539         __in                    size_t buffer_size);
 540
 541 #endif  /* EFSYS_OPT_NVRAM */
 542
 543
 544 /* PHY */
 545
 546 typedef struct ef10_link_state_s {
 547         uint32_t                els_adv_cap_mask;
 548         uint32_t                els_lp_cap_mask;
 549         unsigned int            els_fcntl;
 550         efx_link_mode_t         els_link_mode;
 551 #if EFSYS_OPT_LOOPBACK
 552         efx_loopback_type_t     els_loopback;
 553 #endif
 554         boolean_t               els_mac_up;
 555 } ef10_link_state_t;
 556
 557 extern                  void
 558 ef10_phy_link_ev(
 559         __in            efx_nic_t *enp,
 560         __in            efx_qword_t *eqp,
 561         __out           efx_link_mode_t *link_modep);
 562
 563 extern  __checkReturn   efx_rc_t
 564 ef10_phy_get_link(
 565         __in            efx_nic_t *enp,
 566         __out           ef10_link_state_t *elsp);
 567
 568 extern  __checkReturn   efx_rc_t
 569 ef10_phy_power(
 570         __in            efx_nic_t *enp,
 571         __in            boolean_t on);
 572
 573 extern  __checkReturn   efx_rc_t
 574 ef10_phy_reconfigure(
 575         __in            efx_nic_t *enp);
 576
 577 extern  __checkReturn   efx_rc_t
 578 ef10_phy_verify(
 579         __in            efx_nic_t *enp);
 580
 581 extern  __checkReturn   efx_rc_t
 582 ef10_phy_oui_get(
 583         __in            efx_nic_t *enp,
 584         __out           uint32_t *ouip);
 585
 586 #if EFSYS_OPT_PHY_STATS
 587
 588 extern  __checkReturn                   efx_rc_t
 589 ef10_phy_stats_update(
 590         __in                            efx_nic_t *enp,
 591         __in                            efsys_mem_t *esmp,
 592         __inout_ecount(EFX_PHY_NSTATS)  uint32_t *stat);
 593
 594 #endif  /* EFSYS_OPT_PHY_STATS */
 595
 596 #if EFSYS_OPT_BIST
 597
 598 extern  __checkReturn           efx_rc_t
 599 ef10_bist_enable_offline(
 600         __in                    efx_nic_t *enp);
 601
 602 extern  __checkReturn           efx_rc_t
 603 ef10_bist_start(
 604         __in                    efx_nic_t *enp,
 605         __in                    efx_bist_type_t type);
 606
 607 extern  __checkReturn           efx_rc_t
 608 ef10_bist_poll(
 609         __in                    efx_nic_t *enp,
 610         __in                    efx_bist_type_t type,
 611         __out                   efx_bist_result_t *resultp,
 612         __out_opt __drv_when(count > 0, __notnull)
 613         uint32_t        *value_maskp,
 614         __out_ecount_opt(count) __drv_when(count > 0, __notnull)
 615         unsigned long   *valuesp,
 616         __in                    size_t count);
 617
 618 extern                          void
 619 ef10_bist_stop(
 620         __in                    efx_nic_t *enp,
 621         __in                    efx_bist_type_t type);
 622
 623 #endif  /* EFSYS_OPT_BIST */
 624
 625 /* TX */
 626
 627 extern  __checkReturn   efx_rc_t
 628 ef10_tx_init(
 629         __in            efx_nic_t *enp);
 630
 631 extern                  void
 632 ef10_tx_fini(
 633         __in            efx_nic_t *enp);
 634
 635 extern  __checkReturn   efx_rc_t
 636 ef10_tx_qcreate(
 637         __in            efx_nic_t *enp,
 638         __in            unsigned int index,
 639         __in            unsigned int label,
 640         __in            efsys_mem_t *esmp,
 641         __in            size_t ndescs,
 642         __in            uint32_t id,
 643         __in            uint16_t flags,
 644         __in            efx_evq_t *eep,
 645         __in            efx_txq_t *etp,
 646         __out           unsigned int *addedp);
 647
 648 extern          void
 649 ef10_tx_qdestroy(
 650         __in            efx_txq_t *etp);
 651
 652 extern  __checkReturn           efx_rc_t
 653 ef10_tx_qpost(
 654         __in                    efx_txq_t *etp,
 655         __in_ecount(ndescs)     efx_buffer_t *ebp,
 656         __in                    unsigned int ndescs,
 657         __in                    unsigned int completed,
 658         __inout                 unsigned int *addedp);
 659
 660 extern                  void
 661 ef10_tx_qpush(
 662         __in            efx_txq_t *etp,
 663         __in            unsigned int added,
 664         __in            unsigned int pushed);
 665
 666 #if EFSYS_OPT_RX_PACKED_STREAM
 667 extern                  void
 668 ef10_rx_qpush_ps_credits(
 669         __in            efx_rxq_t *erp);
 670
 671 extern  __checkReturn   uint8_t *
 672 ef10_rx_qps_packet_info(
 673         __in            efx_rxq_t *erp,
 674         __in            uint8_t *buffer,
 675         __in            uint32_t buffer_length,
 676         __in            uint32_t current_offset,
 677         __out           uint16_t *lengthp,
 678         __out           uint32_t *next_offsetp,
 679         __out           uint32_t *timestamp);
 680 #endif
 681
 682 extern  __checkReturn   efx_rc_t
 683 ef10_tx_qpace(
 684         __in            efx_txq_t *etp,
 685         __in            unsigned int ns);
 686
 687 extern  __checkReturn   efx_rc_t
 688 ef10_tx_qflush(
 689         __in            efx_txq_t *etp);
 690
 691 extern                  void
 692 ef10_tx_qenable(
 693         __in            efx_txq_t *etp);
 694
 695 extern  __checkReturn   efx_rc_t
 696 ef10_tx_qpio_enable(
 697         __in            efx_txq_t *etp);
 698
 699 extern                  void
 700 ef10_tx_qpio_disable(
 701         __in            efx_txq_t *etp);
 702
 703 extern  __checkReturn   efx_rc_t
 704 ef10_tx_qpio_write(
 705         __in                    efx_txq_t *etp,
 706         __in_ecount(buf_length) uint8_t *buffer,
 707         __in                    size_t buf_length,
 708         __in                    size_t pio_buf_offset);
 709
 710 extern  __checkReturn   efx_rc_t
 711 ef10_tx_qpio_post(
 712         __in                    efx_txq_t *etp,
 713         __in                    size_t pkt_length,
 714         __in                    unsigned int completed,
 715         __inout                 unsigned int *addedp);
 716
 717 extern  __checkReturn   efx_rc_t
 718 ef10_tx_qdesc_post(
 719         __in            efx_txq_t *etp,
 720         __in_ecount(n)  efx_desc_t *ed,
 721         __in            unsigned int n,
 722         __in            unsigned int completed,
 723         __inout         unsigned int *addedp);
 724
 725 extern  void
 726 ef10_tx_qdesc_dma_create(
 727         __in    efx_txq_t *etp,
 728         __in    efsys_dma_addr_t addr,
 729         __in    size_t size,
 730         __in    boolean_t eop,
 731         __out   efx_desc_t *edp);
 732
 733 extern  void
 734 ef10_tx_qdesc_tso_create(
 735         __in    efx_txq_t *etp,
 736         __in    uint16_t ipv4_id,
 737         __in    uint32_t tcp_seq,
 738         __in    uint8_t  tcp_flags,
 739         __out   efx_desc_t *edp);
 740
 741 extern  void
 742 ef10_tx_qdesc_tso2_create(
 743         __in                    efx_txq_t *etp,
 744         __in                    uint16_t ipv4_id,
 745         __in                    uint32_t tcp_seq,
 746         __in                    uint16_t tcp_mss,
 747         __out_ecount(count)     efx_desc_t *edp,
 748         __in                    int count);
 749
 750 extern  void
 751 ef10_tx_qdesc_vlantci_create(
 752         __in    efx_txq_t *etp,
 753         __in    uint16_t vlan_tci,
 754         __out   efx_desc_t *edp);
 755
 756
 757 #if EFSYS_OPT_QSTATS
 758
 759 extern                  void
 760 ef10_tx_qstats_update(
 761         __in                            efx_txq_t *etp,
 762         __inout_ecount(TX_NQSTATS)      efsys_stat_t *stat);
 763
 764 #endif /* EFSYS_OPT_QSTATS */
 765
 766 typedef uint32_t        efx_piobuf_handle_t;
 767
 768 #define EFX_PIOBUF_HANDLE_INVALID       ((efx_piobuf_handle_t)-1)
 769
 770 extern  __checkReturn   efx_rc_t
 771 ef10_nic_pio_alloc(
 772         __inout         efx_nic_t *enp,
 773         __out           uint32_t *bufnump,
 774         __out           efx_piobuf_handle_t *handlep,
 775         __out           uint32_t *blknump,
 776         __out           uint32_t *offsetp,
 777         __out           size_t *sizep);
 778
 779 extern  __checkReturn   efx_rc_t
 780 ef10_nic_pio_free(
 781         __inout         efx_nic_t *enp,
 782         __in            uint32_t bufnum,
 783         __in            uint32_t blknum);
 784
 785 extern  __checkReturn   efx_rc_t
 786 ef10_nic_pio_link(
 787         __inout         efx_nic_t *enp,
 788         __in            uint32_t vi_index,
 789         __in            efx_piobuf_handle_t handle);
 790
 791 extern  __checkReturn   efx_rc_t
 792 ef10_nic_pio_unlink(
 793         __inout         efx_nic_t *enp,
 794         __in            uint32_t vi_index);
 795
 796
 797 /* VPD */
 798
 799 #if EFSYS_OPT_VPD
 800
 801 extern  __checkReturn           efx_rc_t
 802 ef10_vpd_init(
 803         __in                    efx_nic_t *enp);
 804
 805 extern  __checkReturn           efx_rc_t
 806 ef10_vpd_size(
 807         __in                    efx_nic_t *enp,
 808         __out                   size_t *sizep);
 809
 810 extern  __checkReturn           efx_rc_t
 811 ef10_vpd_read(
 812         __in                    efx_nic_t *enp,
 813         __out_bcount(size)      caddr_t data,
 814         __in                    size_t size);
 815
 816 extern  __checkReturn           efx_rc_t
 817 ef10_vpd_verify(
 818         __in                    efx_nic_t *enp,
 819         __in_bcount(size)       caddr_t data,
 820         __in                    size_t size);
 821
 822 extern  __checkReturn           efx_rc_t
 823 ef10_vpd_reinit(
 824         __in                    efx_nic_t *enp,
 825         __in_bcount(size)       caddr_t data,
 826         __in                    size_t size);
 827
 828 extern  __checkReturn           efx_rc_t
 829 ef10_vpd_get(
 830         __in                    efx_nic_t *enp,
 831         __in_bcount(size)       caddr_t data,
 832         __in                    size_t size,
 833         __inout                 efx_vpd_value_t *evvp);
 834
 835 extern  __checkReturn           efx_rc_t
 836 ef10_vpd_set(
 837         __in                    efx_nic_t *enp,
 838         __in_bcount(size)       caddr_t data,
 839         __in                    size_t size,
 840         __in                    efx_vpd_value_t *evvp);
 841
 842 extern  __checkReturn           efx_rc_t
 843 ef10_vpd_next(
 844         __in                    efx_nic_t *enp,
 845         __in_bcount(size)       caddr_t data,
 846         __in                    size_t size,
 847         __out                   efx_vpd_value_t *evvp,
 848         __inout                 unsigned int *contp);
 849
 850 extern __checkReturn            efx_rc_t
 851 ef10_vpd_write(
 852         __in                    efx_nic_t *enp,
 853         __in_bcount(size)       caddr_t data,
 854         __in                    size_t size);
 855
 856 extern                          void
 857 ef10_vpd_fini(
 858         __in                    efx_nic_t *enp);
 859
 860 #endif  /* EFSYS_OPT_VPD */
 861
 862
 863 /* RX */
 864
 865 extern  __checkReturn   efx_rc_t
 866 ef10_rx_init(
 867         __in            efx_nic_t *enp);
 868
 869 #if EFSYS_OPT_RX_SCATTER
 870 extern  __checkReturn   efx_rc_t
 871 ef10_rx_scatter_enable(
 872         __in            efx_nic_t *enp,
 873         __in            unsigned int buf_size);
 874 #endif  /* EFSYS_OPT_RX_SCATTER */
 875
 876
 877 #if EFSYS_OPT_RX_SCALE
 878
 879 extern  __checkReturn   efx_rc_t
 880 ef10_rx_scale_context_alloc(
 881         __in            efx_nic_t *enp,
 882         __in            efx_rx_scale_context_type_t type,
 883         __in            uint32_t num_queues,
 884         __out           uint32_t *rss_contextp);
 885
 886 extern  __checkReturn   efx_rc_t
 887 ef10_rx_scale_context_free(
 888         __in            efx_nic_t *enp,
 889         __in            uint32_t rss_context);
 890
 891 extern  __checkReturn   efx_rc_t
 892 ef10_rx_scale_mode_set(
 893         __in            efx_nic_t *enp,
 894         __in            uint32_t rss_context,
 895         __in            efx_rx_hash_alg_t alg,
 896         __in            efx_rx_hash_type_t type,
 897         __in            boolean_t insert);
 898
 899 extern  __checkReturn   efx_rc_t
 900 ef10_rx_scale_key_set(
 901         __in            efx_nic_t *enp,
 902         __in            uint32_t rss_context,
 903         __in_ecount(n)  uint8_t *key,
 904         __in            size_t n);
 905
 906 extern  __checkReturn   efx_rc_t
 907 ef10_rx_scale_tbl_set(
 908         __in            efx_nic_t *enp,
 909         __in            uint32_t rss_context,
 910         __in_ecount(n)  unsigned int *table,
 911         __in            size_t n);
 912
 913 extern  __checkReturn   uint32_t
 914 ef10_rx_prefix_hash(
 915         __in            efx_nic_t *enp,
 916         __in            efx_rx_hash_alg_t func,
 917         __in            uint8_t *buffer);
 918
 919 #endif /* EFSYS_OPT_RX_SCALE */
 920
 921 extern  __checkReturn   efx_rc_t
 922 ef10_rx_prefix_pktlen(
 923         __in            efx_nic_t *enp,
 924         __in            uint8_t *buffer,
 925         __out           uint16_t *lengthp);
 926
 927 extern                          void
 928 ef10_rx_qpost(
 929         __in                    efx_rxq_t *erp,
 930         __in_ecount(ndescs)     efsys_dma_addr_t *addrp,
 931         __in                    size_t size,
 932         __in                    unsigned int ndescs,
 933         __in                    unsigned int completed,
 934         __in                    unsigned int added);
 935
 936 extern                  void
 937 ef10_rx_qpush(
 938         __in            efx_rxq_t *erp,
 939         __in            unsigned int added,
 940         __inout         unsigned int *pushedp);
 941
 942 extern  __checkReturn   efx_rc_t
 943 ef10_rx_qflush(
 944         __in            efx_rxq_t *erp);
 945
 946 extern          void
 947 ef10_rx_qenable(
 948         __in            efx_rxq_t *erp);
 949
 950 extern  __checkReturn   efx_rc_t
 951 ef10_rx_qcreate(
 952         __in            efx_nic_t *enp,
 953         __in            unsigned int index,
 954         __in            unsigned int label,
 955         __in            efx_rxq_type_t type,
 956         __in            uint32_t type_data,
 957         __in            efsys_mem_t *esmp,
 958         __in            size_t ndescs,
 959         __in            uint32_t id,
 960         __in            unsigned int flags,
 961         __in            efx_evq_t *eep,
 962         __in            efx_rxq_t *erp);
 963
 964 extern                  void
 965 ef10_rx_qdestroy(
 966         __in            efx_rxq_t *erp);
 967
 968 extern                  void
 969 ef10_rx_fini(
 970         __in            efx_nic_t *enp);
 971
 972 #if EFSYS_OPT_FILTER
 973
 974 typedef struct ef10_filter_handle_s {
 975         uint32_t        efh_lo;
 976         uint32_t        efh_hi;
 977 } ef10_filter_handle_t;
 978
 979 typedef struct ef10_filter_entry_s {
 980         uintptr_t efe_spec; /* pointer to filter spec plus busy bit */
 981         ef10_filter_handle_t efe_handle;
 982 } ef10_filter_entry_t;
 983
 984 /*
 985  * BUSY flag indicates that an update is in progress.
 986  * AUTO_OLD flag is used to mark and sweep MAC packet filters.
 987  */
 988 #define EFX_EF10_FILTER_FLAG_BUSY       1U
 989 #define EFX_EF10_FILTER_FLAG_AUTO_OLD   2U
 990 #define EFX_EF10_FILTER_FLAGS           3U
 991
 992 /*
 993  * Size of the hash table used by the driver. Doesn't need to be the
 994  * same size as the hardware's table.
 995  */
 996 #define EFX_EF10_FILTER_TBL_ROWS 8192
 997
 998 /* Only need to allow for one directed and one unknown unicast filter */
 999 #define EFX_EF10_FILTER_UNICAST_FILTERS_MAX     2
1000
1001 /* Allow for the broadcast address to be added to the multicast list */
1002 #define EFX_EF10_FILTER_MULTICAST_FILTERS_MAX   (EFX_MAC_MULTICAST_LIST_MAX + 1)
1003
1004 /*
1005  * For encapsulated packets, there is one filter each for each combination of
1006  * IPv4 or IPv6 outer frame, VXLAN, GENEVE or NVGRE packet type, and unicast or
1007  * multicast inner frames.
1008  */
1009 #define EFX_EF10_FILTER_ENCAP_FILTERS_MAX       12
1010
1011 typedef struct ef10_filter_table_s {
1012         ef10_filter_entry_t     eft_entry[EFX_EF10_FILTER_TBL_ROWS];
1013         efx_rxq_t               *eft_default_rxq;
1014         boolean_t               eft_using_rss;
1015         uint32_t                eft_unicst_filter_indexes[
1016             EFX_EF10_FILTER_UNICAST_FILTERS_MAX];
1017         uint32_t                eft_unicst_filter_count;
1018         uint32_t                eft_mulcst_filter_indexes[
1019             EFX_EF10_FILTER_MULTICAST_FILTERS_MAX];
1020         uint32_t                eft_mulcst_filter_count;
1021         boolean_t               eft_using_all_mulcst;
1022         uint32_t                eft_encap_filter_indexes[
1023             EFX_EF10_FILTER_ENCAP_FILTERS_MAX];
1024         uint32_t                eft_encap_filter_count;
1025 } ef10_filter_table_t;
1026
1027         __checkReturn   efx_rc_t
1028 ef10_filter_init(
1029         __in            efx_nic_t *enp);
1030
1031                         void
1032 ef10_filter_fini(
1033         __in            efx_nic_t *enp);
1034
1035         __checkReturn   efx_rc_t
1036 ef10_filter_restore(
1037         __in            efx_nic_t *enp);
1038
1039         __checkReturn   efx_rc_t
1040 ef10_filter_add(
1041         __in            efx_nic_t *enp,
1042         __inout         efx_filter_spec_t *spec,
1043         __in            boolean_t may_replace);
1044
1045         __checkReturn   efx_rc_t
1046 ef10_filter_delete(
1047         __in            efx_nic_t *enp,
1048         __inout         efx_filter_spec_t *spec);
1049
1050 extern  __checkReturn   efx_rc_t
1051 ef10_filter_supported_filters(
1052         __in                            efx_nic_t *enp,
1053         __out_ecount(buffer_length)     uint32_t *buffer,
1054         __in                            size_t buffer_length,
1055         __out                           size_t *list_lengthp);
1056
1057 extern  __checkReturn   efx_rc_t
1058 ef10_filter_reconfigure(
1059         __in                            efx_nic_t *enp,
1060         __in_ecount(6)                  uint8_t const *mac_addr,
1061         __in                            boolean_t all_unicst,
1062         __in                            boolean_t mulcst,
1063         __in                            boolean_t all_mulcst,
1064         __in                            boolean_t brdcst,
1065         __in_ecount(6*count)            uint8_t const *addrs,
1066         __in                            uint32_t count);
1067
1068 extern          void
1069 ef10_filter_get_default_rxq(
1070         __in            efx_nic_t *enp,
1071         __out           efx_rxq_t **erpp,
1072         __out           boolean_t *using_rss);
1073
1074 extern          void
1075 ef10_filter_default_rxq_set(
1076         __in            efx_nic_t *enp,
1077         __in            efx_rxq_t *erp,
1078         __in            boolean_t using_rss);
1079
1080 extern          void
1081 ef10_filter_default_rxq_clear(
1082         __in            efx_nic_t *enp);
1083
1084
1085 #endif /* EFSYS_OPT_FILTER */
1086
1087 extern  __checkReturn                   efx_rc_t
1088 efx_mcdi_get_function_info(
1089         __in                            efx_nic_t *enp,
1090         __out                           uint32_t *pfp,
1091         __out_opt                       uint32_t *vfp);
1092
1093 extern  __checkReturn           efx_rc_t
1094 efx_mcdi_privilege_mask(
1095         __in                    efx_nic_t *enp,
1096         __in                    uint32_t pf,
1097         __in                    uint32_t vf,
1098         __out                   uint32_t *maskp);
1099
1100 extern  __checkReturn   efx_rc_t
1101 efx_mcdi_get_port_assignment(
1102         __in            efx_nic_t *enp,
1103         __out           uint32_t *portp);
1104
1105 extern  __checkReturn   efx_rc_t
1106 efx_mcdi_get_port_modes(
1107         __in            efx_nic_t *enp,
1108         __out           uint32_t *modesp,
1109         __out_opt       uint32_t *current_modep);
1110
1111 extern  __checkReturn   efx_rc_t
1112 ef10_nic_get_port_mode_bandwidth(
1113         __in            uint32_t port_mode,
1114         __out           uint32_t *bandwidth_mbpsp);
1115
1116 extern  __checkReturn   efx_rc_t
1117 efx_mcdi_get_mac_address_pf(
1118         __in                    efx_nic_t *enp,
1119         __out_ecount_opt(6)     uint8_t mac_addrp[6]);
1120
1121 extern  __checkReturn   efx_rc_t
1122 efx_mcdi_get_mac_address_vf(
1123         __in                    efx_nic_t *enp,
1124         __out_ecount_opt(6)     uint8_t mac_addrp[6]);
1125
1126 extern  __checkReturn   efx_rc_t
1127 efx_mcdi_get_clock(
1128         __in            efx_nic_t *enp,
1129         __out           uint32_t *sys_freqp,
1130         __out           uint32_t *dpcpu_freqp);
1131
1132
1133 extern  __checkReturn   efx_rc_t
1134 efx_mcdi_get_vector_cfg(
1135         __in            efx_nic_t *enp,
1136         __out_opt       uint32_t *vec_basep,
1137         __out_opt       uint32_t *pf_nvecp,
1138         __out_opt       uint32_t *vf_nvecp);
1139
1140 extern  __checkReturn   efx_rc_t
1141 ef10_get_datapath_caps(
1142         __in            efx_nic_t *enp);
1143
1144 extern  __checkReturn           efx_rc_t
1145 ef10_get_privilege_mask(
1146         __in                    efx_nic_t *enp,
1147         __out                   uint32_t *maskp);
1148
1149 extern  __checkReturn   efx_rc_t
1150 ef10_external_port_mapping(
1151         __in            efx_nic_t *enp,
1152         __in            uint32_t port,
1153         __out           uint8_t *external_portp);
1154
1155 #if EFSYS_OPT_RX_PACKED_STREAM
1156
1157 /* Data space per credit in packed stream mode */
1158 #define EFX_RX_PACKED_STREAM_MEM_PER_CREDIT (1 << 16)
1159
1160 /*
1161  * Received packets are always aligned at this boundary. Also there always
1162  * exists a gap of this size between packets.
1163  * (see SF-112241-TC, 4.5)
1164  */
1165 #define EFX_RX_PACKED_STREAM_ALIGNMENT 64
1166
1167 /*
1168  * Size of a pseudo-header prepended to received packets
1169  * in packed stream mode
1170  */
1171 #define EFX_RX_PACKED_STREAM_RX_PREFIX_SIZE 8
1172
1173 /* Minimum space for packet in packed stream mode */
1174 #define EFX_RX_PACKED_STREAM_MIN_PACKET_SPACE                \
1175         P2ROUNDUP(EFX_RX_PACKED_STREAM_RX_PREFIX_SIZE +      \
1176             EFX_MAC_PDU_MIN +                                \
1177             EFX_RX_PACKED_STREAM_ALIGNMENT,                  \
1178             EFX_RX_PACKED_STREAM_ALIGNMENT)
1179
1180 /* Maximum number of credits */
1181 #define EFX_RX_PACKED_STREAM_MAX_CREDITS 127
1182
1183 #endif /* EFSYS_OPT_RX_PACKED_STREAM */
1184
1185 #ifdef  __cplusplus
1186 }
1187 #endif
1188
1189 #endif  /* _SYS_EF10_IMPL_H */