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