xref: /titanic_41/usr/src/uts/common/io/mac/mac_provider.c (revision 9b41bdc4d1e09925acb52ea879d632a2611393df)
1da14cebeSEric Cheng /*
2da14cebeSEric Cheng  * CDDL HEADER START
3da14cebeSEric Cheng  *
4da14cebeSEric Cheng  * The contents of this file are subject to the terms of the
5da14cebeSEric Cheng  * Common Development and Distribution License (the "License").
6da14cebeSEric Cheng  * You may not use this file except in compliance with the License.
7da14cebeSEric Cheng  *
8da14cebeSEric Cheng  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9da14cebeSEric Cheng  * or http://www.opensolaris.org/os/licensing.
10da14cebeSEric Cheng  * See the License for the specific language governing permissions
11da14cebeSEric Cheng  * and limitations under the License.
12da14cebeSEric Cheng  *
13da14cebeSEric Cheng  * When distributing Covered Code, include this CDDL HEADER in each
14da14cebeSEric Cheng  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15da14cebeSEric Cheng  * If applicable, add the following below this CDDL HEADER, with the
16da14cebeSEric Cheng  * fields enclosed by brackets "[]" replaced with your own identifying
17da14cebeSEric Cheng  * information: Portions Copyright [yyyy] [name of copyright owner]
18da14cebeSEric Cheng  *
19da14cebeSEric Cheng  * CDDL HEADER END
20da14cebeSEric Cheng  */
21da14cebeSEric Cheng 
22da14cebeSEric Cheng /*
230591ddd0SPrakash Jalan  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24da14cebeSEric Cheng  */
25da14cebeSEric Cheng 
26da14cebeSEric Cheng #include <sys/types.h>
27da14cebeSEric Cheng #include <sys/conf.h>
28da14cebeSEric Cheng #include <sys/id_space.h>
29da14cebeSEric Cheng #include <sys/esunddi.h>
30da14cebeSEric Cheng #include <sys/stat.h>
31da14cebeSEric Cheng #include <sys/mkdev.h>
32da14cebeSEric Cheng #include <sys/stream.h>
33da14cebeSEric Cheng #include <sys/strsubr.h>
34da14cebeSEric Cheng #include <sys/dlpi.h>
35da14cebeSEric Cheng #include <sys/modhash.h>
36da14cebeSEric Cheng #include <sys/mac.h>
37da14cebeSEric Cheng #include <sys/mac_provider.h>
38da14cebeSEric Cheng #include <sys/mac_impl.h>
39da14cebeSEric Cheng #include <sys/mac_client_impl.h>
40da14cebeSEric Cheng #include <sys/mac_client_priv.h>
41da14cebeSEric Cheng #include <sys/mac_soft_ring.h>
420dc2366fSVenugopal Iyer #include <sys/mac_stat.h>
4361af1958SGarrett D'Amore #include <sys/dld.h>
44da14cebeSEric Cheng #include <sys/modctl.h>
45da14cebeSEric Cheng #include <sys/fs/dv_node.h>
46da14cebeSEric Cheng #include <sys/thread.h>
47da14cebeSEric Cheng #include <sys/proc.h>
48da14cebeSEric Cheng #include <sys/callb.h>
49da14cebeSEric Cheng #include <sys/cpuvar.h>
50da14cebeSEric Cheng #include <sys/atomic.h>
51da14cebeSEric Cheng #include <sys/sdt.h>
52da14cebeSEric Cheng #include <sys/mac_flow.h>
53da14cebeSEric Cheng #include <sys/ddi_intr_impl.h>
54da14cebeSEric Cheng #include <sys/disp.h>
55da14cebeSEric Cheng #include <sys/sdt.h>
560dc2366fSVenugopal Iyer #include <sys/pattr.h>
570dc2366fSVenugopal Iyer #include <sys/strsun.h>
58da14cebeSEric Cheng 
59da14cebeSEric Cheng /*
60da14cebeSEric Cheng  * MAC Provider Interface.
61da14cebeSEric Cheng  *
62da14cebeSEric Cheng  * Interface for GLDv3 compatible NIC drivers.
63da14cebeSEric Cheng  */
64da14cebeSEric Cheng 
65da14cebeSEric Cheng static void i_mac_notify_thread(void *);
66da14cebeSEric Cheng 
67da14cebeSEric Cheng typedef void (*mac_notify_default_cb_fn_t)(mac_impl_t *);
68da14cebeSEric Cheng 
694eaa4710SRishi Srivatsavai static const mac_notify_default_cb_fn_t mac_notify_cb_list[MAC_NNOTE] = {
704eaa4710SRishi Srivatsavai 	mac_fanout_recompute,	/* MAC_NOTE_LINK */
714eaa4710SRishi Srivatsavai 	NULL,		/* MAC_NOTE_UNICST */
724eaa4710SRishi Srivatsavai 	NULL,		/* MAC_NOTE_TX */
734eaa4710SRishi Srivatsavai 	NULL,		/* MAC_NOTE_DEVPROMISC */
744eaa4710SRishi Srivatsavai 	NULL,		/* MAC_NOTE_FASTPATH_FLUSH */
754eaa4710SRishi Srivatsavai 	NULL,		/* MAC_NOTE_SDU_SIZE */
764eaa4710SRishi Srivatsavai 	NULL,		/* MAC_NOTE_MARGIN */
774eaa4710SRishi Srivatsavai 	NULL,		/* MAC_NOTE_CAPAB_CHG */
784eaa4710SRishi Srivatsavai 	NULL		/* MAC_NOTE_LOWLINK */
79da14cebeSEric Cheng };
80da14cebeSEric Cheng 
81da14cebeSEric Cheng /*
82da14cebeSEric Cheng  * Driver support functions.
83da14cebeSEric Cheng  */
84da14cebeSEric Cheng 
85da14cebeSEric Cheng /* REGISTRATION */
86da14cebeSEric Cheng 
87da14cebeSEric Cheng mac_register_t *
mac_alloc(uint_t mac_version)88da14cebeSEric Cheng mac_alloc(uint_t mac_version)
89da14cebeSEric Cheng {
90da14cebeSEric Cheng 	mac_register_t *mregp;
91da14cebeSEric Cheng 
92da14cebeSEric Cheng 	/*
93da14cebeSEric Cheng 	 * Make sure there isn't a version mismatch between the driver and
94da14cebeSEric Cheng 	 * the framework.  In the future, if multiple versions are
95da14cebeSEric Cheng 	 * supported, this check could become more sophisticated.
96da14cebeSEric Cheng 	 */
97da14cebeSEric Cheng 	if (mac_version != MAC_VERSION)
98da14cebeSEric Cheng 		return (NULL);
99da14cebeSEric Cheng 
100da14cebeSEric Cheng 	mregp = kmem_zalloc(sizeof (mac_register_t), KM_SLEEP);
101da14cebeSEric Cheng 	mregp->m_version = mac_version;
102da14cebeSEric Cheng 	return (mregp);
103da14cebeSEric Cheng }
104da14cebeSEric Cheng 
105da14cebeSEric Cheng void
mac_free(mac_register_t * mregp)106da14cebeSEric Cheng mac_free(mac_register_t *mregp)
107da14cebeSEric Cheng {
108da14cebeSEric Cheng 	kmem_free(mregp, sizeof (mac_register_t));
109da14cebeSEric Cheng }
110da14cebeSEric Cheng 
111da14cebeSEric Cheng /*
112da14cebeSEric Cheng  * mac_register() is how drivers register new MACs with the GLDv3
113da14cebeSEric Cheng  * framework.  The mregp argument is allocated by drivers using the
114da14cebeSEric Cheng  * mac_alloc() function, and can be freed using mac_free() immediately upon
115da14cebeSEric Cheng  * return from mac_register().  Upon success (0 return value), the mhp
116da14cebeSEric Cheng  * opaque pointer becomes the driver's handle to its MAC interface, and is
117da14cebeSEric Cheng  * the argument to all other mac module entry points.
118da14cebeSEric Cheng  */
119da14cebeSEric Cheng /* ARGSUSED */
120da14cebeSEric Cheng int
mac_register(mac_register_t * mregp,mac_handle_t * mhp)121da14cebeSEric Cheng mac_register(mac_register_t *mregp, mac_handle_t *mhp)
122da14cebeSEric Cheng {
123da14cebeSEric Cheng 	mac_impl_t		*mip;
124da14cebeSEric Cheng 	mactype_t		*mtype;
125da14cebeSEric Cheng 	int			err = EINVAL;
126da14cebeSEric Cheng 	struct devnames		*dnp = NULL;
127da14cebeSEric Cheng 	uint_t			instance;
128da14cebeSEric Cheng 	boolean_t		style1_created = B_FALSE;
129da14cebeSEric Cheng 	boolean_t		style2_created = B_FALSE;
130da14cebeSEric Cheng 	char			*driver;
131da14cebeSEric Cheng 	minor_t			minor = 0;
132da14cebeSEric Cheng 
133ee94b1c3SSebastien Roy 	/* A successful call to mac_init_ops() sets the DN_GLDV3_DRIVER flag. */
134ee94b1c3SSebastien Roy 	if (!GLDV3_DRV(ddi_driver_major(mregp->m_dip)))
135ee94b1c3SSebastien Roy 		return (EINVAL);
136ee94b1c3SSebastien Roy 
137da14cebeSEric Cheng 	/* Find the required MAC-Type plugin. */
138da14cebeSEric Cheng 	if ((mtype = mactype_getplugin(mregp->m_type_ident)) == NULL)
139da14cebeSEric Cheng 		return (EINVAL);
140da14cebeSEric Cheng 
141da14cebeSEric Cheng 	/* Create a mac_impl_t to represent this MAC. */
142da14cebeSEric Cheng 	mip = kmem_cache_alloc(i_mac_impl_cachep, KM_SLEEP);
143da14cebeSEric Cheng 
144da14cebeSEric Cheng 	/*
145da14cebeSEric Cheng 	 * The mac is not ready for open yet.
146da14cebeSEric Cheng 	 */
147da14cebeSEric Cheng 	mip->mi_state_flags |= MIS_DISABLED;
148da14cebeSEric Cheng 
149da14cebeSEric Cheng 	/*
150da14cebeSEric Cheng 	 * When a mac is registered, the m_instance field can be set to:
151da14cebeSEric Cheng 	 *
152da14cebeSEric Cheng 	 *  0:	Get the mac's instance number from m_dip.
153da14cebeSEric Cheng 	 *	This is usually used for physical device dips.
154da14cebeSEric Cheng 	 *
155da14cebeSEric Cheng 	 *  [1 .. MAC_MAX_MINOR-1]: Use the value as the mac's instance number.
156da14cebeSEric Cheng 	 *	For example, when an aggregation is created with the key option,
157da14cebeSEric Cheng 	 *	"key" will be used as the instance number.
158da14cebeSEric Cheng 	 *
159da14cebeSEric Cheng 	 *  -1: Assign an instance number from [MAC_MAX_MINOR .. MAXMIN-1].
160da14cebeSEric Cheng 	 *	This is often used when a MAC of a virtual link is registered
161da14cebeSEric Cheng 	 *	(e.g., aggregation when "key" is not specified, or vnic).
162da14cebeSEric Cheng 	 *
163da14cebeSEric Cheng 	 * Note that the instance number is used to derive the mi_minor field
164da14cebeSEric Cheng 	 * of mac_impl_t, which will then be used to derive the name of kstats
165da14cebeSEric Cheng 	 * and the devfs nodes.  The first 2 cases are needed to preserve
166da14cebeSEric Cheng 	 * backward compatibility.
167da14cebeSEric Cheng 	 */
168da14cebeSEric Cheng 	switch (mregp->m_instance) {
169da14cebeSEric Cheng 	case 0:
170da14cebeSEric Cheng 		instance = ddi_get_instance(mregp->m_dip);
171da14cebeSEric Cheng 		break;
172da14cebeSEric Cheng 	case ((uint_t)-1):
173da14cebeSEric Cheng 		minor = mac_minor_hold(B_TRUE);
174da14cebeSEric Cheng 		if (minor == 0) {
175da14cebeSEric Cheng 			err = ENOSPC;
176da14cebeSEric Cheng 			goto fail;
177da14cebeSEric Cheng 		}
178da14cebeSEric Cheng 		instance = minor - 1;
179da14cebeSEric Cheng 		break;
180da14cebeSEric Cheng 	default:
181da14cebeSEric Cheng 		instance = mregp->m_instance;
182da14cebeSEric Cheng 		if (instance >= MAC_MAX_MINOR) {
183da14cebeSEric Cheng 			err = EINVAL;
184da14cebeSEric Cheng 			goto fail;
185da14cebeSEric Cheng 		}
186da14cebeSEric Cheng 		break;
187da14cebeSEric Cheng 	}
188da14cebeSEric Cheng 
189da14cebeSEric Cheng 	mip->mi_minor = (minor_t)(instance + 1);
190da14cebeSEric Cheng 	mip->mi_dip = mregp->m_dip;
191da14cebeSEric Cheng 	mip->mi_clients_list = NULL;
192da14cebeSEric Cheng 	mip->mi_nclients = 0;
193da14cebeSEric Cheng 
1944eaa4710SRishi Srivatsavai 	/* Set the default IEEE Port VLAN Identifier */
1954eaa4710SRishi Srivatsavai 	mip->mi_pvid = 1;
1964eaa4710SRishi Srivatsavai 
1974eaa4710SRishi Srivatsavai 	/* Default bridge link learning protection values */
1984eaa4710SRishi Srivatsavai 	mip->mi_llimit = 1000;
1994eaa4710SRishi Srivatsavai 	mip->mi_ldecay = 200;
2004eaa4710SRishi Srivatsavai 
201da14cebeSEric Cheng 	driver = (char *)ddi_driver_name(mip->mi_dip);
202da14cebeSEric Cheng 
203da14cebeSEric Cheng 	/* Construct the MAC name as <drvname><instance> */
204da14cebeSEric Cheng 	(void) snprintf(mip->mi_name, sizeof (mip->mi_name), "%s%d",
205da14cebeSEric Cheng 	    driver, instance);
206da14cebeSEric Cheng 
207da14cebeSEric Cheng 	mip->mi_driver = mregp->m_driver;
208da14cebeSEric Cheng 
209da14cebeSEric Cheng 	mip->mi_type = mtype;
210da14cebeSEric Cheng 	mip->mi_margin = mregp->m_margin;
211da14cebeSEric Cheng 	mip->mi_info.mi_media = mtype->mt_type;
212da14cebeSEric Cheng 	mip->mi_info.mi_nativemedia = mtype->mt_nativetype;
213da14cebeSEric Cheng 	if (mregp->m_max_sdu <= mregp->m_min_sdu)
214da14cebeSEric Cheng 		goto fail;
2151eee170aSErik Nordmark 	if (mregp->m_multicast_sdu == 0)
2161eee170aSErik Nordmark 		mregp->m_multicast_sdu = mregp->m_max_sdu;
2171eee170aSErik Nordmark 	if (mregp->m_multicast_sdu < mregp->m_min_sdu ||
2181eee170aSErik Nordmark 	    mregp->m_multicast_sdu > mregp->m_max_sdu)
2191eee170aSErik Nordmark 		goto fail;
220da14cebeSEric Cheng 	mip->mi_sdu_min = mregp->m_min_sdu;
221da14cebeSEric Cheng 	mip->mi_sdu_max = mregp->m_max_sdu;
2221eee170aSErik Nordmark 	mip->mi_sdu_multicast = mregp->m_multicast_sdu;
223da14cebeSEric Cheng 	mip->mi_info.mi_addr_length = mip->mi_type->mt_addr_length;
224da14cebeSEric Cheng 	/*
225da14cebeSEric Cheng 	 * If the media supports a broadcast address, cache a pointer to it
226da14cebeSEric Cheng 	 * in the mac_info_t so that upper layers can use it.
227da14cebeSEric Cheng 	 */
228da14cebeSEric Cheng 	mip->mi_info.mi_brdcst_addr = mip->mi_type->mt_brdcst_addr;
229da14cebeSEric Cheng 
230da14cebeSEric Cheng 	mip->mi_v12n_level = mregp->m_v12n;
231da14cebeSEric Cheng 
232da14cebeSEric Cheng 	/*
233da14cebeSEric Cheng 	 * Copy the unicast source address into the mac_info_t, but only if
234da14cebeSEric Cheng 	 * the MAC-Type defines a non-zero address length.  We need to
235da14cebeSEric Cheng 	 * handle MAC-Types that have an address length of 0
236da14cebeSEric Cheng 	 * (point-to-point protocol MACs for example).
237da14cebeSEric Cheng 	 */
238da14cebeSEric Cheng 	if (mip->mi_type->mt_addr_length > 0) {
239da14cebeSEric Cheng 		if (mregp->m_src_addr == NULL)
240da14cebeSEric Cheng 			goto fail;
241da14cebeSEric Cheng 		mip->mi_info.mi_unicst_addr =
242da14cebeSEric Cheng 		    kmem_alloc(mip->mi_type->mt_addr_length, KM_SLEEP);
243da14cebeSEric Cheng 		bcopy(mregp->m_src_addr, mip->mi_info.mi_unicst_addr,
244da14cebeSEric Cheng 		    mip->mi_type->mt_addr_length);
245da14cebeSEric Cheng 
246da14cebeSEric Cheng 		/*
247da14cebeSEric Cheng 		 * Copy the fixed 'factory' MAC address from the immutable
248da14cebeSEric Cheng 		 * info.  This is taken to be the MAC address currently in
249da14cebeSEric Cheng 		 * use.
250da14cebeSEric Cheng 		 */
251da14cebeSEric Cheng 		bcopy(mip->mi_info.mi_unicst_addr, mip->mi_addr,
252da14cebeSEric Cheng 		    mip->mi_type->mt_addr_length);
253da14cebeSEric Cheng 
254da14cebeSEric Cheng 		/*
255da14cebeSEric Cheng 		 * At this point, we should set up the classification
256da14cebeSEric Cheng 		 * rules etc but we delay it till mac_open() so that
257da14cebeSEric Cheng 		 * the resource discovery has taken place and we
258da14cebeSEric Cheng 		 * know someone wants to use the device. Otherwise
259da14cebeSEric Cheng 		 * memory gets allocated for Rx ring structures even
260da14cebeSEric Cheng 		 * during probe.
261da14cebeSEric Cheng 		 */
262da14cebeSEric Cheng 
263da14cebeSEric Cheng 		/* Copy the destination address if one is provided. */
264da14cebeSEric Cheng 		if (mregp->m_dst_addr != NULL) {
265da14cebeSEric Cheng 			bcopy(mregp->m_dst_addr, mip->mi_dstaddr,
266da14cebeSEric Cheng 			    mip->mi_type->mt_addr_length);
2672b24ab6bSSebastien Roy 			mip->mi_dstaddr_set = B_TRUE;
268da14cebeSEric Cheng 		}
269da14cebeSEric Cheng 	} else if (mregp->m_src_addr != NULL) {
270da14cebeSEric Cheng 		goto fail;
271da14cebeSEric Cheng 	}
272da14cebeSEric Cheng 
273da14cebeSEric Cheng 	/*
274da14cebeSEric Cheng 	 * The format of the m_pdata is specific to the plugin.  It is
275da14cebeSEric Cheng 	 * passed in as an argument to all of the plugin callbacks.  The
276da14cebeSEric Cheng 	 * driver can update this information by calling
277da14cebeSEric Cheng 	 * mac_pdata_update().
278da14cebeSEric Cheng 	 */
2792b24ab6bSSebastien Roy 	if (mip->mi_type->mt_ops.mtops_ops & MTOPS_PDATA_VERIFY) {
280da14cebeSEric Cheng 		/*
2812b24ab6bSSebastien Roy 		 * Verify if the supplied plugin data is valid.  Note that
2822b24ab6bSSebastien Roy 		 * even if the caller passed in a NULL pointer as plugin data,
2832b24ab6bSSebastien Roy 		 * we still need to verify if that's valid as the plugin may
2842b24ab6bSSebastien Roy 		 * require plugin data to function.
285da14cebeSEric Cheng 		 */
286da14cebeSEric Cheng 		if (!mip->mi_type->mt_ops.mtops_pdata_verify(mregp->m_pdata,
287da14cebeSEric Cheng 		    mregp->m_pdata_size)) {
288da14cebeSEric Cheng 			goto fail;
289da14cebeSEric Cheng 		}
2902b24ab6bSSebastien Roy 		if (mregp->m_pdata != NULL) {
2912b24ab6bSSebastien Roy 			mip->mi_pdata =
2922b24ab6bSSebastien Roy 			    kmem_alloc(mregp->m_pdata_size, KM_SLEEP);
2932b24ab6bSSebastien Roy 			bcopy(mregp->m_pdata, mip->mi_pdata,
2942b24ab6bSSebastien Roy 			    mregp->m_pdata_size);
295da14cebeSEric Cheng 			mip->mi_pdata_size = mregp->m_pdata_size;
296da14cebeSEric Cheng 		}
2972b24ab6bSSebastien Roy 	} else if (mregp->m_pdata != NULL) {
2982b24ab6bSSebastien Roy 		/*
2992b24ab6bSSebastien Roy 		 * The caller supplied non-NULL plugin data, but the plugin
3002b24ab6bSSebastien Roy 		 * does not recognize plugin data.
3012b24ab6bSSebastien Roy 		 */
3022b24ab6bSSebastien Roy 		err = EINVAL;
3032b24ab6bSSebastien Roy 		goto fail;
3042b24ab6bSSebastien Roy 	}
305da14cebeSEric Cheng 
306da14cebeSEric Cheng 	/*
307da14cebeSEric Cheng 	 * Register the private properties.
308da14cebeSEric Cheng 	 */
3090dc2366fSVenugopal Iyer 	mac_register_priv_prop(mip, mregp->m_priv_props);
310da14cebeSEric Cheng 
311da14cebeSEric Cheng 	/*
312da14cebeSEric Cheng 	 * Stash the driver callbacks into the mac_impl_t, but first sanity
313da14cebeSEric Cheng 	 * check to make sure all mandatory callbacks are set.
314da14cebeSEric Cheng 	 */
315da14cebeSEric Cheng 	if (mregp->m_callbacks->mc_getstat == NULL ||
316da14cebeSEric Cheng 	    mregp->m_callbacks->mc_start == NULL ||
317da14cebeSEric Cheng 	    mregp->m_callbacks->mc_stop == NULL ||
318da14cebeSEric Cheng 	    mregp->m_callbacks->mc_setpromisc == NULL ||
319da14cebeSEric Cheng 	    mregp->m_callbacks->mc_multicst == NULL) {
320da14cebeSEric Cheng 		goto fail;
321da14cebeSEric Cheng 	}
322da14cebeSEric Cheng 	mip->mi_callbacks = mregp->m_callbacks;
323da14cebeSEric Cheng 
3245d460eafSCathy Zhou 	if (mac_capab_get((mac_handle_t)mip, MAC_CAPAB_LEGACY,
3255d460eafSCathy Zhou 	    &mip->mi_capab_legacy)) {
326da14cebeSEric Cheng 		mip->mi_state_flags |= MIS_LEGACY;
3275d460eafSCathy Zhou 		mip->mi_phy_dev = mip->mi_capab_legacy.ml_dev;
328da14cebeSEric Cheng 	} else {
329da14cebeSEric Cheng 		mip->mi_phy_dev = makedevice(ddi_driver_major(mip->mi_dip),
33061af1958SGarrett D'Amore 		    mip->mi_minor);
331da14cebeSEric Cheng 	}
332da14cebeSEric Cheng 
333da14cebeSEric Cheng 	/*
334da14cebeSEric Cheng 	 * Allocate a notification thread. thread_create blocks for memory
335da14cebeSEric Cheng 	 * if needed, it never fails.
336da14cebeSEric Cheng 	 */
337da14cebeSEric Cheng 	mip->mi_notify_thread = thread_create(NULL, 0, i_mac_notify_thread,
338da14cebeSEric Cheng 	    mip, 0, &p0, TS_RUN, minclsyspri);
339da14cebeSEric Cheng 
340da14cebeSEric Cheng 	/*
341da14cebeSEric Cheng 	 * Initialize the capabilities
342da14cebeSEric Cheng 	 */
343da14cebeSEric Cheng 
3440dc2366fSVenugopal Iyer 	bzero(&mip->mi_rx_rings_cap, sizeof (mac_capab_rings_t));
3450dc2366fSVenugopal Iyer 	bzero(&mip->mi_tx_rings_cap, sizeof (mac_capab_rings_t));
3460dc2366fSVenugopal Iyer 
347da14cebeSEric Cheng 	if (i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_VNIC, NULL))
348da14cebeSEric Cheng 		mip->mi_state_flags |= MIS_IS_VNIC;
349da14cebeSEric Cheng 
350da14cebeSEric Cheng 	if (i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_AGGR, NULL))
351da14cebeSEric Cheng 		mip->mi_state_flags |= MIS_IS_AGGR;
352da14cebeSEric Cheng 
353da14cebeSEric Cheng 	mac_addr_factory_init(mip);
354da14cebeSEric Cheng 
355da14cebeSEric Cheng 	/*
356da14cebeSEric Cheng 	 * Enforce the virtrualization level registered.
357da14cebeSEric Cheng 	 */
358da14cebeSEric Cheng 	if (mip->mi_v12n_level & MAC_VIRT_LEVEL1) {
359da14cebeSEric Cheng 		if (mac_init_rings(mip, MAC_RING_TYPE_RX) != 0 ||
360da14cebeSEric Cheng 		    mac_init_rings(mip, MAC_RING_TYPE_TX) != 0)
361da14cebeSEric Cheng 			goto fail;
362da14cebeSEric Cheng 
363da14cebeSEric Cheng 		/*
364da14cebeSEric Cheng 		 * The driver needs to register at least rx rings for this
365da14cebeSEric Cheng 		 * virtualization level.
366da14cebeSEric Cheng 		 */
367da14cebeSEric Cheng 		if (mip->mi_rx_groups == NULL)
368da14cebeSEric Cheng 			goto fail;
369da14cebeSEric Cheng 	}
370da14cebeSEric Cheng 
371da14cebeSEric Cheng 	/*
372da14cebeSEric Cheng 	 * The driver must set mc_unicst entry point to NULL when it advertises
373da14cebeSEric Cheng 	 * CAP_RINGS for rx groups.
374da14cebeSEric Cheng 	 */
375da14cebeSEric Cheng 	if (mip->mi_rx_groups != NULL) {
376da14cebeSEric Cheng 		if (mregp->m_callbacks->mc_unicst != NULL)
377da14cebeSEric Cheng 			goto fail;
378da14cebeSEric Cheng 	} else {
379da14cebeSEric Cheng 		if (mregp->m_callbacks->mc_unicst == NULL)
380da14cebeSEric Cheng 			goto fail;
381da14cebeSEric Cheng 	}
382da14cebeSEric Cheng 
383da14cebeSEric Cheng 	/*
384da14cebeSEric Cheng 	 * Initialize MAC addresses. Must be called after mac_init_rings().
385da14cebeSEric Cheng 	 */
386da14cebeSEric Cheng 	mac_init_macaddr(mip);
387da14cebeSEric Cheng 
388da14cebeSEric Cheng 	mip->mi_share_capab.ms_snum = 0;
389da14cebeSEric Cheng 	if (mip->mi_v12n_level & MAC_VIRT_HIO) {
390da14cebeSEric Cheng 		(void) mac_capab_get((mac_handle_t)mip, MAC_CAPAB_SHARES,
391da14cebeSEric Cheng 		    &mip->mi_share_capab);
392da14cebeSEric Cheng 	}
393da14cebeSEric Cheng 
394da14cebeSEric Cheng 	/*
395da14cebeSEric Cheng 	 * Initialize the kstats for this device.
396da14cebeSEric Cheng 	 */
3970dc2366fSVenugopal Iyer 	mac_driver_stat_create(mip);
398da14cebeSEric Cheng 
399da14cebeSEric Cheng 	/* Zero out any properties. */
400da14cebeSEric Cheng 	bzero(&mip->mi_resource_props, sizeof (mac_resource_props_t));
401da14cebeSEric Cheng 
4023ade6e84SGarrett D'Amore 	if (mip->mi_minor <= MAC_MAX_MINOR) {
403da14cebeSEric Cheng 		/* Create a style-2 DLPI device */
404da14cebeSEric Cheng 		if (ddi_create_minor_node(mip->mi_dip, driver, S_IFCHR, 0,
405da14cebeSEric Cheng 		    DDI_NT_NET, CLONE_DEV) != DDI_SUCCESS)
406da14cebeSEric Cheng 			goto fail;
407da14cebeSEric Cheng 		style2_created = B_TRUE;
408da14cebeSEric Cheng 
409da14cebeSEric Cheng 		/* Create a style-1 DLPI device */
410da14cebeSEric Cheng 		if (ddi_create_minor_node(mip->mi_dip, mip->mi_name, S_IFCHR,
411da14cebeSEric Cheng 		    mip->mi_minor, DDI_NT_NET, 0) != DDI_SUCCESS)
412da14cebeSEric Cheng 			goto fail;
413da14cebeSEric Cheng 		style1_created = B_TRUE;
414da14cebeSEric Cheng 	}
415da14cebeSEric Cheng 
416da14cebeSEric Cheng 	mac_flow_l2tab_create(mip, &mip->mi_flow_tab);
417da14cebeSEric Cheng 
418da14cebeSEric Cheng 	rw_enter(&i_mac_impl_lock, RW_WRITER);
419da14cebeSEric Cheng 	if (mod_hash_insert(i_mac_impl_hash,
420da14cebeSEric Cheng 	    (mod_hash_key_t)mip->mi_name, (mod_hash_val_t)mip) != 0) {
421da14cebeSEric Cheng 		rw_exit(&i_mac_impl_lock);
422da14cebeSEric Cheng 		err = EEXIST;
423da14cebeSEric Cheng 		goto fail;
424da14cebeSEric Cheng 	}
425da14cebeSEric Cheng 
426da14cebeSEric Cheng 	DTRACE_PROBE2(mac__register, struct devnames *, dnp,
427da14cebeSEric Cheng 	    (mac_impl_t *), mip);
428da14cebeSEric Cheng 
429da14cebeSEric Cheng 	/*
430da14cebeSEric Cheng 	 * Mark the MAC to be ready for open.
431da14cebeSEric Cheng 	 */
432da14cebeSEric Cheng 	mip->mi_state_flags &= ~MIS_DISABLED;
433da14cebeSEric Cheng 	rw_exit(&i_mac_impl_lock);
434da14cebeSEric Cheng 
435da14cebeSEric Cheng 	atomic_inc_32(&i_mac_impl_count);
436da14cebeSEric Cheng 
437da14cebeSEric Cheng 	cmn_err(CE_NOTE, "!%s registered", mip->mi_name);
438da14cebeSEric Cheng 	*mhp = (mac_handle_t)mip;
439da14cebeSEric Cheng 	return (0);
440da14cebeSEric Cheng 
441da14cebeSEric Cheng fail:
442da14cebeSEric Cheng 	if (style1_created)
443da14cebeSEric Cheng 		ddi_remove_minor_node(mip->mi_dip, mip->mi_name);
444da14cebeSEric Cheng 
445da14cebeSEric Cheng 	if (style2_created)
446da14cebeSEric Cheng 		ddi_remove_minor_node(mip->mi_dip, driver);
447da14cebeSEric Cheng 
448da14cebeSEric Cheng 	mac_addr_factory_fini(mip);
449da14cebeSEric Cheng 
450da14cebeSEric Cheng 	/* Clean up registered MAC addresses */
451da14cebeSEric Cheng 	mac_fini_macaddr(mip);
452da14cebeSEric Cheng 
453da14cebeSEric Cheng 	/* Clean up registered rings */
454da14cebeSEric Cheng 	mac_free_rings(mip, MAC_RING_TYPE_RX);
455da14cebeSEric Cheng 	mac_free_rings(mip, MAC_RING_TYPE_TX);
456da14cebeSEric Cheng 
457da14cebeSEric Cheng 	/* Clean up notification thread */
458da14cebeSEric Cheng 	if (mip->mi_notify_thread != NULL)
459da14cebeSEric Cheng 		i_mac_notify_exit(mip);
460da14cebeSEric Cheng 
461da14cebeSEric Cheng 	if (mip->mi_info.mi_unicst_addr != NULL) {
462da14cebeSEric Cheng 		kmem_free(mip->mi_info.mi_unicst_addr,
463da14cebeSEric Cheng 		    mip->mi_type->mt_addr_length);
464da14cebeSEric Cheng 		mip->mi_info.mi_unicst_addr = NULL;
465da14cebeSEric Cheng 	}
466da14cebeSEric Cheng 
4670dc2366fSVenugopal Iyer 	mac_driver_stat_delete(mip);
468da14cebeSEric Cheng 
469da14cebeSEric Cheng 	if (mip->mi_type != NULL) {
470da14cebeSEric Cheng 		atomic_dec_32(&mip->mi_type->mt_ref);
471da14cebeSEric Cheng 		mip->mi_type = NULL;
472da14cebeSEric Cheng 	}
473da14cebeSEric Cheng 
474da14cebeSEric Cheng 	if (mip->mi_pdata != NULL) {
475da14cebeSEric Cheng 		kmem_free(mip->mi_pdata, mip->mi_pdata_size);
476da14cebeSEric Cheng 		mip->mi_pdata = NULL;
477da14cebeSEric Cheng 		mip->mi_pdata_size = 0;
478da14cebeSEric Cheng 	}
479da14cebeSEric Cheng 
480da14cebeSEric Cheng 	if (minor != 0) {
481da14cebeSEric Cheng 		ASSERT(minor > MAC_MAX_MINOR);
482da14cebeSEric Cheng 		mac_minor_rele(minor);
483da14cebeSEric Cheng 	}
484da14cebeSEric Cheng 
4850dc2366fSVenugopal Iyer 	mip->mi_state_flags = 0;
486da14cebeSEric Cheng 	mac_unregister_priv_prop(mip);
487da14cebeSEric Cheng 
488783f25ceSMichael Speer 	/*
489783f25ceSMichael Speer 	 * Clear the state before destroying the mac_impl_t
490783f25ceSMichael Speer 	 */
491783f25ceSMichael Speer 	mip->mi_state_flags = 0;
492783f25ceSMichael Speer 
493da14cebeSEric Cheng 	kmem_cache_free(i_mac_impl_cachep, mip);
494da14cebeSEric Cheng 	return (err);
495da14cebeSEric Cheng }
496da14cebeSEric Cheng 
497da14cebeSEric Cheng /*
498da14cebeSEric Cheng  * Unregister from the GLDv3 framework
499da14cebeSEric Cheng  */
500da14cebeSEric Cheng int
mac_unregister(mac_handle_t mh)501da14cebeSEric Cheng mac_unregister(mac_handle_t mh)
502da14cebeSEric Cheng {
503da14cebeSEric Cheng 	int			err;
504da14cebeSEric Cheng 	mac_impl_t		*mip = (mac_impl_t *)mh;
505da14cebeSEric Cheng 	mod_hash_val_t		val;
506da14cebeSEric Cheng 	mac_margin_req_t	*mmr, *nextmmr;
507da14cebeSEric Cheng 
508da14cebeSEric Cheng 	/* Fail the unregister if there are any open references to this mac. */
509da14cebeSEric Cheng 	if ((err = mac_disable_nowait(mh)) != 0)
510da14cebeSEric Cheng 		return (err);
511da14cebeSEric Cheng 
512da14cebeSEric Cheng 	/*
513da14cebeSEric Cheng 	 * Clean up notification thread and wait for it to exit.
514da14cebeSEric Cheng 	 */
515da14cebeSEric Cheng 	i_mac_notify_exit(mip);
516da14cebeSEric Cheng 
517da14cebeSEric Cheng 	i_mac_perim_enter(mip);
518da14cebeSEric Cheng 
5195d460eafSCathy Zhou 	/*
5205d460eafSCathy Zhou 	 * There is still resource properties configured over this mac.
5215d460eafSCathy Zhou 	 */
5225d460eafSCathy Zhou 	if (mip->mi_resource_props.mrp_mask != 0)
5235d460eafSCathy Zhou 		mac_fastpath_enable((mac_handle_t)mip);
5245d460eafSCathy Zhou 
525da14cebeSEric Cheng 	if (mip->mi_minor < MAC_MAX_MINOR + 1) {
526da14cebeSEric Cheng 		ddi_remove_minor_node(mip->mi_dip, mip->mi_name);
527da14cebeSEric Cheng 		ddi_remove_minor_node(mip->mi_dip,
528da14cebeSEric Cheng 		    (char *)ddi_driver_name(mip->mi_dip));
529da14cebeSEric Cheng 	}
530da14cebeSEric Cheng 
531da14cebeSEric Cheng 	ASSERT(mip->mi_nactiveclients == 0 && !(mip->mi_state_flags &
532da14cebeSEric Cheng 	    MIS_EXCLUSIVE));
533da14cebeSEric Cheng 
5340dc2366fSVenugopal Iyer 	mac_driver_stat_delete(mip);
535da14cebeSEric Cheng 
536da14cebeSEric Cheng 	(void) mod_hash_remove(i_mac_impl_hash,
537da14cebeSEric Cheng 	    (mod_hash_key_t)mip->mi_name, &val);
538da14cebeSEric Cheng 	ASSERT(mip == (mac_impl_t *)val);
539da14cebeSEric Cheng 
540da14cebeSEric Cheng 	ASSERT(i_mac_impl_count > 0);
541da14cebeSEric Cheng 	atomic_dec_32(&i_mac_impl_count);
542da14cebeSEric Cheng 
543da14cebeSEric Cheng 	if (mip->mi_pdata != NULL)
544da14cebeSEric Cheng 		kmem_free(mip->mi_pdata, mip->mi_pdata_size);
545da14cebeSEric Cheng 	mip->mi_pdata = NULL;
546da14cebeSEric Cheng 	mip->mi_pdata_size = 0;
547da14cebeSEric Cheng 
548da14cebeSEric Cheng 	/*
549da14cebeSEric Cheng 	 * Free the list of margin request.
550da14cebeSEric Cheng 	 */
551da14cebeSEric Cheng 	for (mmr = mip->mi_mmrp; mmr != NULL; mmr = nextmmr) {
552da14cebeSEric Cheng 		nextmmr = mmr->mmr_nextp;
553da14cebeSEric Cheng 		kmem_free(mmr, sizeof (mac_margin_req_t));
554da14cebeSEric Cheng 	}
555da14cebeSEric Cheng 	mip->mi_mmrp = NULL;
556da14cebeSEric Cheng 
5574eaa4710SRishi Srivatsavai 	mip->mi_linkstate = mip->mi_lowlinkstate = LINK_STATE_UNKNOWN;
558da14cebeSEric Cheng 	kmem_free(mip->mi_info.mi_unicst_addr, mip->mi_type->mt_addr_length);
559da14cebeSEric Cheng 	mip->mi_info.mi_unicst_addr = NULL;
560da14cebeSEric Cheng 
561da14cebeSEric Cheng 	atomic_dec_32(&mip->mi_type->mt_ref);
562da14cebeSEric Cheng 	mip->mi_type = NULL;
563da14cebeSEric Cheng 
564da14cebeSEric Cheng 	/*
565da14cebeSEric Cheng 	 * Free the primary MAC address.
566da14cebeSEric Cheng 	 */
567da14cebeSEric Cheng 	mac_fini_macaddr(mip);
568da14cebeSEric Cheng 
569da14cebeSEric Cheng 	/*
570da14cebeSEric Cheng 	 * free all rings
571da14cebeSEric Cheng 	 */
572da14cebeSEric Cheng 	mac_free_rings(mip, MAC_RING_TYPE_RX);
573da14cebeSEric Cheng 	mac_free_rings(mip, MAC_RING_TYPE_TX);
574da14cebeSEric Cheng 
575da14cebeSEric Cheng 	mac_addr_factory_fini(mip);
576da14cebeSEric Cheng 
577da14cebeSEric Cheng 	bzero(mip->mi_addr, MAXMACADDRLEN);
578da14cebeSEric Cheng 	bzero(mip->mi_dstaddr, MAXMACADDRLEN);
579*9b41bdc4SRobert Mustacchi 	mip->mi_dstaddr_set = B_FALSE;
580da14cebeSEric Cheng 
581da14cebeSEric Cheng 	/* and the flows */
582da14cebeSEric Cheng 	mac_flow_tab_destroy(mip->mi_flow_tab);
583da14cebeSEric Cheng 	mip->mi_flow_tab = NULL;
584da14cebeSEric Cheng 
585da14cebeSEric Cheng 	if (mip->mi_minor > MAC_MAX_MINOR)
586da14cebeSEric Cheng 		mac_minor_rele(mip->mi_minor);
587da14cebeSEric Cheng 
588da14cebeSEric Cheng 	cmn_err(CE_NOTE, "!%s unregistered", mip->mi_name);
589da14cebeSEric Cheng 
590da14cebeSEric Cheng 	/*
591da14cebeSEric Cheng 	 * Reset the perim related fields to default values before
592da14cebeSEric Cheng 	 * kmem_cache_free
593da14cebeSEric Cheng 	 */
594da14cebeSEric Cheng 	i_mac_perim_exit(mip);
595da14cebeSEric Cheng 	mip->mi_state_flags = 0;
596da14cebeSEric Cheng 
597da14cebeSEric Cheng 	mac_unregister_priv_prop(mip);
5984eaa4710SRishi Srivatsavai 
5994eaa4710SRishi Srivatsavai 	ASSERT(mip->mi_bridge_link == NULL);
600da14cebeSEric Cheng 	kmem_cache_free(i_mac_impl_cachep, mip);
601da14cebeSEric Cheng 
602da14cebeSEric Cheng 	return (0);
603da14cebeSEric Cheng }
604da14cebeSEric Cheng 
605da14cebeSEric Cheng /* DATA RECEPTION */
606da14cebeSEric Cheng 
607da14cebeSEric Cheng /*
608da14cebeSEric Cheng  * This function is invoked for packets received by the MAC driver in
609da14cebeSEric Cheng  * interrupt context. The ring generation number provided by the driver
610da14cebeSEric Cheng  * is matched with the ring generation number held in MAC. If they do not
611da14cebeSEric Cheng  * match, received packets are considered stale packets coming from an older
612da14cebeSEric Cheng  * assignment of the ring. Drop them.
613da14cebeSEric Cheng  */
614da14cebeSEric Cheng void
mac_rx_ring(mac_handle_t mh,mac_ring_handle_t mrh,mblk_t * mp_chain,uint64_t mr_gen_num)615da14cebeSEric Cheng mac_rx_ring(mac_handle_t mh, mac_ring_handle_t mrh, mblk_t *mp_chain,
616da14cebeSEric Cheng     uint64_t mr_gen_num)
617da14cebeSEric Cheng {
618da14cebeSEric Cheng 	mac_ring_t		*mr = (mac_ring_t *)mrh;
619da14cebeSEric Cheng 
620da14cebeSEric Cheng 	if ((mr != NULL) && (mr->mr_gen_num != mr_gen_num)) {
621da14cebeSEric Cheng 		DTRACE_PROBE2(mac__rx__rings__stale__packet, uint64_t,
622da14cebeSEric Cheng 		    mr->mr_gen_num, uint64_t, mr_gen_num);
623da14cebeSEric Cheng 		freemsgchain(mp_chain);
624da14cebeSEric Cheng 		return;
625da14cebeSEric Cheng 	}
626da14cebeSEric Cheng 	mac_rx(mh, (mac_resource_handle_t)mrh, mp_chain);
627da14cebeSEric Cheng }
628da14cebeSEric Cheng 
629da14cebeSEric Cheng /*
6304eaa4710SRishi Srivatsavai  * This function is invoked for each packet received by the underlying driver.
631da14cebeSEric Cheng  */
632da14cebeSEric Cheng void
mac_rx(mac_handle_t mh,mac_resource_handle_t mrh,mblk_t * mp_chain)633da14cebeSEric Cheng mac_rx(mac_handle_t mh, mac_resource_handle_t mrh, mblk_t *mp_chain)
634da14cebeSEric Cheng {
635da14cebeSEric Cheng 	mac_impl_t *mip = (mac_impl_t *)mh;
6364eaa4710SRishi Srivatsavai 
6374eaa4710SRishi Srivatsavai 	/*
6384eaa4710SRishi Srivatsavai 	 * Check if the link is part of a bridge.  If not, then we don't need
6394eaa4710SRishi Srivatsavai 	 * to take the lock to remain consistent.  Make this common case
6404eaa4710SRishi Srivatsavai 	 * lock-free and tail-call optimized.
6414eaa4710SRishi Srivatsavai 	 */
6424eaa4710SRishi Srivatsavai 	if (mip->mi_bridge_link == NULL) {
6434eaa4710SRishi Srivatsavai 		mac_rx_common(mh, mrh, mp_chain);
6444eaa4710SRishi Srivatsavai 	} else {
6454eaa4710SRishi Srivatsavai 		/*
6464eaa4710SRishi Srivatsavai 		 * Once we take a reference on the bridge link, the bridge
6474eaa4710SRishi Srivatsavai 		 * module itself can't unload, so the callback pointers are
6484eaa4710SRishi Srivatsavai 		 * stable.
6494eaa4710SRishi Srivatsavai 		 */
6504eaa4710SRishi Srivatsavai 		mutex_enter(&mip->mi_bridge_lock);
6514eaa4710SRishi Srivatsavai 		if ((mh = mip->mi_bridge_link) != NULL)
6524eaa4710SRishi Srivatsavai 			mac_bridge_ref_cb(mh, B_TRUE);
6534eaa4710SRishi Srivatsavai 		mutex_exit(&mip->mi_bridge_lock);
6544eaa4710SRishi Srivatsavai 		if (mh == NULL) {
6554eaa4710SRishi Srivatsavai 			mac_rx_common((mac_handle_t)mip, mrh, mp_chain);
6564eaa4710SRishi Srivatsavai 		} else {
6574eaa4710SRishi Srivatsavai 			mac_bridge_rx_cb(mh, mrh, mp_chain);
6584eaa4710SRishi Srivatsavai 			mac_bridge_ref_cb(mh, B_FALSE);
6594eaa4710SRishi Srivatsavai 		}
6604eaa4710SRishi Srivatsavai 	}
6614eaa4710SRishi Srivatsavai }
6624eaa4710SRishi Srivatsavai 
6634eaa4710SRishi Srivatsavai /*
6644eaa4710SRishi Srivatsavai  * Special case function: this allows snooping of packets transmitted and
6654eaa4710SRishi Srivatsavai  * received by TRILL. By design, they go directly into the TRILL module.
6664eaa4710SRishi Srivatsavai  */
6674eaa4710SRishi Srivatsavai void
mac_trill_snoop(mac_handle_t mh,mblk_t * mp)6684eaa4710SRishi Srivatsavai mac_trill_snoop(mac_handle_t mh, mblk_t *mp)
6694eaa4710SRishi Srivatsavai {
6704eaa4710SRishi Srivatsavai 	mac_impl_t *mip = (mac_impl_t *)mh;
6714eaa4710SRishi Srivatsavai 
6724eaa4710SRishi Srivatsavai 	if (mip->mi_promisc_list != NULL)
6734eaa4710SRishi Srivatsavai 		mac_promisc_dispatch(mip, mp, NULL);
6744eaa4710SRishi Srivatsavai }
6754eaa4710SRishi Srivatsavai 
6764eaa4710SRishi Srivatsavai /*
6774eaa4710SRishi Srivatsavai  * This is the upward reentry point for packets arriving from the bridging
6784eaa4710SRishi Srivatsavai  * module and from mac_rx for links not part of a bridge.
6794eaa4710SRishi Srivatsavai  */
6804eaa4710SRishi Srivatsavai void
mac_rx_common(mac_handle_t mh,mac_resource_handle_t mrh,mblk_t * mp_chain)6814eaa4710SRishi Srivatsavai mac_rx_common(mac_handle_t mh, mac_resource_handle_t mrh, mblk_t *mp_chain)
6824eaa4710SRishi Srivatsavai {
6834eaa4710SRishi Srivatsavai 	mac_impl_t		*mip = (mac_impl_t *)mh;
684da14cebeSEric Cheng 	mac_ring_t		*mr = (mac_ring_t *)mrh;
685da14cebeSEric Cheng 	mac_soft_ring_set_t 	*mac_srs;
686da14cebeSEric Cheng 	mblk_t			*bp = mp_chain;
687da14cebeSEric Cheng 	boolean_t		hw_classified = B_FALSE;
688da14cebeSEric Cheng 
689da14cebeSEric Cheng 	/*
690da14cebeSEric Cheng 	 * If there are any promiscuous mode callbacks defined for
691da14cebeSEric Cheng 	 * this MAC, pass them a copy if appropriate.
692da14cebeSEric Cheng 	 */
693da14cebeSEric Cheng 	if (mip->mi_promisc_list != NULL)
694da14cebeSEric Cheng 		mac_promisc_dispatch(mip, mp_chain, NULL);
695da14cebeSEric Cheng 
696da14cebeSEric Cheng 	if (mr != NULL) {
697da14cebeSEric Cheng 		/*
698da14cebeSEric Cheng 		 * If the SRS teardown has started, just return. The 'mr'
699da14cebeSEric Cheng 		 * continues to be valid until the driver unregisters the mac.
700da14cebeSEric Cheng 		 * Hardware classified packets will not make their way up
701da14cebeSEric Cheng 		 * beyond this point once the teardown has started. The driver
702da14cebeSEric Cheng 		 * is never passed a pointer to a flow entry or SRS or any
703da14cebeSEric Cheng 		 * structure that can be freed much before mac_unregister.
704da14cebeSEric Cheng 		 */
705da14cebeSEric Cheng 		mutex_enter(&mr->mr_lock);
706da14cebeSEric Cheng 		if ((mr->mr_state != MR_INUSE) || (mr->mr_flag &
707da14cebeSEric Cheng 		    (MR_INCIPIENT | MR_CONDEMNED | MR_QUIESCE))) {
708da14cebeSEric Cheng 			mutex_exit(&mr->mr_lock);
709da14cebeSEric Cheng 			freemsgchain(mp_chain);
710da14cebeSEric Cheng 			return;
711da14cebeSEric Cheng 		}
712da14cebeSEric Cheng 		if (mr->mr_classify_type == MAC_HW_CLASSIFIER) {
713da14cebeSEric Cheng 			hw_classified = B_TRUE;
714da14cebeSEric Cheng 			MR_REFHOLD_LOCKED(mr);
715da14cebeSEric Cheng 		}
716da14cebeSEric Cheng 		mutex_exit(&mr->mr_lock);
717da14cebeSEric Cheng 
718da14cebeSEric Cheng 		/*
719da14cebeSEric Cheng 		 * We check if an SRS is controlling this ring.
720da14cebeSEric Cheng 		 * If so, we can directly call the srs_lower_proc
721da14cebeSEric Cheng 		 * routine otherwise we need to go through mac_rx_classify
722da14cebeSEric Cheng 		 * to reach the right place.
723da14cebeSEric Cheng 		 */
724da14cebeSEric Cheng 		if (hw_classified) {
725da14cebeSEric Cheng 			mac_srs = mr->mr_srs;
726da14cebeSEric Cheng 			/*
727da14cebeSEric Cheng 			 * This is supposed to be the fast path.
728da14cebeSEric Cheng 			 * All packets received though here were steered by
729da14cebeSEric Cheng 			 * the hardware classifier, and share the same
730da14cebeSEric Cheng 			 * MAC header info.
731da14cebeSEric Cheng 			 */
732da14cebeSEric Cheng 			mac_srs->srs_rx.sr_lower_proc(mh,
733da14cebeSEric Cheng 			    (mac_resource_handle_t)mac_srs, mp_chain, B_FALSE);
734da14cebeSEric Cheng 			MR_REFRELE(mr);
735da14cebeSEric Cheng 			return;
736da14cebeSEric Cheng 		}
737da14cebeSEric Cheng 		/* We'll fall through to software classification */
738ae6aa22aSVenugopal Iyer 	} else {
739ae6aa22aSVenugopal Iyer 		flow_entry_t *flent;
740ae6aa22aSVenugopal Iyer 		int err;
741ae6aa22aSVenugopal Iyer 
742ae6aa22aSVenugopal Iyer 		rw_enter(&mip->mi_rw_lock, RW_READER);
743ae6aa22aSVenugopal Iyer 		if (mip->mi_single_active_client != NULL) {
744ae6aa22aSVenugopal Iyer 			flent = mip->mi_single_active_client->mci_flent_list;
745ae6aa22aSVenugopal Iyer 			FLOW_TRY_REFHOLD(flent, err);
746ae6aa22aSVenugopal Iyer 			rw_exit(&mip->mi_rw_lock);
747ae6aa22aSVenugopal Iyer 			if (err == 0) {
748ae6aa22aSVenugopal Iyer 				(flent->fe_cb_fn)(flent->fe_cb_arg1,
749ae6aa22aSVenugopal Iyer 				    flent->fe_cb_arg2, mp_chain, B_FALSE);
750ae6aa22aSVenugopal Iyer 				FLOW_REFRELE(flent);
751ae6aa22aSVenugopal Iyer 				return;
752ae6aa22aSVenugopal Iyer 			}
753ae6aa22aSVenugopal Iyer 		} else {
754ae6aa22aSVenugopal Iyer 			rw_exit(&mip->mi_rw_lock);
755ae6aa22aSVenugopal Iyer 		}
756da14cebeSEric Cheng 	}
757da14cebeSEric Cheng 
758da14cebeSEric Cheng 	if (!FLOW_TAB_EMPTY(mip->mi_flow_tab)) {
759da14cebeSEric Cheng 		if ((bp = mac_rx_flow(mh, mrh, bp)) == NULL)
760da14cebeSEric Cheng 			return;
761da14cebeSEric Cheng 	}
762da14cebeSEric Cheng 
763da14cebeSEric Cheng 	freemsgchain(bp);
764da14cebeSEric Cheng }
765da14cebeSEric Cheng 
766da14cebeSEric Cheng /* DATA TRANSMISSION */
767da14cebeSEric Cheng 
768da14cebeSEric Cheng /*
769da14cebeSEric Cheng  * A driver's notification to resume transmission, in case of a provider
770da14cebeSEric Cheng  * without TX rings.
771da14cebeSEric Cheng  */
772da14cebeSEric Cheng void
mac_tx_update(mac_handle_t mh)773da14cebeSEric Cheng mac_tx_update(mac_handle_t mh)
774da14cebeSEric Cheng {
7750dc2366fSVenugopal Iyer 	mac_tx_ring_update(mh, NULL);
776da14cebeSEric Cheng }
777da14cebeSEric Cheng 
778da14cebeSEric Cheng /*
779da14cebeSEric Cheng  * A driver's notification to resume transmission on the specified TX ring.
780da14cebeSEric Cheng  */
781da14cebeSEric Cheng void
mac_tx_ring_update(mac_handle_t mh,mac_ring_handle_t rh)782da14cebeSEric Cheng mac_tx_ring_update(mac_handle_t mh, mac_ring_handle_t rh)
783da14cebeSEric Cheng {
784da14cebeSEric Cheng 	i_mac_tx_srs_notify((mac_impl_t *)mh, rh);
785da14cebeSEric Cheng }
786da14cebeSEric Cheng 
787da14cebeSEric Cheng /* LINK STATE */
788da14cebeSEric Cheng /*
789da14cebeSEric Cheng  * Notify the MAC layer about a link state change
790da14cebeSEric Cheng  */
791da14cebeSEric Cheng void
mac_link_update(mac_handle_t mh,link_state_t link)792da14cebeSEric Cheng mac_link_update(mac_handle_t mh, link_state_t link)
793da14cebeSEric Cheng {
794da14cebeSEric Cheng 	mac_impl_t	*mip = (mac_impl_t *)mh;
795da14cebeSEric Cheng 
796da14cebeSEric Cheng 	/*
797da14cebeSEric Cheng 	 * Save the link state.
798da14cebeSEric Cheng 	 */
7994eaa4710SRishi Srivatsavai 	mip->mi_lowlinkstate = link;
8004eaa4710SRishi Srivatsavai 
8014eaa4710SRishi Srivatsavai 	/*
8024eaa4710SRishi Srivatsavai 	 * Send a MAC_NOTE_LOWLINK notification.  This tells the notification
8034eaa4710SRishi Srivatsavai 	 * thread to deliver both lower and upper notifications.
8044eaa4710SRishi Srivatsavai 	 */
8054eaa4710SRishi Srivatsavai 	i_mac_notify(mip, MAC_NOTE_LOWLINK);
8064eaa4710SRishi Srivatsavai }
8074eaa4710SRishi Srivatsavai 
8084eaa4710SRishi Srivatsavai /*
8094eaa4710SRishi Srivatsavai  * Notify the MAC layer about a link state change due to bridging.
8104eaa4710SRishi Srivatsavai  */
8114eaa4710SRishi Srivatsavai void
mac_link_redo(mac_handle_t mh,link_state_t link)8124eaa4710SRishi Srivatsavai mac_link_redo(mac_handle_t mh, link_state_t link)
8134eaa4710SRishi Srivatsavai {
8144eaa4710SRishi Srivatsavai 	mac_impl_t	*mip = (mac_impl_t *)mh;
8154eaa4710SRishi Srivatsavai 
8164eaa4710SRishi Srivatsavai 	/*
8174eaa4710SRishi Srivatsavai 	 * Save the link state.
8184eaa4710SRishi Srivatsavai 	 */
819da14cebeSEric Cheng 	mip->mi_linkstate = link;
820da14cebeSEric Cheng 
821da14cebeSEric Cheng 	/*
8224eaa4710SRishi Srivatsavai 	 * Send a MAC_NOTE_LINK notification.  Only upper notifications are
8234eaa4710SRishi Srivatsavai 	 * made.
824da14cebeSEric Cheng 	 */
825da14cebeSEric Cheng 	i_mac_notify(mip, MAC_NOTE_LINK);
826da14cebeSEric Cheng }
827da14cebeSEric Cheng 
82861af1958SGarrett D'Amore /* MINOR NODE HANDLING */
82961af1958SGarrett D'Amore 
83061af1958SGarrett D'Amore /*
83161af1958SGarrett D'Amore  * Given a dev_t, return the instance number (PPA) associated with it.
83261af1958SGarrett D'Amore  * Drivers can use this in their getinfo(9e) implementation to lookup
83361af1958SGarrett D'Amore  * the instance number (i.e. PPA) of the device, to use as an index to
83461af1958SGarrett D'Amore  * their own array of soft state structures.
83561af1958SGarrett D'Amore  *
83661af1958SGarrett D'Amore  * Returns -1 on error.
83761af1958SGarrett D'Amore  */
83861af1958SGarrett D'Amore int
mac_devt_to_instance(dev_t devt)83961af1958SGarrett D'Amore mac_devt_to_instance(dev_t devt)
84061af1958SGarrett D'Amore {
84161af1958SGarrett D'Amore 	return (dld_devt_to_instance(devt));
84261af1958SGarrett D'Amore }
84361af1958SGarrett D'Amore 
84461af1958SGarrett D'Amore /*
84561af1958SGarrett D'Amore  * This function returns the first minor number that is available for
84661af1958SGarrett D'Amore  * driver private use.  All minor numbers smaller than this are
84761af1958SGarrett D'Amore  * reserved for GLDv3 use.
84861af1958SGarrett D'Amore  */
84961af1958SGarrett D'Amore minor_t
mac_private_minor(void)85061af1958SGarrett D'Amore mac_private_minor(void)
85161af1958SGarrett D'Amore {
85261af1958SGarrett D'Amore 	return (MAC_PRIVATE_MINOR);
85361af1958SGarrett D'Amore }
85461af1958SGarrett D'Amore 
855da14cebeSEric Cheng /* OTHER CONTROL INFORMATION */
856da14cebeSEric Cheng 
857da14cebeSEric Cheng /*
858da14cebeSEric Cheng  * A driver notified us that its primary MAC address has changed.
859da14cebeSEric Cheng  */
860da14cebeSEric Cheng void
mac_unicst_update(mac_handle_t mh,const uint8_t * addr)861da14cebeSEric Cheng mac_unicst_update(mac_handle_t mh, const uint8_t *addr)
862da14cebeSEric Cheng {
863da14cebeSEric Cheng 	mac_impl_t	*mip = (mac_impl_t *)mh;
864da14cebeSEric Cheng 
865da14cebeSEric Cheng 	if (mip->mi_type->mt_addr_length == 0)
866da14cebeSEric Cheng 		return;
867da14cebeSEric Cheng 
868da14cebeSEric Cheng 	i_mac_perim_enter(mip);
869da14cebeSEric Cheng 
870da14cebeSEric Cheng 	/*
871fd0939efSDavid Edmondson 	 * If address changes, freshen the MAC address value and update
872fd0939efSDavid Edmondson 	 * all MAC clients that share this MAC address.
873da14cebeSEric Cheng 	 */
874fd0939efSDavid Edmondson 	if (bcmp(addr, mip->mi_addr, mip->mi_type->mt_addr_length) != 0) {
875da14cebeSEric Cheng 		mac_freshen_macaddr(mac_find_macaddr(mip, mip->mi_addr),
876da14cebeSEric Cheng 		    (uint8_t *)addr);
877fd0939efSDavid Edmondson 	}
878da14cebeSEric Cheng 
879da14cebeSEric Cheng 	i_mac_perim_exit(mip);
880da14cebeSEric Cheng 
881da14cebeSEric Cheng 	/*
882da14cebeSEric Cheng 	 * Send a MAC_NOTE_UNICST notification.
883da14cebeSEric Cheng 	 */
884da14cebeSEric Cheng 	i_mac_notify(mip, MAC_NOTE_UNICST);
885da14cebeSEric Cheng }
886da14cebeSEric Cheng 
8872b24ab6bSSebastien Roy void
mac_dst_update(mac_handle_t mh,const uint8_t * addr)8882b24ab6bSSebastien Roy mac_dst_update(mac_handle_t mh, const uint8_t *addr)
8892b24ab6bSSebastien Roy {
8902b24ab6bSSebastien Roy 	mac_impl_t	*mip = (mac_impl_t *)mh;
8912b24ab6bSSebastien Roy 
8922b24ab6bSSebastien Roy 	if (mip->mi_type->mt_addr_length == 0)
8932b24ab6bSSebastien Roy 		return;
8942b24ab6bSSebastien Roy 
8952b24ab6bSSebastien Roy 	i_mac_perim_enter(mip);
8962b24ab6bSSebastien Roy 	bcopy(addr, mip->mi_dstaddr, mip->mi_type->mt_addr_length);
8972b24ab6bSSebastien Roy 	i_mac_perim_exit(mip);
8982b24ab6bSSebastien Roy 	i_mac_notify(mip, MAC_NOTE_DEST);
8992b24ab6bSSebastien Roy }
9002b24ab6bSSebastien Roy 
901da14cebeSEric Cheng /*
902da14cebeSEric Cheng  * MAC plugin information changed.
903da14cebeSEric Cheng  */
904da14cebeSEric Cheng int
mac_pdata_update(mac_handle_t mh,void * mac_pdata,size_t dsize)905da14cebeSEric Cheng mac_pdata_update(mac_handle_t mh, void *mac_pdata, size_t dsize)
906da14cebeSEric Cheng {
907da14cebeSEric Cheng 	mac_impl_t	*mip = (mac_impl_t *)mh;
908da14cebeSEric Cheng 
909da14cebeSEric Cheng 	/*
910da14cebeSEric Cheng 	 * Verify that the plugin supports MAC plugin data and that the
911da14cebeSEric Cheng 	 * supplied data is valid.
912da14cebeSEric Cheng 	 */
913da14cebeSEric Cheng 	if (!(mip->mi_type->mt_ops.mtops_ops & MTOPS_PDATA_VERIFY))
914da14cebeSEric Cheng 		return (EINVAL);
915da14cebeSEric Cheng 	if (!mip->mi_type->mt_ops.mtops_pdata_verify(mac_pdata, dsize))
916da14cebeSEric Cheng 		return (EINVAL);
917da14cebeSEric Cheng 
918da14cebeSEric Cheng 	if (mip->mi_pdata != NULL)
919da14cebeSEric Cheng 		kmem_free(mip->mi_pdata, mip->mi_pdata_size);
920da14cebeSEric Cheng 
921da14cebeSEric Cheng 	mip->mi_pdata = kmem_alloc(dsize, KM_SLEEP);
922da14cebeSEric Cheng 	bcopy(mac_pdata, mip->mi_pdata, dsize);
923da14cebeSEric Cheng 	mip->mi_pdata_size = dsize;
924da14cebeSEric Cheng 
925da14cebeSEric Cheng 	/*
926da14cebeSEric Cheng 	 * Since the MAC plugin data is used to construct MAC headers that
927da14cebeSEric Cheng 	 * were cached in fast-path headers, we need to flush fast-path
928da14cebeSEric Cheng 	 * information for links associated with this mac.
929da14cebeSEric Cheng 	 */
930da14cebeSEric Cheng 	i_mac_notify(mip, MAC_NOTE_FASTPATH_FLUSH);
931da14cebeSEric Cheng 	return (0);
932da14cebeSEric Cheng }
933da14cebeSEric Cheng 
934da14cebeSEric Cheng /*
935da14cebeSEric Cheng  * Invoked by driver as well as the framework to notify its capability change.
936da14cebeSEric Cheng  */
937da14cebeSEric Cheng void
mac_capab_update(mac_handle_t mh)938da14cebeSEric Cheng mac_capab_update(mac_handle_t mh)
939da14cebeSEric Cheng {
940da14cebeSEric Cheng 	/* Send MAC_NOTE_CAPAB_CHG notification */
941da14cebeSEric Cheng 	i_mac_notify((mac_impl_t *)mh, MAC_NOTE_CAPAB_CHG);
942da14cebeSEric Cheng }
943da14cebeSEric Cheng 
9441eee170aSErik Nordmark /*
9451eee170aSErik Nordmark  * Used by normal drivers to update the max sdu size.
9461eee170aSErik Nordmark  * We need to handle the case of a smaller mi_sdu_multicast
9471eee170aSErik Nordmark  * since this is called by mac_set_mtu() even for drivers that
9481eee170aSErik Nordmark  * have differing unicast and multicast mtu and we don't want to
9491eee170aSErik Nordmark  * increase the multicast mtu by accident in that case.
9501eee170aSErik Nordmark  */
951da14cebeSEric Cheng int
mac_maxsdu_update(mac_handle_t mh,uint_t sdu_max)952da14cebeSEric Cheng mac_maxsdu_update(mac_handle_t mh, uint_t sdu_max)
953da14cebeSEric Cheng {
954da14cebeSEric Cheng 	mac_impl_t	*mip = (mac_impl_t *)mh;
955da14cebeSEric Cheng 
956f0f2c3a5SGirish Moodalbail 	if (sdu_max == 0 || sdu_max < mip->mi_sdu_min)
957da14cebeSEric Cheng 		return (EINVAL);
958da14cebeSEric Cheng 	mip->mi_sdu_max = sdu_max;
9591eee170aSErik Nordmark 	if (mip->mi_sdu_multicast > mip->mi_sdu_max)
9601eee170aSErik Nordmark 		mip->mi_sdu_multicast = mip->mi_sdu_max;
9611eee170aSErik Nordmark 
9621eee170aSErik Nordmark 	/* Send a MAC_NOTE_SDU_SIZE notification. */
9631eee170aSErik Nordmark 	i_mac_notify(mip, MAC_NOTE_SDU_SIZE);
9641eee170aSErik Nordmark 	return (0);
9651eee170aSErik Nordmark }
9661eee170aSErik Nordmark 
9671eee170aSErik Nordmark /*
9681eee170aSErik Nordmark  * Version of the above function that is used by drivers that have a different
9691eee170aSErik Nordmark  * max sdu size for multicast/broadcast vs. unicast.
9701eee170aSErik Nordmark  */
9711eee170aSErik Nordmark int
mac_maxsdu_update2(mac_handle_t mh,uint_t sdu_max,uint_t sdu_multicast)9721eee170aSErik Nordmark mac_maxsdu_update2(mac_handle_t mh, uint_t sdu_max, uint_t sdu_multicast)
9731eee170aSErik Nordmark {
9741eee170aSErik Nordmark 	mac_impl_t	*mip = (mac_impl_t *)mh;
9751eee170aSErik Nordmark 
9761eee170aSErik Nordmark 	if (sdu_max == 0 || sdu_max < mip->mi_sdu_min)
9771eee170aSErik Nordmark 		return (EINVAL);
9781eee170aSErik Nordmark 	if (sdu_multicast == 0)
9791eee170aSErik Nordmark 		sdu_multicast = sdu_max;
9801eee170aSErik Nordmark 	if (sdu_multicast > sdu_max || sdu_multicast < mip->mi_sdu_min)
9811eee170aSErik Nordmark 		return (EINVAL);
9821eee170aSErik Nordmark 	mip->mi_sdu_max = sdu_max;
9831eee170aSErik Nordmark 	mip->mi_sdu_multicast = sdu_multicast;
984da14cebeSEric Cheng 
985da14cebeSEric Cheng 	/* Send a MAC_NOTE_SDU_SIZE notification. */
986da14cebeSEric Cheng 	i_mac_notify(mip, MAC_NOTE_SDU_SIZE);
987da14cebeSEric Cheng 	return (0);
988da14cebeSEric Cheng }
989da14cebeSEric Cheng 
9900dc2366fSVenugopal Iyer static void
mac_ring_intr_retarget(mac_group_t * group,mac_ring_t * ring)9910dc2366fSVenugopal Iyer mac_ring_intr_retarget(mac_group_t *group, mac_ring_t *ring)
9920dc2366fSVenugopal Iyer {
9930dc2366fSVenugopal Iyer 	mac_client_impl_t *mcip;
9940dc2366fSVenugopal Iyer 	flow_entry_t *flent;
9950dc2366fSVenugopal Iyer 	mac_soft_ring_set_t *mac_rx_srs;
9960dc2366fSVenugopal Iyer 	mac_cpus_t *srs_cpu;
9970dc2366fSVenugopal Iyer 	int i;
9980dc2366fSVenugopal Iyer 
9990dc2366fSVenugopal Iyer 	if (((mcip = MAC_GROUP_ONLY_CLIENT(group)) != NULL) &&
10000dc2366fSVenugopal Iyer 	    (!ring->mr_info.mri_intr.mi_ddi_shared)) {
10010dc2366fSVenugopal Iyer 		/* interrupt can be re-targeted */
10020dc2366fSVenugopal Iyer 		ASSERT(group->mrg_state == MAC_GROUP_STATE_RESERVED);
10030dc2366fSVenugopal Iyer 		flent = mcip->mci_flent;
10040dc2366fSVenugopal Iyer 		if (ring->mr_type == MAC_RING_TYPE_RX) {
10050dc2366fSVenugopal Iyer 			for (i = 0; i < flent->fe_rx_srs_cnt; i++) {
10060dc2366fSVenugopal Iyer 				mac_rx_srs = flent->fe_rx_srs[i];
10070dc2366fSVenugopal Iyer 				if (mac_rx_srs->srs_ring != ring)
10080dc2366fSVenugopal Iyer 					continue;
10090dc2366fSVenugopal Iyer 				srs_cpu = &mac_rx_srs->srs_cpu;
10100dc2366fSVenugopal Iyer 				mutex_enter(&cpu_lock);
10110dc2366fSVenugopal Iyer 				mac_rx_srs_retarget_intr(mac_rx_srs,
10120dc2366fSVenugopal Iyer 				    srs_cpu->mc_rx_intr_cpu);
10130dc2366fSVenugopal Iyer 				mutex_exit(&cpu_lock);
10140dc2366fSVenugopal Iyer 				break;
10150dc2366fSVenugopal Iyer 			}
10160dc2366fSVenugopal Iyer 		} else {
10170dc2366fSVenugopal Iyer 			if (flent->fe_tx_srs != NULL) {
10180dc2366fSVenugopal Iyer 				mutex_enter(&cpu_lock);
10190dc2366fSVenugopal Iyer 				mac_tx_srs_retarget_intr(
10200dc2366fSVenugopal Iyer 				    flent->fe_tx_srs);
10210dc2366fSVenugopal Iyer 				mutex_exit(&cpu_lock);
10220dc2366fSVenugopal Iyer 			}
10230dc2366fSVenugopal Iyer 		}
10240dc2366fSVenugopal Iyer 	}
10250dc2366fSVenugopal Iyer }
10260dc2366fSVenugopal Iyer 
10270dc2366fSVenugopal Iyer /*
10280dc2366fSVenugopal Iyer  * Clients like aggr create pseudo rings (mac_ring_t) and expose them to
10290dc2366fSVenugopal Iyer  * their clients. There is a 1-1 mapping pseudo ring and the hardware
10300dc2366fSVenugopal Iyer  * ring. ddi interrupt handles are exported from the hardware ring to
10310dc2366fSVenugopal Iyer  * the pseudo ring. Thus when the interrupt handle changes, clients of
10320dc2366fSVenugopal Iyer  * aggr that are using the handle need to use the new handle and
10330dc2366fSVenugopal Iyer  * re-target their interrupts.
10340dc2366fSVenugopal Iyer  */
10350dc2366fSVenugopal Iyer static void
mac_pseudo_ring_intr_retarget(mac_impl_t * mip,mac_ring_t * ring,ddi_intr_handle_t ddh)10360dc2366fSVenugopal Iyer mac_pseudo_ring_intr_retarget(mac_impl_t *mip, mac_ring_t *ring,
10370dc2366fSVenugopal Iyer     ddi_intr_handle_t ddh)
10380dc2366fSVenugopal Iyer {
10390dc2366fSVenugopal Iyer 	mac_ring_t *pring;
10400dc2366fSVenugopal Iyer 	mac_group_t *pgroup;
10410dc2366fSVenugopal Iyer 	mac_impl_t *pmip;
10420dc2366fSVenugopal Iyer 	char macname[MAXNAMELEN];
10430dc2366fSVenugopal Iyer 	mac_perim_handle_t p_mph;
10440dc2366fSVenugopal Iyer 	uint64_t saved_gen_num;
10450dc2366fSVenugopal Iyer 
10460dc2366fSVenugopal Iyer again:
10470dc2366fSVenugopal Iyer 	pring = (mac_ring_t *)ring->mr_prh;
10480dc2366fSVenugopal Iyer 	pgroup = (mac_group_t *)pring->mr_gh;
10490dc2366fSVenugopal Iyer 	pmip = (mac_impl_t *)pgroup->mrg_mh;
10500dc2366fSVenugopal Iyer 	saved_gen_num = ring->mr_gen_num;
10510dc2366fSVenugopal Iyer 	(void) strlcpy(macname, pmip->mi_name, MAXNAMELEN);
10520dc2366fSVenugopal Iyer 	/*
10530dc2366fSVenugopal Iyer 	 * We need to enter aggr's perimeter. The locking hierarchy
10540dc2366fSVenugopal Iyer 	 * dictates that aggr's perimeter should be entered first
10550dc2366fSVenugopal Iyer 	 * and then the port's perimeter. So drop the port's
10560dc2366fSVenugopal Iyer 	 * perimeter, enter aggr's and then re-enter port's
10570dc2366fSVenugopal Iyer 	 * perimeter.
10580dc2366fSVenugopal Iyer 	 */
10590dc2366fSVenugopal Iyer 	i_mac_perim_exit(mip);
10600dc2366fSVenugopal Iyer 	/*
10610dc2366fSVenugopal Iyer 	 * While we know pmip is the aggr's mip, there is a
10620dc2366fSVenugopal Iyer 	 * possibility that aggr could have unregistered by
10630dc2366fSVenugopal Iyer 	 * the time we exit port's perimeter (mip) and
10640dc2366fSVenugopal Iyer 	 * enter aggr's perimeter (pmip). To avoid that
10650dc2366fSVenugopal Iyer 	 * scenario, enter aggr's perimeter using its name.
10660dc2366fSVenugopal Iyer 	 */
10670dc2366fSVenugopal Iyer 	if (mac_perim_enter_by_macname(macname, &p_mph) != 0)
10680dc2366fSVenugopal Iyer 		return;
10690dc2366fSVenugopal Iyer 	i_mac_perim_enter(mip);
10700dc2366fSVenugopal Iyer 	/*
10710dc2366fSVenugopal Iyer 	 * Check if the ring got assigned to another aggregation before
10720dc2366fSVenugopal Iyer 	 * be could enter aggr's and the port's perimeter. When a ring
10730dc2366fSVenugopal Iyer 	 * gets deleted from an aggregation, it calls mac_stop_ring()
10740dc2366fSVenugopal Iyer 	 * which increments the generation number. So checking
10750dc2366fSVenugopal Iyer 	 * generation number will be enough.
10760dc2366fSVenugopal Iyer 	 */
10770dc2366fSVenugopal Iyer 	if (ring->mr_gen_num != saved_gen_num && ring->mr_prh != NULL) {
10780dc2366fSVenugopal Iyer 		i_mac_perim_exit(mip);
10790dc2366fSVenugopal Iyer 		mac_perim_exit(p_mph);
10800dc2366fSVenugopal Iyer 		i_mac_perim_enter(mip);
10810dc2366fSVenugopal Iyer 		goto again;
10820dc2366fSVenugopal Iyer 	}
10830dc2366fSVenugopal Iyer 
10840dc2366fSVenugopal Iyer 	/* Check if pseudo ring is still present */
10850dc2366fSVenugopal Iyer 	if (ring->mr_prh != NULL) {
10860dc2366fSVenugopal Iyer 		pring->mr_info.mri_intr.mi_ddi_handle = ddh;
10870dc2366fSVenugopal Iyer 		pring->mr_info.mri_intr.mi_ddi_shared =
10880dc2366fSVenugopal Iyer 		    ring->mr_info.mri_intr.mi_ddi_shared;
10890dc2366fSVenugopal Iyer 		if (ddh != NULL)
10900dc2366fSVenugopal Iyer 			mac_ring_intr_retarget(pgroup, pring);
10910dc2366fSVenugopal Iyer 	}
10920dc2366fSVenugopal Iyer 	i_mac_perim_exit(mip);
10930dc2366fSVenugopal Iyer 	mac_perim_exit(p_mph);
10940dc2366fSVenugopal Iyer }
10950dc2366fSVenugopal Iyer /*
10960dc2366fSVenugopal Iyer  * API called by driver to provide new interrupt handle for TX/RX rings.
10970dc2366fSVenugopal Iyer  * This usually happens when IRM (Interrupt Resource Manangement)
10980dc2366fSVenugopal Iyer  * framework either gives the driver more MSI-x interrupts or takes
10990dc2366fSVenugopal Iyer  * away MSI-x interrupts from the driver.
11000dc2366fSVenugopal Iyer  */
11010dc2366fSVenugopal Iyer void
mac_ring_intr_set(mac_ring_handle_t mrh,ddi_intr_handle_t ddh)11020dc2366fSVenugopal Iyer mac_ring_intr_set(mac_ring_handle_t mrh, ddi_intr_handle_t ddh)
11030dc2366fSVenugopal Iyer {
11040dc2366fSVenugopal Iyer 	mac_ring_t	*ring = (mac_ring_t *)mrh;
11050dc2366fSVenugopal Iyer 	mac_group_t	*group = (mac_group_t *)ring->mr_gh;
11060dc2366fSVenugopal Iyer 	mac_impl_t	*mip = (mac_impl_t *)group->mrg_mh;
11070dc2366fSVenugopal Iyer 
11080dc2366fSVenugopal Iyer 	i_mac_perim_enter(mip);
11090dc2366fSVenugopal Iyer 	ring->mr_info.mri_intr.mi_ddi_handle = ddh;
11100dc2366fSVenugopal Iyer 	if (ddh == NULL) {
11110dc2366fSVenugopal Iyer 		/* Interrupts being reset */
11120dc2366fSVenugopal Iyer 		ring->mr_info.mri_intr.mi_ddi_shared = B_FALSE;
11130dc2366fSVenugopal Iyer 		if (ring->mr_prh != NULL) {
11140dc2366fSVenugopal Iyer 			mac_pseudo_ring_intr_retarget(mip, ring, ddh);
11150dc2366fSVenugopal Iyer 			return;
11160dc2366fSVenugopal Iyer 		}
11170dc2366fSVenugopal Iyer 	} else {
11180dc2366fSVenugopal Iyer 		/* New interrupt handle */
11190dc2366fSVenugopal Iyer 		mac_compare_ddi_handle(mip->mi_rx_groups,
11200dc2366fSVenugopal Iyer 		    mip->mi_rx_group_count, ring);
11210dc2366fSVenugopal Iyer 		if (!ring->mr_info.mri_intr.mi_ddi_shared) {
11220dc2366fSVenugopal Iyer 			mac_compare_ddi_handle(mip->mi_tx_groups,
11230dc2366fSVenugopal Iyer 			    mip->mi_tx_group_count, ring);
11240dc2366fSVenugopal Iyer 		}
11250dc2366fSVenugopal Iyer 		if (ring->mr_prh != NULL) {
11260dc2366fSVenugopal Iyer 			mac_pseudo_ring_intr_retarget(mip, ring, ddh);
11270dc2366fSVenugopal Iyer 			return;
11280dc2366fSVenugopal Iyer 		} else {
11290dc2366fSVenugopal Iyer 			mac_ring_intr_retarget(group, ring);
11300dc2366fSVenugopal Iyer 		}
11310dc2366fSVenugopal Iyer 	}
11320dc2366fSVenugopal Iyer 	i_mac_perim_exit(mip);
11330dc2366fSVenugopal Iyer }
11340dc2366fSVenugopal Iyer 
1135da14cebeSEric Cheng /* PRIVATE FUNCTIONS, FOR INTERNAL USE ONLY */
1136da14cebeSEric Cheng 
1137da14cebeSEric Cheng /*
1138da14cebeSEric Cheng  * Updates the mac_impl structure with the current state of the link
1139da14cebeSEric Cheng  */
1140da14cebeSEric Cheng static void
i_mac_log_link_state(mac_impl_t * mip)1141da14cebeSEric Cheng i_mac_log_link_state(mac_impl_t *mip)
1142da14cebeSEric Cheng {
1143da14cebeSEric Cheng 	/*
1144da14cebeSEric Cheng 	 * If no change, then it is not interesting.
1145da14cebeSEric Cheng 	 */
11464eaa4710SRishi Srivatsavai 	if (mip->mi_lastlowlinkstate == mip->mi_lowlinkstate)
1147da14cebeSEric Cheng 		return;
1148da14cebeSEric Cheng 
11494eaa4710SRishi Srivatsavai 	switch (mip->mi_lowlinkstate) {
1150da14cebeSEric Cheng 	case LINK_STATE_UP:
1151da14cebeSEric Cheng 		if (mip->mi_type->mt_ops.mtops_ops & MTOPS_LINK_DETAILS) {
1152da14cebeSEric Cheng 			char det[200];
1153da14cebeSEric Cheng 
1154da14cebeSEric Cheng 			mip->mi_type->mt_ops.mtops_link_details(det,
1155da14cebeSEric Cheng 			    sizeof (det), (mac_handle_t)mip, mip->mi_pdata);
1156da14cebeSEric Cheng 
1157da14cebeSEric Cheng 			cmn_err(CE_NOTE, "!%s link up, %s", mip->mi_name, det);
1158da14cebeSEric Cheng 		} else {
1159da14cebeSEric Cheng 			cmn_err(CE_NOTE, "!%s link up", mip->mi_name);
1160da14cebeSEric Cheng 		}
1161da14cebeSEric Cheng 		break;
1162da14cebeSEric Cheng 
1163da14cebeSEric Cheng 	case LINK_STATE_DOWN:
1164da14cebeSEric Cheng 		/*
1165da14cebeSEric Cheng 		 * Only transitions from UP to DOWN are interesting
1166da14cebeSEric Cheng 		 */
11674eaa4710SRishi Srivatsavai 		if (mip->mi_lastlowlinkstate != LINK_STATE_UNKNOWN)
1168da14cebeSEric Cheng 			cmn_err(CE_NOTE, "!%s link down", mip->mi_name);
1169da14cebeSEric Cheng 		break;
1170da14cebeSEric Cheng 
1171da14cebeSEric Cheng 	case LINK_STATE_UNKNOWN:
1172da14cebeSEric Cheng 		/*
1173da14cebeSEric Cheng 		 * This case is normally not interesting.
1174da14cebeSEric Cheng 		 */
1175da14cebeSEric Cheng 		break;
1176da14cebeSEric Cheng 	}
11774eaa4710SRishi Srivatsavai 	mip->mi_lastlowlinkstate = mip->mi_lowlinkstate;
1178da14cebeSEric Cheng }
1179da14cebeSEric Cheng 
1180da14cebeSEric Cheng /*
1181da14cebeSEric Cheng  * Main routine for the callbacks notifications thread
1182da14cebeSEric Cheng  */
1183da14cebeSEric Cheng static void
i_mac_notify_thread(void * arg)1184da14cebeSEric Cheng i_mac_notify_thread(void *arg)
1185da14cebeSEric Cheng {
1186da14cebeSEric Cheng 	mac_impl_t	*mip = arg;
1187da14cebeSEric Cheng 	callb_cpr_t	cprinfo;
1188da14cebeSEric Cheng 	mac_cb_t	*mcb;
1189da14cebeSEric Cheng 	mac_cb_info_t	*mcbi;
1190da14cebeSEric Cheng 	mac_notify_cb_t	*mncb;
1191da14cebeSEric Cheng 
1192da14cebeSEric Cheng 	mcbi = &mip->mi_notify_cb_info;
1193da14cebeSEric Cheng 	CALLB_CPR_INIT(&cprinfo, mcbi->mcbi_lockp, callb_generic_cpr,
1194da14cebeSEric Cheng 	    "i_mac_notify_thread");
1195da14cebeSEric Cheng 
1196da14cebeSEric Cheng 	mutex_enter(mcbi->mcbi_lockp);
1197da14cebeSEric Cheng 
1198da14cebeSEric Cheng 	for (;;) {
1199da14cebeSEric Cheng 		uint32_t	bits;
1200da14cebeSEric Cheng 		uint32_t	type;
1201da14cebeSEric Cheng 
1202da14cebeSEric Cheng 		bits = mip->mi_notify_bits;
1203da14cebeSEric Cheng 		if (bits == 0) {
1204da14cebeSEric Cheng 			CALLB_CPR_SAFE_BEGIN(&cprinfo);
1205da14cebeSEric Cheng 			cv_wait(&mcbi->mcbi_cv, mcbi->mcbi_lockp);
1206da14cebeSEric Cheng 			CALLB_CPR_SAFE_END(&cprinfo, mcbi->mcbi_lockp);
1207da14cebeSEric Cheng 			continue;
1208da14cebeSEric Cheng 		}
1209da14cebeSEric Cheng 		mip->mi_notify_bits = 0;
1210da14cebeSEric Cheng 		if ((bits & (1 << MAC_NNOTE)) != 0) {
1211da14cebeSEric Cheng 			/* request to quit */
1212da14cebeSEric Cheng 			ASSERT(mip->mi_state_flags & MIS_DISABLED);
1213da14cebeSEric Cheng 			break;
1214da14cebeSEric Cheng 		}
1215da14cebeSEric Cheng 
1216da14cebeSEric Cheng 		mutex_exit(mcbi->mcbi_lockp);
1217da14cebeSEric Cheng 
1218da14cebeSEric Cheng 		/*
12194eaa4710SRishi Srivatsavai 		 * Log link changes on the actual link, but then do reports on
12204eaa4710SRishi Srivatsavai 		 * synthetic state (if part of a bridge).
1221da14cebeSEric Cheng 		 */
12224eaa4710SRishi Srivatsavai 		if ((bits & (1 << MAC_NOTE_LOWLINK)) != 0) {
12234eaa4710SRishi Srivatsavai 			link_state_t newstate;
12244eaa4710SRishi Srivatsavai 			mac_handle_t mh;
12254eaa4710SRishi Srivatsavai 
1226da14cebeSEric Cheng 			i_mac_log_link_state(mip);
12274eaa4710SRishi Srivatsavai 			newstate = mip->mi_lowlinkstate;
12284eaa4710SRishi Srivatsavai 			if (mip->mi_bridge_link != NULL) {
12294eaa4710SRishi Srivatsavai 				mutex_enter(&mip->mi_bridge_lock);
12304eaa4710SRishi Srivatsavai 				if ((mh = mip->mi_bridge_link) != NULL) {
12314eaa4710SRishi Srivatsavai 					newstate = mac_bridge_ls_cb(mh,
12324eaa4710SRishi Srivatsavai 					    newstate);
12334eaa4710SRishi Srivatsavai 				}
12344eaa4710SRishi Srivatsavai 				mutex_exit(&mip->mi_bridge_lock);
12354eaa4710SRishi Srivatsavai 			}
12364eaa4710SRishi Srivatsavai 			if (newstate != mip->mi_linkstate) {
12374eaa4710SRishi Srivatsavai 				mip->mi_linkstate = newstate;
12384eaa4710SRishi Srivatsavai 				bits |= 1 << MAC_NOTE_LINK;
12394eaa4710SRishi Srivatsavai 			}
12404eaa4710SRishi Srivatsavai 		}
1241da14cebeSEric Cheng 
1242da14cebeSEric Cheng 		/*
1243da14cebeSEric Cheng 		 * Do notification callbacks for each notification type.
1244da14cebeSEric Cheng 		 */
1245da14cebeSEric Cheng 		for (type = 0; type < MAC_NNOTE; type++) {
1246da14cebeSEric Cheng 			if ((bits & (1 << type)) == 0) {
1247da14cebeSEric Cheng 				continue;
1248da14cebeSEric Cheng 			}
1249da14cebeSEric Cheng 
12504eaa4710SRishi Srivatsavai 			if (mac_notify_cb_list[type] != NULL)
12514eaa4710SRishi Srivatsavai 				(*mac_notify_cb_list[type])(mip);
1252da14cebeSEric Cheng 
1253da14cebeSEric Cheng 			/*
1254da14cebeSEric Cheng 			 * Walk the list of notifications.
1255da14cebeSEric Cheng 			 */
1256da14cebeSEric Cheng 			MAC_CALLBACK_WALKER_INC(&mip->mi_notify_cb_info);
1257da14cebeSEric Cheng 			for (mcb = mip->mi_notify_cb_list; mcb != NULL;
1258da14cebeSEric Cheng 			    mcb = mcb->mcb_nextp) {
1259da14cebeSEric Cheng 				mncb = (mac_notify_cb_t *)mcb->mcb_objp;
1260da14cebeSEric Cheng 				mncb->mncb_fn(mncb->mncb_arg, type);
1261da14cebeSEric Cheng 			}
1262da14cebeSEric Cheng 			MAC_CALLBACK_WALKER_DCR(&mip->mi_notify_cb_info,
1263da14cebeSEric Cheng 			    &mip->mi_notify_cb_list);
1264da14cebeSEric Cheng 		}
1265da14cebeSEric Cheng 
1266da14cebeSEric Cheng 		mutex_enter(mcbi->mcbi_lockp);
1267da14cebeSEric Cheng 	}
1268da14cebeSEric Cheng 
1269da14cebeSEric Cheng 	mip->mi_state_flags |= MIS_NOTIFY_DONE;
1270da14cebeSEric Cheng 	cv_broadcast(&mcbi->mcbi_cv);
1271da14cebeSEric Cheng 
1272da14cebeSEric Cheng 	/* CALLB_CPR_EXIT drops the lock */
1273da14cebeSEric Cheng 	CALLB_CPR_EXIT(&cprinfo);
1274da14cebeSEric Cheng 	thread_exit();
1275da14cebeSEric Cheng }
1276da14cebeSEric Cheng 
1277da14cebeSEric Cheng /*
1278da14cebeSEric Cheng  * Signal the i_mac_notify_thread asking it to quit.
1279da14cebeSEric Cheng  * Then wait till it is done.
1280da14cebeSEric Cheng  */
1281da14cebeSEric Cheng void
i_mac_notify_exit(mac_impl_t * mip)1282da14cebeSEric Cheng i_mac_notify_exit(mac_impl_t *mip)
1283da14cebeSEric Cheng {
1284da14cebeSEric Cheng 	mac_cb_info_t	*mcbi;
1285da14cebeSEric Cheng 
1286da14cebeSEric Cheng 	mcbi = &mip->mi_notify_cb_info;
1287da14cebeSEric Cheng 
1288da14cebeSEric Cheng 	mutex_enter(mcbi->mcbi_lockp);
1289da14cebeSEric Cheng 	mip->mi_notify_bits = (1 << MAC_NNOTE);
1290da14cebeSEric Cheng 	cv_broadcast(&mcbi->mcbi_cv);
1291da14cebeSEric Cheng 
1292da14cebeSEric Cheng 
1293da14cebeSEric Cheng 	while ((mip->mi_notify_thread != NULL) &&
1294da14cebeSEric Cheng 	    !(mip->mi_state_flags & MIS_NOTIFY_DONE)) {
1295da14cebeSEric Cheng 		cv_wait(&mcbi->mcbi_cv, mcbi->mcbi_lockp);
1296da14cebeSEric Cheng 	}
1297da14cebeSEric Cheng 
1298da14cebeSEric Cheng 	/* Necessary clean up before doing kmem_cache_free */
1299da14cebeSEric Cheng 	mip->mi_state_flags &= ~MIS_NOTIFY_DONE;
1300da14cebeSEric Cheng 	mip->mi_notify_bits = 0;
1301da14cebeSEric Cheng 	mip->mi_notify_thread = NULL;
1302da14cebeSEric Cheng 	mutex_exit(mcbi->mcbi_lockp);
1303da14cebeSEric Cheng }
1304da14cebeSEric Cheng 
1305da14cebeSEric Cheng /*
1306da14cebeSEric Cheng  * Entry point invoked by drivers to dynamically add a ring to an
1307da14cebeSEric Cheng  * existing group.
1308da14cebeSEric Cheng  */
1309da14cebeSEric Cheng int
mac_group_add_ring(mac_group_handle_t gh,int index)1310da14cebeSEric Cheng mac_group_add_ring(mac_group_handle_t gh, int index)
1311da14cebeSEric Cheng {
1312da14cebeSEric Cheng 	mac_group_t *group = (mac_group_t *)gh;
1313da14cebeSEric Cheng 	mac_impl_t *mip = (mac_impl_t *)group->mrg_mh;
1314da14cebeSEric Cheng 	int ret;
1315da14cebeSEric Cheng 
1316da14cebeSEric Cheng 	i_mac_perim_enter(mip);
1317da14cebeSEric Cheng 	ret = i_mac_group_add_ring(group, NULL, index);
1318da14cebeSEric Cheng 	i_mac_perim_exit(mip);
1319da14cebeSEric Cheng 	return (ret);
1320da14cebeSEric Cheng }
1321da14cebeSEric Cheng 
1322da14cebeSEric Cheng /*
1323da14cebeSEric Cheng  * Entry point invoked by drivers to dynamically remove a ring
1324da14cebeSEric Cheng  * from an existing group. The specified ring handle must no longer
1325da14cebeSEric Cheng  * be used by the driver after a call to this function.
1326da14cebeSEric Cheng  */
1327da14cebeSEric Cheng void
mac_group_rem_ring(mac_group_handle_t gh,mac_ring_handle_t rh)1328da14cebeSEric Cheng mac_group_rem_ring(mac_group_handle_t gh, mac_ring_handle_t rh)
1329da14cebeSEric Cheng {
1330da14cebeSEric Cheng 	mac_group_t *group = (mac_group_t *)gh;
1331da14cebeSEric Cheng 	mac_impl_t *mip = (mac_impl_t *)group->mrg_mh;
1332da14cebeSEric Cheng 
1333da14cebeSEric Cheng 	i_mac_perim_enter(mip);
13340dc2366fSVenugopal Iyer 	i_mac_group_rem_ring(group, (mac_ring_t *)rh, B_TRUE);
13350dc2366fSVenugopal Iyer 	i_mac_perim_exit(mip);
13360dc2366fSVenugopal Iyer }
1337da14cebeSEric Cheng 
1338da14cebeSEric Cheng /*
13390dc2366fSVenugopal Iyer  * mac_prop_info_*() callbacks called from the driver's prefix_propinfo()
13400dc2366fSVenugopal Iyer  * entry points.
1341da14cebeSEric Cheng  */
1342da14cebeSEric Cheng 
13430dc2366fSVenugopal Iyer void
mac_prop_info_set_default_uint8(mac_prop_info_handle_t ph,uint8_t val)13440dc2366fSVenugopal Iyer mac_prop_info_set_default_uint8(mac_prop_info_handle_t ph, uint8_t val)
13450dc2366fSVenugopal Iyer {
13460dc2366fSVenugopal Iyer 	mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph;
1347da14cebeSEric Cheng 
13480dc2366fSVenugopal Iyer 	/* nothing to do if the caller doesn't want the default value */
13490dc2366fSVenugopal Iyer 	if (pr->pr_default == NULL)
13500dc2366fSVenugopal Iyer 		return;
13510dc2366fSVenugopal Iyer 
13520dc2366fSVenugopal Iyer 	ASSERT(pr->pr_default_size >= sizeof (uint8_t));
13530dc2366fSVenugopal Iyer 
13540dc2366fSVenugopal Iyer 	*(uint8_t *)(pr->pr_default) = val;
13550dc2366fSVenugopal Iyer 	pr->pr_flags |= MAC_PROP_INFO_DEFAULT;
13560dc2366fSVenugopal Iyer }
13570dc2366fSVenugopal Iyer 
13580dc2366fSVenugopal Iyer void
mac_prop_info_set_default_uint64(mac_prop_info_handle_t ph,uint64_t val)13590dc2366fSVenugopal Iyer mac_prop_info_set_default_uint64(mac_prop_info_handle_t ph, uint64_t val)
13600dc2366fSVenugopal Iyer {
13610dc2366fSVenugopal Iyer 	mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph;
13620dc2366fSVenugopal Iyer 
13630dc2366fSVenugopal Iyer 	/* nothing to do if the caller doesn't want the default value */
13640dc2366fSVenugopal Iyer 	if (pr->pr_default == NULL)
13650dc2366fSVenugopal Iyer 		return;
13660dc2366fSVenugopal Iyer 
13670dc2366fSVenugopal Iyer 	ASSERT(pr->pr_default_size >= sizeof (uint64_t));
13680dc2366fSVenugopal Iyer 
13690dc2366fSVenugopal Iyer 	bcopy(&val, pr->pr_default, sizeof (val));
13700dc2366fSVenugopal Iyer 
13710dc2366fSVenugopal Iyer 	pr->pr_flags |= MAC_PROP_INFO_DEFAULT;
13720dc2366fSVenugopal Iyer }
13730dc2366fSVenugopal Iyer 
13740dc2366fSVenugopal Iyer void
mac_prop_info_set_default_uint32(mac_prop_info_handle_t ph,uint32_t val)13750dc2366fSVenugopal Iyer mac_prop_info_set_default_uint32(mac_prop_info_handle_t ph, uint32_t val)
13760dc2366fSVenugopal Iyer {
13770dc2366fSVenugopal Iyer 	mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph;
13780dc2366fSVenugopal Iyer 
13790dc2366fSVenugopal Iyer 	/* nothing to do if the caller doesn't want the default value */
13800dc2366fSVenugopal Iyer 	if (pr->pr_default == NULL)
13810dc2366fSVenugopal Iyer 		return;
13820dc2366fSVenugopal Iyer 
13830dc2366fSVenugopal Iyer 	ASSERT(pr->pr_default_size >= sizeof (uint32_t));
13840dc2366fSVenugopal Iyer 
13850dc2366fSVenugopal Iyer 	bcopy(&val, pr->pr_default, sizeof (val));
13860dc2366fSVenugopal Iyer 
13870dc2366fSVenugopal Iyer 	pr->pr_flags |= MAC_PROP_INFO_DEFAULT;
13880dc2366fSVenugopal Iyer }
13890dc2366fSVenugopal Iyer 
13900dc2366fSVenugopal Iyer void
mac_prop_info_set_default_str(mac_prop_info_handle_t ph,const char * str)13910dc2366fSVenugopal Iyer mac_prop_info_set_default_str(mac_prop_info_handle_t ph, const char *str)
13920dc2366fSVenugopal Iyer {
13930dc2366fSVenugopal Iyer 	mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph;
13940dc2366fSVenugopal Iyer 
13950dc2366fSVenugopal Iyer 	/* nothing to do if the caller doesn't want the default value */
13960dc2366fSVenugopal Iyer 	if (pr->pr_default == NULL)
13970dc2366fSVenugopal Iyer 		return;
13980dc2366fSVenugopal Iyer 
1399f689bed1SRishi Srivatsavai 	if (strlen(str) >= pr->pr_default_size)
14000591ddd0SPrakash Jalan 		pr->pr_errno = ENOBUFS;
14010dc2366fSVenugopal Iyer 	else
1402f689bed1SRishi Srivatsavai 		(void) strlcpy(pr->pr_default, str, pr->pr_default_size);
14030dc2366fSVenugopal Iyer 	pr->pr_flags |= MAC_PROP_INFO_DEFAULT;
14040dc2366fSVenugopal Iyer }
14050dc2366fSVenugopal Iyer 
14060dc2366fSVenugopal Iyer void
mac_prop_info_set_default_link_flowctrl(mac_prop_info_handle_t ph,link_flowctrl_t val)14070dc2366fSVenugopal Iyer mac_prop_info_set_default_link_flowctrl(mac_prop_info_handle_t ph,
14080dc2366fSVenugopal Iyer     link_flowctrl_t val)
14090dc2366fSVenugopal Iyer {
14100dc2366fSVenugopal Iyer 	mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph;
14110dc2366fSVenugopal Iyer 
14120dc2366fSVenugopal Iyer 	/* nothing to do if the caller doesn't want the default value */
14130dc2366fSVenugopal Iyer 	if (pr->pr_default == NULL)
14140dc2366fSVenugopal Iyer 		return;
14150dc2366fSVenugopal Iyer 
14160dc2366fSVenugopal Iyer 	ASSERT(pr->pr_default_size >= sizeof (link_flowctrl_t));
14170dc2366fSVenugopal Iyer 
14180dc2366fSVenugopal Iyer 	bcopy(&val, pr->pr_default, sizeof (val));
14190dc2366fSVenugopal Iyer 
14200dc2366fSVenugopal Iyer 	pr->pr_flags |= MAC_PROP_INFO_DEFAULT;
14210dc2366fSVenugopal Iyer }
14220dc2366fSVenugopal Iyer 
14230dc2366fSVenugopal Iyer void
mac_prop_info_set_range_uint32(mac_prop_info_handle_t ph,uint32_t min,uint32_t max)14240dc2366fSVenugopal Iyer mac_prop_info_set_range_uint32(mac_prop_info_handle_t ph, uint32_t min,
14250dc2366fSVenugopal Iyer     uint32_t max)
14260dc2366fSVenugopal Iyer {
14270dc2366fSVenugopal Iyer 	mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph;
14280dc2366fSVenugopal Iyer 	mac_propval_range_t *range = pr->pr_range;
14290591ddd0SPrakash Jalan 	mac_propval_uint32_range_t *range32;
14300dc2366fSVenugopal Iyer 
14310dc2366fSVenugopal Iyer 	/* nothing to do if the caller doesn't want the range info */
14320dc2366fSVenugopal Iyer 	if (range == NULL)
14330dc2366fSVenugopal Iyer 		return;
14340dc2366fSVenugopal Iyer 
14350591ddd0SPrakash Jalan 	if (pr->pr_range_cur_count++ == 0) {
14360591ddd0SPrakash Jalan 		/* first range */
14370dc2366fSVenugopal Iyer 		pr->pr_flags |= MAC_PROP_INFO_RANGE;
14380591ddd0SPrakash Jalan 		range->mpr_type = MAC_PROPVAL_UINT32;
14390591ddd0SPrakash Jalan 	} else {
14400591ddd0SPrakash Jalan 		/* all ranges of a property should be of the same type */
14410591ddd0SPrakash Jalan 		ASSERT(range->mpr_type == MAC_PROPVAL_UINT32);
14420591ddd0SPrakash Jalan 		if (pr->pr_range_cur_count > range->mpr_count) {
14430591ddd0SPrakash Jalan 			pr->pr_errno = ENOSPC;
14440591ddd0SPrakash Jalan 			return;
14450591ddd0SPrakash Jalan 		}
14460591ddd0SPrakash Jalan 	}
14470591ddd0SPrakash Jalan 
14480591ddd0SPrakash Jalan 	range32 = range->mpr_range_uint32;
14490591ddd0SPrakash Jalan 	range32[pr->pr_range_cur_count - 1].mpur_min = min;
14500591ddd0SPrakash Jalan 	range32[pr->pr_range_cur_count - 1].mpur_max = max;
14510dc2366fSVenugopal Iyer }
14520dc2366fSVenugopal Iyer 
14530dc2366fSVenugopal Iyer void
mac_prop_info_set_perm(mac_prop_info_handle_t ph,uint8_t perm)14540dc2366fSVenugopal Iyer mac_prop_info_set_perm(mac_prop_info_handle_t ph, uint8_t perm)
14550dc2366fSVenugopal Iyer {
14560dc2366fSVenugopal Iyer 	mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph;
14570dc2366fSVenugopal Iyer 
14580dc2366fSVenugopal Iyer 	pr->pr_perm = perm;
14590dc2366fSVenugopal Iyer 	pr->pr_flags |= MAC_PROP_INFO_PERM;
14600dc2366fSVenugopal Iyer }
14610dc2366fSVenugopal Iyer 
mac_hcksum_get(mblk_t * mp,uint32_t * start,uint32_t * stuff,uint32_t * end,uint32_t * value,uint32_t * flags_ptr)14620dc2366fSVenugopal Iyer void mac_hcksum_get(mblk_t *mp, uint32_t *start, uint32_t *stuff,
14630dc2366fSVenugopal Iyer     uint32_t *end, uint32_t *value, uint32_t *flags_ptr)
14640dc2366fSVenugopal Iyer {
14650dc2366fSVenugopal Iyer 	uint32_t flags;
14660dc2366fSVenugopal Iyer 
14670dc2366fSVenugopal Iyer 	ASSERT(DB_TYPE(mp) == M_DATA);
14680dc2366fSVenugopal Iyer 
14690dc2366fSVenugopal Iyer 	flags = DB_CKSUMFLAGS(mp) & HCK_FLAGS;
14700dc2366fSVenugopal Iyer 	if ((flags & (HCK_PARTIALCKSUM | HCK_FULLCKSUM)) != 0) {
14710dc2366fSVenugopal Iyer 		if (value != NULL)
14720dc2366fSVenugopal Iyer 			*value = (uint32_t)DB_CKSUM16(mp);
14730dc2366fSVenugopal Iyer 		if ((flags & HCK_PARTIALCKSUM) != 0) {
14740dc2366fSVenugopal Iyer 			if (start != NULL)
14750dc2366fSVenugopal Iyer 				*start = (uint32_t)DB_CKSUMSTART(mp);
14760dc2366fSVenugopal Iyer 			if (stuff != NULL)
14770dc2366fSVenugopal Iyer 				*stuff = (uint32_t)DB_CKSUMSTUFF(mp);
14780dc2366fSVenugopal Iyer 			if (end != NULL)
14790dc2366fSVenugopal Iyer 				*end = (uint32_t)DB_CKSUMEND(mp);
14800dc2366fSVenugopal Iyer 		}
14810dc2366fSVenugopal Iyer 	}
14820dc2366fSVenugopal Iyer 
14830dc2366fSVenugopal Iyer 	if (flags_ptr != NULL)
14840dc2366fSVenugopal Iyer 		*flags_ptr = flags;
14850dc2366fSVenugopal Iyer }
14860dc2366fSVenugopal Iyer 
mac_hcksum_set(mblk_t * mp,uint32_t start,uint32_t stuff,uint32_t end,uint32_t value,uint32_t flags)14870dc2366fSVenugopal Iyer void mac_hcksum_set(mblk_t *mp, uint32_t start, uint32_t stuff,
14880dc2366fSVenugopal Iyer     uint32_t end, uint32_t value, uint32_t flags)
14890dc2366fSVenugopal Iyer {
14900dc2366fSVenugopal Iyer 	ASSERT(DB_TYPE(mp) == M_DATA);
14910dc2366fSVenugopal Iyer 
14920dc2366fSVenugopal Iyer 	DB_CKSUMSTART(mp) = (intptr_t)start;
14930dc2366fSVenugopal Iyer 	DB_CKSUMSTUFF(mp) = (intptr_t)stuff;
14940dc2366fSVenugopal Iyer 	DB_CKSUMEND(mp) = (intptr_t)end;
14950dc2366fSVenugopal Iyer 	DB_CKSUMFLAGS(mp) = (uint16_t)flags;
14960dc2366fSVenugopal Iyer 	DB_CKSUM16(mp) = (uint16_t)value;
14970dc2366fSVenugopal Iyer }
14980dc2366fSVenugopal Iyer 
14990dc2366fSVenugopal Iyer void
mac_lso_get(mblk_t * mp,uint32_t * mss,uint32_t * flags)15000dc2366fSVenugopal Iyer mac_lso_get(mblk_t *mp, uint32_t *mss, uint32_t *flags)
15010dc2366fSVenugopal Iyer {
15020dc2366fSVenugopal Iyer 	ASSERT(DB_TYPE(mp) == M_DATA);
15030dc2366fSVenugopal Iyer 
15040dc2366fSVenugopal Iyer 	if (flags != NULL) {
15050dc2366fSVenugopal Iyer 		*flags = DB_CKSUMFLAGS(mp) & HW_LSO;
15060dc2366fSVenugopal Iyer 		if ((*flags != 0) && (mss != NULL))
15070dc2366fSVenugopal Iyer 			*mss = (uint32_t)DB_LSOMSS(mp);
15080dc2366fSVenugopal Iyer 	}
1509da14cebeSEric Cheng }
1510