1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2018, Joyent, Inc. 25 * Copyright 2020 RackTop Systems, Inc. 26 * Copyright 2023 Oxide Computer Company 27 */ 28 29 #ifndef _SYS_MAC_PROVIDER_H 30 #define _SYS_MAC_PROVIDER_H 31 32 #include <sys/types.h> 33 #include <sys/ddi.h> 34 #include <sys/sunddi.h> 35 #include <sys/stream.h> 36 #include <sys/mkdev.h> 37 #include <sys/mac.h> 38 #include <sys/mac_flow.h> 39 40 /* 41 * MAC Provider Interface 42 */ 43 44 #ifdef __cplusplus 45 extern "C" { 46 #endif 47 48 /* 49 * MAC version identifiers. Drivers compiled against the stable V1 version 50 * of the API should register with MAC_VERSION_V1. ON drivers should use 51 * MAC_VERSION. This is used by mac_alloc() mac_register() to 52 * verify that incompatible drivers don't register. 53 */ 54 #define MAC_VERSION_V1 0x1 55 #define MAC_VERSION MAC_VERSION_V1 56 57 /* 58 * Possible values for ETHER_STAT_XCVR_INUSE statistic. 59 */ 60 61 #define XCVR_UNDEFINED 0 62 #define XCVR_NONE 1 63 #define XCVR_10 2 64 #define XCVR_100T4 3 65 #define XCVR_100X 4 66 #define XCVR_100T2 5 67 #define XCVR_1000X 6 68 #define XCVR_1000T 7 69 70 #ifdef _KERNEL 71 72 /* 73 * Definitions for MAC Drivers Capabilities 74 */ 75 /* 76 * MAC layer capabilities. These capabilities are handled by the drivers' 77 * mc_capab_get() callbacks. Some capabilities require the driver to fill 78 * in a given data structure, and others are simply boolean capabilities. 79 * Note that capability values must be powers of 2 so that consumers and 80 * providers of this interface can keep track of which capabilities they 81 * care about by keeping a bitfield of these things around somewhere. 82 */ 83 typedef enum { 84 /* 85 * Public Capabilities (MAC_VERSION_V1) 86 */ 87 MAC_CAPAB_HCKSUM = 0x00000001, /* data is a uint32_t */ 88 MAC_CAPAB_LSO = 0x00000008, /* data is mac_capab_lso_t */ 89 90 /* 91 * Reserved capabilities, do not use 92 */ 93 MAC_CAPAB_RESERVED1 = 0x00000002, 94 MAC_CAPAB_RESERVED2 = 0x00000004, 95 96 /* 97 * Private driver capabilities 98 */ 99 MAC_CAPAB_RINGS = 0x00000010, /* data is mac_capab_rings_t */ 100 MAC_CAPAB_SHARES = 0x00000020, /* data is mac_capab_share_t */ 101 MAC_CAPAB_MULTIFACTADDR = 0x00000040, /* mac_data_multifactaddr_t */ 102 103 /* 104 * Private driver capabilities for use by the GLDv3 framework only 105 */ 106 MAC_CAPAB_VNIC = 0x00010000, /* data is mac_capab_vnic_t */ 107 MAC_CAPAB_ANCHOR_VNIC = 0x00020000, /* boolean only, no data */ 108 MAC_CAPAB_AGGR = 0x00040000, /* data is mac_capab_aggr_t */ 109 MAC_CAPAB_NO_NATIVEVLAN = 0x00080000, /* boolean only, no data */ 110 MAC_CAPAB_NO_ZCOPY = 0x00100000, /* boolean only, no data */ 111 MAC_CAPAB_LEGACY = 0x00200000, /* data is mac_capab_legacy_t */ 112 MAC_CAPAB_VRRP = 0x00400000, /* data is mac_capab_vrrp_t */ 113 MAC_CAPAB_OVERLAY = 0x00800000, /* boolean only, no data */ 114 MAC_CAPAB_TRANSCEIVER = 0x01000000, /* mac_capab_transceiver_t */ 115 MAC_CAPAB_LED = 0x02000000 /* data is mac_capab_led_t */ 116 } mac_capab_t; 117 118 /* 119 * LSO capability 120 */ 121 typedef struct lso_basic_tcp_ipv4_s { 122 t_uscalar_t lso_max; /* maximum payload */ 123 } lso_basic_tcp_ipv4_t; 124 125 typedef struct lso_basic_tcp_ipv6_s { 126 t_uscalar_t lso_max; /* maximum payload */ 127 } lso_basic_tcp_ipv6_t; 128 129 /* 130 * Currently supported flags for LSO. 131 */ 132 #define LSO_TX_BASIC_TCP_IPV4 0x01 /* TCPv4 LSO capability */ 133 #define LSO_TX_BASIC_TCP_IPV6 0x02 /* TCPv6 LSO capability */ 134 135 /* 136 * Future LSO capabilities can be added at the end of the mac_capab_lso_t. 137 * When such capability is added to the GLDv3 framework, the size of the 138 * mac_capab_lso_t it allocates and passes to the drivers increases. Older 139 * drivers wil access only the (upper) sections of that structure, that is the 140 * sections carrying the capabilities they understand. This ensures the 141 * interface can be safely extended in a binary compatible way. 142 */ 143 typedef struct mac_capab_lso_s { 144 t_uscalar_t lso_flags; 145 lso_basic_tcp_ipv4_t lso_basic_tcp_ipv4; 146 lso_basic_tcp_ipv6_t lso_basic_tcp_ipv6; 147 /* Add future lso capabilities here */ 148 } mac_capab_lso_t; 149 150 /* 151 * Multiple Factory MAC Addresses Capability 152 */ 153 typedef struct mac_capab_multifactaddr_s { 154 /* 155 * Number of factory addresses 156 */ 157 uint_t mcm_naddr; 158 159 /* 160 * Callbacks to query all the factory addresses. 161 */ 162 void (*mcm_getaddr)(void *, uint_t, uint8_t *); 163 } mac_capab_multifactaddr_t; 164 165 /* 166 * Info and callbacks of legacy devices. 167 */ 168 typedef struct mac_capab_legacy_s { 169 /* 170 * Notifications that the legacy device does not support. 171 */ 172 uint32_t ml_unsup_note; 173 /* 174 * dev_t of the legacy device; can be held to force attach. 175 */ 176 dev_t ml_dev; 177 boolean_t (*ml_active_set)(void *); 178 void (*ml_active_clear)(void *); 179 int (*ml_fastpath_disable)(void *); 180 void (*ml_fastpath_enable)(void *); 181 } mac_capab_legacy_t; 182 183 typedef struct __mac_prop_info_handle *mac_prop_info_handle_t; 184 185 /* 186 * MAC driver entry point types. 187 */ 188 typedef int (*mac_getstat_t)(void *, uint_t, uint64_t *); 189 typedef int (*mac_start_t)(void *); 190 typedef void (*mac_stop_t)(void *); 191 typedef int (*mac_setpromisc_t)(void *, boolean_t); 192 typedef int (*mac_multicst_t)(void *, boolean_t, const uint8_t *); 193 typedef int (*mac_unicst_t)(void *, const uint8_t *); 194 typedef void (*mac_ioctl_t)(void *, queue_t *, mblk_t *); 195 typedef void (*mac_resources_t)(void *); 196 typedef mblk_t *(*mac_tx_t)(void *, mblk_t *); 197 typedef boolean_t (*mac_getcapab_t)(void *, mac_capab_t, void *); 198 typedef int (*mac_open_t)(void *); 199 typedef void (*mac_close_t)(void *); 200 typedef int (*mac_set_prop_t)(void *, const char *, mac_prop_id_t, 201 uint_t, const void *); 202 typedef int (*mac_get_prop_t)(void *, const char *, mac_prop_id_t, 203 uint_t, void *); 204 typedef void (*mac_prop_info_t)(void *, const char *, mac_prop_id_t, 205 mac_prop_info_handle_t); 206 207 /* 208 * Driver callbacks. The following capabilities are optional, and if 209 * implemented by the driver, must have a corresponding MC_ flag set 210 * in the mc_callbacks field. 211 * 212 * Any future additions to this list must also be accompanied by an 213 * associated mc_callbacks flag so that the framework can grow without 214 * affecting the binary compatibility of the interface. 215 */ 216 typedef struct mac_callbacks_s { 217 uint_t mc_callbacks; /* Denotes which callbacks are set */ 218 mac_getstat_t mc_getstat; /* Get the value of a statistic */ 219 mac_start_t mc_start; /* Start the device */ 220 mac_stop_t mc_stop; /* Stop the device */ 221 mac_setpromisc_t mc_setpromisc; /* Enable or disable promiscuous mode */ 222 mac_multicst_t mc_multicst; /* Enable or disable a multicast addr */ 223 mac_unicst_t mc_unicst; /* Set the unicast MAC address */ 224 mac_tx_t mc_tx; /* Transmit a packet */ 225 void *mc_reserved; /* Reserved, do not use */ 226 mac_ioctl_t mc_ioctl; /* Process an unknown ioctl */ 227 mac_getcapab_t mc_getcapab; /* Get capability information */ 228 mac_open_t mc_open; /* Open the device */ 229 mac_close_t mc_close; /* Close the device */ 230 mac_set_prop_t mc_setprop; 231 mac_get_prop_t mc_getprop; 232 mac_prop_info_t mc_propinfo; 233 } mac_callbacks_t; 234 235 /* 236 * Flags for mc_callbacks. Requiring drivers to set the flags associated 237 * with optional callbacks initialized in the structure allows the mac 238 * module to add optional callbacks in the future without requiring drivers 239 * to recompile. 240 */ 241 #define MC_RESERVED 0x0001 242 #define MC_IOCTL 0x0002 243 #define MC_GETCAPAB 0x0004 244 #define MC_OPEN 0x0008 245 #define MC_CLOSE 0x0010 246 #define MC_SETPROP 0x0020 247 #define MC_GETPROP 0x0040 248 #define MC_PROPINFO 0x0080 249 #define MC_PROPERTIES (MC_SETPROP | MC_GETPROP | MC_PROPINFO) 250 251 /* 252 * Virtualization Capabilities 253 */ 254 255 /* 256 * The type of ring classification. This is used by MAC to determine 257 * what, if any, processing it has to do upon receiving traffic on a 258 * particular Rx ring. 259 * 260 * MAC_NO_CLASSIFIER 261 * 262 * No classification has been set. No traffic should cross an Rx 263 * ring in this state. 264 * 265 * MAC_SW_CLASSIFIER 266 * 267 * The driver delivers traffic for multiple clients to this ring. 268 * All traffic must be software classified by MAC to guarantee 269 * delivery to the correct client. This classification type may 270 * be chosen for several reasons. 271 * 272 * o The driver provides only one group and there are multiple 273 * clients using the MAC. 274 * 275 * o The driver provides some hardware filtering but not enough 276 * to fully classify the traffic. E.g., a VLAN VNIC requires L2 277 * unicast address filtering as well as VLAN filtering, but 278 * some drivers may only support the former. 279 * 280 * o The ring belongs to the default group. The default group 281 * acts as a spillover for all clients that can't reserve an 282 * exclusive group. It also handles multicast traffic for all 283 * clients. For these reasons, the default group's rings are 284 * always software classified. 285 * 286 * MAC_HW_CLASSIFIER 287 * 288 * The driver delivers traffic for a single MAC client across 289 * this ring. With this guarantee, MAC can simply pass the 290 * traffic up the stack or even allow polling of the ring. 291 * 292 * MAC_PASSTHRU_CLASSIFIER 293 * 294 * The ring is in "passthru" mode. In this mode we bypass all of 295 * the typical MAC processing and pass the traffic directly to 296 * the mr_pt_fn callback, see mac_rx_common(). This is used in 297 * cases where there is another module acting as MAC provider on 298 * behalf of the driver. E.g., link aggregations use this mode to 299 * take full control of the port's rings; allowing it to enforce 300 * LACP protocols and aggregate rings across discrete drivers. 301 */ 302 typedef enum { 303 MAC_NO_CLASSIFIER = 0, 304 MAC_SW_CLASSIFIER, 305 MAC_HW_CLASSIFIER, 306 MAC_PASSTHRU_CLASSIFIER 307 } mac_classify_type_t; 308 309 typedef void (*mac_rx_func_t)(void *, mac_resource_handle_t, mblk_t *, 310 boolean_t); 311 312 /* 313 * The virtualization level conveys the extent of the NIC hardware assistance 314 * for traffic steering employed for virtualization: 315 * 316 * MAC_VIRT_NONE: No assist for v12n. 317 * 318 * MAC_VIRT_LEVEL1: Multiple Rx rings with MAC address level 319 * classification between groups of rings. 320 * Requires the support of the MAC_CAPAB_RINGS 321 * capability. 322 * 323 * MAC_VIRT_HIO: Hybrid I/O capable MAC. Require the support 324 * of the MAC_CAPAB_SHARES capability. 325 */ 326 #define MAC_VIRT_NONE 0x0 327 #define MAC_VIRT_LEVEL1 0x1 328 #define MAC_VIRT_HIO 0x2 329 330 typedef enum { 331 MAC_RING_TYPE_RX = 1, /* Receive ring */ 332 MAC_RING_TYPE_TX /* Transmit ring */ 333 } mac_ring_type_t; 334 335 /* 336 * The value VLAN_ID_NONE (VID 0) means a client does not have 337 * membership to any VLAN. However, this statement is true for both 338 * untagged packets and priority tagged packets leading to confusion 339 * over what semantic is intended. To the provider, VID 0 is a valid 340 * VID when priority tagging is in play. To MAC and everything above 341 * VLAN_ID_NONE almost universally implies untagged traffic. Thus, we 342 * convert VLAN_ID_NONE to a sentinel value (MAC_VLAN_UNTAGGED) at the 343 * border between MAC and MAC provider. This informs the provider that 344 * the client is interested in untagged traffic and the provider 345 * should set any relevant bits to receive such traffic. 346 * 347 * Currently, the API between MAC and the provider passes the VID as a 348 * unit16_t. In the future this could actually be the entire TCI mask 349 * (PCP, DEI, and VID). This current scheme is safe in that potential 350 * future world as well; as 0xFFFF is not a valid TCI (the 0xFFF VID 351 * is reserved and never transmitted across networks). 352 */ 353 #define MAC_VLAN_UNTAGGED UINT16_MAX 354 #define MAC_VLAN_UNTAGGED_VID(vid) \ 355 (((vid) == VLAN_ID_NONE) ? MAC_VLAN_UNTAGGED : (vid)) 356 357 /* 358 * Grouping type of a ring group 359 * 360 * MAC_GROUP_TYPE_STATIC: The ring group can not be re-grouped. 361 * MAC_GROUP_TYPE_DYNAMIC: The ring group support dynamic re-grouping 362 */ 363 typedef enum { 364 MAC_GROUP_TYPE_STATIC = 1, /* Static ring group */ 365 MAC_GROUP_TYPE_DYNAMIC /* Dynamic ring group */ 366 } mac_group_type_t; 367 368 typedef struct __mac_ring_driver *mac_ring_driver_t; 369 typedef struct __mac_group_driver *mac_group_driver_t; 370 371 typedef struct mac_ring_info_s mac_ring_info_t; 372 typedef struct mac_group_info_s mac_group_info_t; 373 374 typedef void (*mac_get_ring_t)(void *, mac_ring_type_t, const int, const int, 375 mac_ring_info_t *, mac_ring_handle_t); 376 typedef void (*mac_get_group_t)(void *, mac_ring_type_t, const int, 377 mac_group_info_t *, mac_group_handle_t); 378 379 typedef void (*mac_group_add_ring_t)(mac_group_driver_t, 380 mac_ring_driver_t, mac_ring_type_t); 381 typedef void (*mac_group_rem_ring_t)(mac_group_driver_t, 382 mac_ring_driver_t, mac_ring_type_t); 383 384 /* 385 * Multiple Rings Capability 386 */ 387 typedef struct mac_capab_rings_s { 388 mac_ring_type_t mr_type; /* Ring type: Rx vs Tx */ 389 mac_group_type_t mr_group_type; /* Dynamic vs static grouping */ 390 uint_t mr_rnum; /* Number of rings */ 391 uint_t mr_gnum; /* Number of ring groups */ 392 mac_get_ring_t mr_rget; /* Get ring from driver */ 393 mac_get_group_t mr_gget; /* Get ring group from driver */ 394 mac_group_add_ring_t mr_gaddring; /* Add ring into a group */ 395 mac_group_rem_ring_t mr_gremring; /* Remove ring from a group */ 396 } mac_capab_rings_t; 397 398 /* 399 * Common ring functions and driver interfaces 400 */ 401 typedef int (*mac_ring_start_t)(mac_ring_driver_t, uint64_t); 402 typedef void (*mac_ring_stop_t)(mac_ring_driver_t); 403 404 typedef mblk_t *(*mac_ring_send_t)(void *, mblk_t *); 405 typedef mblk_t *(*mac_ring_poll_t)(void *, int); 406 407 typedef int (*mac_ring_stat_t)(mac_ring_driver_t, uint_t, uint64_t *); 408 409 typedef struct mac_ring_info_s { 410 mac_ring_driver_t mri_driver; 411 mac_ring_start_t mri_start; 412 mac_ring_stop_t mri_stop; 413 mac_intr_t mri_intr; 414 union { 415 mac_ring_send_t send; 416 mac_ring_poll_t poll; 417 } mrfunion; 418 mac_ring_stat_t mri_stat; 419 420 /* 421 * mri_flags will have some bits set to indicate some special 422 * property/feature of a ring like serialization needed for a 423 * Tx ring or packets should always need enqueuing on Rx side, 424 * etc. 425 */ 426 uint_t mri_flags; 427 } mac_ring_info_s; 428 429 #define mri_tx mrfunion.send 430 #define mri_poll mrfunion.poll 431 432 /* 433 * #defines for mri_flags. The flags are temporary flags that are provided 434 * only to workaround issues in specific drivers, and they will be 435 * removed in the future. 436 * 437 * These are consumed only by sun4v and neptune (nxge). 438 */ 439 #define MAC_RING_TX_SERIALIZE 0x1 440 #define MAC_RING_RX_ENQUEUE 0x2 441 442 typedef int (*mac_group_start_t)(mac_group_driver_t); 443 typedef void (*mac_group_stop_t)(mac_group_driver_t); 444 typedef int (*mac_add_mac_addr_t)(void *, const uint8_t *); 445 typedef int (*mac_rem_mac_addr_t)(void *, const uint8_t *); 446 typedef int (*mac_add_vlan_filter_t)(mac_group_driver_t, uint16_t); 447 typedef int (*mac_rem_vlan_filter_t)(mac_group_driver_t, uint16_t); 448 449 struct mac_group_info_s { 450 mac_group_driver_t mgi_driver; /* Driver reference */ 451 mac_group_start_t mgi_start; /* Start the group */ 452 mac_group_stop_t mgi_stop; /* Stop the group */ 453 uint_t mgi_count; /* Count of rings */ 454 mac_intr_t mgi_intr; /* Optional per-group intr */ 455 456 /* Only used for Rx groups */ 457 mac_add_mac_addr_t mgi_addmac; /* Add a MAC address */ 458 mac_rem_mac_addr_t mgi_remmac; /* Remove a MAC address */ 459 mac_add_vlan_filter_t mgi_addvlan; /* Add a VLAN filter */ 460 mac_rem_vlan_filter_t mgi_remvlan; /* Remove a VLAN filter */ 461 }; 462 463 /* 464 * Share management functions. 465 */ 466 typedef uint64_t mac_share_handle_t; 467 468 /* 469 * Allocate and free a share. Returns ENOSPC if all shares have been 470 * previously allocated. 471 */ 472 typedef int (*mac_alloc_share_t)(void *, mac_share_handle_t *); 473 typedef void (*mac_free_share_t)(mac_share_handle_t); 474 475 /* 476 * Bind and unbind a share. Binding a share allows a domain 477 * to have direct access to the groups and rings associated with 478 * that share. 479 */ 480 typedef int (*mac_bind_share_t)(mac_share_handle_t, uint64_t, uint64_t *); 481 typedef void (*mac_unbind_share_t)(mac_share_handle_t); 482 483 /* 484 * Return information on about a share. 485 */ 486 typedef void (*mac_share_query_t)(mac_share_handle_t, mac_ring_type_t, 487 mac_ring_handle_t *, uint_t *); 488 489 /* 490 * Basic idea, bind previously created ring groups to shares 491 * for them to be exported (or shared) by another domain. 492 * These interfaces bind/unbind the ring group to a share. 493 * The groups and their rings will be shared with the guest 494 * as soon as the share is bound. 495 */ 496 typedef int (*mac_share_add_group_t)(mac_share_handle_t, 497 mac_group_driver_t); 498 typedef int (*mac_share_rem_group_t)(mac_share_handle_t, 499 mac_group_driver_t); 500 501 typedef struct mac_capab_share_s { 502 uint_t ms_snum; /* Number of shares (vr's) */ 503 void *ms_handle; /* Handle to driver. */ 504 mac_alloc_share_t ms_salloc; /* Get a share from driver. */ 505 mac_free_share_t ms_sfree; /* Return a share to driver. */ 506 mac_share_add_group_t ms_sadd; /* Add a group to the share. */ 507 mac_share_rem_group_t ms_sremove; /* Remove group from share. */ 508 mac_share_query_t ms_squery; /* Query share constraints */ 509 mac_bind_share_t ms_sbind; /* Bind a share */ 510 mac_unbind_share_t ms_sunbind; /* Unbind a share */ 511 } mac_capab_share_t; 512 513 typedef struct mac_capab_vrrp_s { 514 /* IPv6 or IPv4? */ 515 int mcv_af; 516 } mac_capab_vrrp_t; 517 518 /* 519 * Transceiver capability 520 */ 521 typedef struct mac_transceiver_info mac_transceiver_info_t; 522 523 typedef struct mac_capab_transceiver { 524 uint_t mct_flags; 525 uint_t mct_ntransceivers; 526 int (*mct_info)(void *, uint_t, mac_transceiver_info_t *); 527 int (*mct_read)(void *, uint_t, uint_t, void *, size_t, off_t, 528 size_t *); 529 } mac_capab_transceiver_t; 530 531 /* 532 * LED capability 533 */ 534 typedef struct mac_capab_led { 535 uint_t mcl_flags; 536 mac_led_mode_t mcl_modes; 537 int (*mcl_set)(void *, mac_led_mode_t, uint_t); 538 } mac_capab_led_t; 539 540 /* 541 * MAC registration interface 542 */ 543 typedef struct mac_register_s { 544 uint_t m_version; /* set by mac_alloc() */ 545 const char *m_type_ident; 546 void *m_driver; /* Driver private data */ 547 dev_info_t *m_dip; 548 uint_t m_instance; 549 uint8_t *m_src_addr; 550 uint8_t *m_dst_addr; 551 mac_callbacks_t *m_callbacks; 552 uint_t m_min_sdu; 553 uint_t m_max_sdu; 554 void *m_pdata; 555 size_t m_pdata_size; 556 char **m_priv_props; 557 uint32_t m_margin; 558 uint32_t m_v12n; /* Virtualization level */ 559 uint_t m_multicast_sdu; 560 } mac_register_t; 561 562 /* 563 * Driver interface functions. 564 */ 565 extern mac_protect_t *mac_protect_get(mac_handle_t); 566 extern void mac_sdu_get(mac_handle_t, uint_t *, uint_t *); 567 extern void mac_sdu_get2(mac_handle_t, uint_t *, uint_t *, 568 uint_t *); 569 extern int mac_maxsdu_update(mac_handle_t, uint_t); 570 extern int mac_maxsdu_update2(mac_handle_t, uint_t, 571 uint_t); 572 573 extern mac_register_t *mac_alloc(uint_t); 574 extern void mac_free(mac_register_t *); 575 extern int mac_register(mac_register_t *, mac_handle_t *); 576 extern int mac_disable_nowait(mac_handle_t); 577 extern int mac_disable(mac_handle_t); 578 extern int mac_unregister(mac_handle_t); 579 extern void mac_rx(mac_handle_t, mac_resource_handle_t, 580 mblk_t *); 581 extern void mac_rx_ring(mac_handle_t, mac_ring_handle_t, 582 mblk_t *, uint64_t); 583 extern void mac_link_update(mac_handle_t, link_state_t); 584 extern void mac_link_redo(mac_handle_t, link_state_t); 585 extern void mac_unicst_update(mac_handle_t, 586 const uint8_t *); 587 extern void mac_dst_update(mac_handle_t, const uint8_t *); 588 extern void mac_tx_update(mac_handle_t); 589 extern void mac_tx_ring_update(mac_handle_t, 590 mac_ring_handle_t); 591 extern void mac_capab_update(mac_handle_t); 592 extern int mac_pdata_update(mac_handle_t, void *, 593 size_t); 594 extern void mac_multicast_refresh(mac_handle_t, 595 mac_multicst_t, void *, boolean_t); 596 extern void mac_unicst_refresh(mac_handle_t, mac_unicst_t, 597 void *); 598 extern void mac_promisc_refresh(mac_handle_t, 599 mac_setpromisc_t, void *); 600 extern boolean_t mac_margin_update(mac_handle_t, uint32_t); 601 extern void mac_margin_get(mac_handle_t, uint32_t *); 602 extern int mac_margin_remove(mac_handle_t, uint32_t); 603 extern int mac_margin_add(mac_handle_t, uint32_t *, 604 boolean_t); 605 extern void mac_init_ops(struct dev_ops *, const char *); 606 extern void mac_fini_ops(struct dev_ops *); 607 extern int mac_devt_to_instance(dev_t); 608 extern int mac_getinfo(dev_info_t *, ddi_info_cmd_t, 609 void *, void **); 610 extern minor_t mac_private_minor(void); 611 extern void mac_ring_intr_set(mac_ring_handle_t, 612 ddi_intr_handle_t); 613 614 615 extern mactype_register_t *mactype_alloc(uint_t); 616 extern void mactype_free(mactype_register_t *); 617 extern int mactype_register(mactype_register_t *); 618 extern int mactype_unregister(const char *); 619 620 extern boolean_t mac_unicst_verify(mac_handle_t, 621 const uint8_t *, uint_t); 622 623 extern int mac_group_add_ring(mac_group_handle_t, int); 624 extern void mac_group_rem_ring(mac_group_handle_t, 625 mac_ring_handle_t); 626 extern mac_ring_handle_t mac_find_ring(mac_group_handle_t, int); 627 628 extern void mac_prop_info_set_default_uint8( 629 mac_prop_info_handle_t, uint8_t); 630 extern void mac_prop_info_set_default_str( 631 mac_prop_info_handle_t, const char *); 632 extern void mac_prop_info_set_default_uint64( 633 mac_prop_info_handle_t, uint64_t); 634 extern void mac_prop_info_set_default_uint32( 635 mac_prop_info_handle_t, uint32_t); 636 extern void mac_prop_info_set_default_link_flowctrl( 637 mac_prop_info_handle_t, link_flowctrl_t); 638 extern void mac_prop_info_set_default_fec( 639 mac_prop_info_handle_t, link_fec_t); 640 extern void mac_prop_info_set_range_uint32( 641 mac_prop_info_handle_t, 642 uint32_t, uint32_t); 643 extern void mac_prop_info_set_perm(mac_prop_info_handle_t, 644 uint8_t); 645 646 extern void mac_hcksum_get(const mblk_t *, uint32_t *, 647 uint32_t *, uint32_t *, uint32_t *, 648 uint32_t *); 649 extern void mac_hcksum_set(mblk_t *, uint32_t, uint32_t, 650 uint32_t, uint32_t, uint32_t); 651 extern void mac_hcksum_clone(const mblk_t *, mblk_t *); 652 653 extern void mac_lso_get(mblk_t *, uint32_t *, uint32_t *); 654 655 extern void mac_transceiver_info_set_present( 656 mac_transceiver_info_t *, 657 boolean_t); 658 extern void mac_transceiver_info_set_usable( 659 mac_transceiver_info_t *, 660 boolean_t); 661 662 /* 663 * This represents a provisional set of currently illumos-private APIs to get 664 * information about a mblk_t chain's type. This is an evolving interface. 665 */ 666 typedef enum mac_ether_offload_flags { 667 MEOI_L2INFO_SET = 1 << 0, 668 MEOI_VLAN_TAGGED = 1 << 1, 669 MEOI_L3INFO_SET = 1 << 2, 670 MEOI_L4INFO_SET = 1 << 3 671 } mac_ether_offload_flags_t; 672 673 typedef struct mac_ether_offload_info { 674 mac_ether_offload_flags_t meoi_flags; /* What's valid? */ 675 size_t meoi_len; /* Total message length */ 676 uint8_t meoi_l2hlen; /* How long is the Ethernet header? */ 677 uint16_t meoi_l3proto; /* What's the Ethertype */ 678 uint16_t meoi_l3hlen; /* How long is the header? */ 679 uint8_t meoi_l4proto; /* What is the payload type? */ 680 uint8_t meoi_l4hlen; /* How long is the L4 header */ 681 } mac_ether_offload_info_t; 682 683 extern int mac_ether_offload_info(mblk_t *, 684 mac_ether_offload_info_t *); 685 686 687 #endif /* _KERNEL */ 688 689 #ifdef __cplusplus 690 } 691 #endif 692 693 #endif /* _SYS_MAC_PROVIDER_H */ 694