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