xref: /illumos-gate/usr/src/uts/common/io/nxge/nxge_ndd.c (revision 48056c53)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/nxge/nxge_impl.h>
27 #include <sys/nxge/nxge_hio.h>
28 
29 #include <inet/common.h>
30 #include <inet/mi.h>
31 #include <inet/nd.h>
32 
33 extern uint64_t npi_debug_level;
34 
35 #define	NXGE_PARAM_MAC_RW \
36 	NXGE_PARAM_RW | NXGE_PARAM_MAC | \
37 	NXGE_PARAM_NDD_WR_OK | NXGE_PARAM_READ_PROP
38 
39 #define	NXGE_PARAM_MAC_DONT_SHOW \
40 	NXGE_PARAM_RW | NXGE_PARAM_MAC | NXGE_PARAM_DONT_SHOW
41 
42 #define	NXGE_PARAM_RXDMA_RW \
43 	NXGE_PARAM_RWP | NXGE_PARAM_RXDMA | NXGE_PARAM_NDD_WR_OK | \
44 	NXGE_PARAM_READ_PROP
45 
46 #define	NXGE_PARAM_RXDMA_RWC \
47 	NXGE_PARAM_RWP | NXGE_PARAM_RXDMA | NXGE_PARAM_INIT_ONLY | \
48 	NXGE_PARAM_READ_PROP
49 
50 #define	NXGE_PARAM_L2CLASS_CFG \
51 	NXGE_PARAM_RW | NXGE_PARAM_PROP_ARR32 | NXGE_PARAM_READ_PROP | \
52 	NXGE_PARAM_NDD_WR_OK
53 
54 #define	NXGE_PARAM_CLASS_RWS \
55 	NXGE_PARAM_RWS |  NXGE_PARAM_READ_PROP
56 
57 #define	NXGE_PARAM_ARRAY_INIT_SIZE	0x20ULL
58 
59 #define	SET_RX_INTR_TIME_DISABLE 0
60 #define	SET_RX_INTR_TIME_ENABLE 1
61 #define	SET_RX_INTR_PKTS 2
62 
63 #define	BASE_ANY	0
64 #define	BASE_BINARY 	2
65 #define	BASE_HEX	16
66 #define	BASE_DECIMAL	10
67 #define	ALL_FF_64	0xFFFFFFFFFFFFFFFFULL
68 #define	ALL_FF_32	0xFFFFFFFFUL
69 
70 #define	NXGE_NDD_INFODUMP_BUFF_SIZE	2048 /* is 2k enough? */
71 #define	NXGE_NDD_INFODUMP_BUFF_8K	8192
72 #define	NXGE_NDD_INFODUMP_BUFF_16K	0x2000
73 #define	NXGE_NDD_INFODUMP_BUFF_64K	0x8000
74 
75 #define	PARAM_OUTOF_RANGE(vptr, eptr, rval, pa)	\
76 	((vptr == eptr) || (rval < pa->minimum) || (rval > pa->maximum))
77 
78 #define	ADVANCE_PRINT_BUFFER(pmp, plen, rlen) { \
79 	((mblk_t *)pmp)->b_wptr += plen; \
80 	rlen -= plen; \
81 }
82 
83 int nxge_param_set_mac(p_nxge_t, queue_t *,
84 	mblk_t *, char *, caddr_t);
85 static int nxge_param_set_port_rdc(p_nxge_t, queue_t *,
86 	mblk_t *, char *, caddr_t);
87 static int nxge_param_set_grp_rdc(p_nxge_t, queue_t *,
88 	mblk_t *, char *, caddr_t);
89 static int nxge_param_set_ether_usr(p_nxge_t,
90 	queue_t *, mblk_t *, char *, caddr_t);
91 static int nxge_param_set_ip_usr(p_nxge_t,
92 	queue_t *, mblk_t *, char *, caddr_t);
93 static int nxge_param_set_vlan_rdcgrp(p_nxge_t,
94 	queue_t *, mblk_t *, char *, caddr_t);
95 static int nxge_param_set_mac_rdcgrp(p_nxge_t,
96 	queue_t *, mblk_t *, char *, caddr_t);
97 static int nxge_param_fflp_hash_init(p_nxge_t,
98 	queue_t *, mblk_t *, char *, caddr_t);
99 static int nxge_param_llc_snap_enable(p_nxge_t, queue_t *,
100 	mblk_t *, char *, caddr_t);
101 static int nxge_param_hash_lookup_enable(p_nxge_t, queue_t *,
102 	mblk_t *, char *, caddr_t);
103 static int nxge_param_tcam_enable(p_nxge_t, queue_t *,
104 	mblk_t *, char *, caddr_t);
105 static int nxge_param_get_fw_ver(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
106 static int nxge_param_get_port_mode(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
107 static int nxge_param_get_rxdma_info(p_nxge_t, queue_t *q,
108 	p_mblk_t, caddr_t);
109 static int nxge_param_get_txdma_info(p_nxge_t, queue_t *q,
110 	p_mblk_t, caddr_t);
111 static int nxge_param_get_vlan_rdcgrp(p_nxge_t, queue_t *,
112 	p_mblk_t, caddr_t);
113 static int nxge_param_get_mac_rdcgrp(p_nxge_t, queue_t *,
114 	p_mblk_t, caddr_t);
115 static int nxge_param_get_rxdma_rdcgrp_info(p_nxge_t, queue_t *,
116 	p_mblk_t, caddr_t);
117 static int nxge_param_get_rx_intr_time(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
118 static int nxge_param_get_rx_intr_pkts(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
119 static int nxge_param_get_ip_opt(p_nxge_t, queue_t *, mblk_t *, caddr_t);
120 static int nxge_param_get_mac(p_nxge_t, queue_t *q, p_mblk_t, caddr_t);
121 static int nxge_param_get_debug_flag(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
122 static int nxge_param_set_nxge_debug_flag(p_nxge_t, queue_t *, mblk_t *,
123 	char *, caddr_t);
124 static int nxge_param_set_npi_debug_flag(p_nxge_t,
125 	queue_t *, mblk_t *, char *, caddr_t);
126 static int nxge_param_dump_rdc(p_nxge_t, queue_t *q, p_mblk_t, caddr_t);
127 static int nxge_param_dump_tdc(p_nxge_t, queue_t *q, p_mblk_t, caddr_t);
128 static int nxge_param_dump_mac_regs(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
129 static int nxge_param_dump_ipp_regs(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
130 static int nxge_param_dump_fflp_regs(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
131 static int nxge_param_dump_vlan_table(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
132 static int nxge_param_dump_rdc_table(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
133 static int nxge_param_dump_ptrs(p_nxge_t, queue_t *, p_mblk_t, caddr_t);
134 static void nxge_param_sync(p_nxge_t);
135 
136 /*
137  * Global array of Neptune changable parameters.
138  * This array is initialized to correspond to the default
139  * Neptune 4 port configuration. This array would be copied
140  * into each port's parameter structure and modifed per
141  * fcode and nxge.conf configuration. Later, the parameters are
142  * exported to ndd to display and run-time configuration (at least
143  * some of them).
144  *
145  * Parameters with DONT_SHOW are not shown by ndd.
146  *
147  */
148 
149 static nxge_param_t	nxge_param_arr[] = {
150 	/*
151 	 * min	max	value	old	hw-name	conf-name
152 	 */
153 	{ nxge_param_get_generic, NULL, NXGE_PARAM_DONT_SHOW,
154 		0, 999, 1000, 0, "instance", "instance"},
155 
156 	{ nxge_param_get_generic, NULL, NXGE_PARAM_DONT_SHOW,
157 		0, 999, 1000, 0, "main-instance", "main_instance"},
158 
159 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ,
160 		0, 3, 0, 0, "function-number", "function_number"},
161 
162 	/* Partition Id */
163 	{ nxge_param_get_generic, NULL, NXGE_PARAM_DONT_SHOW,
164 		0, 8, 0, 0, "partition-id", "partition_id"},
165 
166 	/* Read Write Permission Mode */
167 	{ nxge_param_get_generic, NULL, NXGE_PARAM_DONT_SHOW,
168 		0, 2, 0, 0, "read-write-mode", "read_write_mode"},
169 
170 	{ nxge_param_get_fw_ver, NULL, NXGE_PARAM_READ,
171 		0, 32, 0, 0, "version",	"fw_version"},
172 
173 	{ nxge_param_get_port_mode, NULL, NXGE_PARAM_READ,
174 		0, 32, 0, 0, "port-mode", "port_mode"},
175 
176 	/* hw cfg types */
177 	/* control the DMA config of Neptune/NIU */
178 	{ nxge_param_get_generic, NULL, NXGE_PARAM_DONT_SHOW,
179 		CFG_DEFAULT, CFG_CUSTOM, CFG_DEFAULT, CFG_DEFAULT,
180 		"niu-cfg-type", "niu_cfg_type"},
181 
182 	/* control the TXDMA config of the Port controlled by tx-quick-cfg */
183 	{ nxge_param_get_generic, NULL, NXGE_PARAM_DONT_SHOW,
184 		CFG_DEFAULT, CFG_CUSTOM, CFG_NOT_SPECIFIED, CFG_DEFAULT,
185 		"tx-qcfg-type", "tx_qcfg_type"},
186 
187 	/* control the RXDMA config of the Port controlled by rx-quick-cfg */
188 	{ nxge_param_get_generic, NULL, NXGE_PARAM_DONT_SHOW,
189 		CFG_DEFAULT, CFG_CUSTOM, CFG_NOT_SPECIFIED, CFG_DEFAULT,
190 		"rx-qcfg-type", "rx_qcfg_type"},
191 
192 	{ nxge_param_get_mac, nxge_param_set_mac,
193 		NXGE_PARAM_RW  | NXGE_PARAM_DONT_SHOW,
194 		0, 1, 0, 0, "master-cfg-enable", "master_cfg_enable"},
195 
196 	{ nxge_param_get_mac, nxge_param_set_mac,
197 		NXGE_PARAM_DONT_SHOW,
198 		0, 1, 0, 0, "master-cfg-value", "master_cfg_value"},
199 
200 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_RW,
201 		0, 1, 1, 1, "adv-autoneg-cap", "adv_autoneg_cap"},
202 
203 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_RW,
204 		0, 1, 1, 1, "adv-10gfdx-cap", "adv_10gfdx_cap"},
205 
206 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_DONT_SHOW,
207 		0, 1, 0, 0, "adv-10ghdx-cap", "adv_10ghdx_cap"},
208 
209 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_RW,
210 		0, 1, 1, 1, "adv-1000fdx-cap", "adv_1000fdx_cap"},
211 
212 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_DONT_SHOW,
213 		0, 1, 0, 0, "adv-1000hdx-cap",	"adv_1000hdx_cap"},
214 
215 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_DONT_SHOW,
216 		0, 1, 0, 0, "adv-100T4-cap", "adv_100T4_cap"},
217 
218 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_RW,
219 		0, 1, 1, 1, "adv-100fdx-cap", "adv_100fdx_cap"},
220 
221 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_DONT_SHOW,
222 		0, 1, 0, 0, "adv-100hdx-cap", "adv_100hdx_cap"},
223 
224 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_RW,
225 		0, 1, 1, 1, "adv-10fdx-cap", "adv_10fdx_cap"},
226 
227 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_DONT_SHOW,
228 		0, 1, 0, 0, "adv-10hdx-cap", "adv_10hdx_cap"},
229 
230 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_DONT_SHOW,
231 		0, 1, 0, 0, "adv-asmpause-cap",	"adv_asmpause_cap"},
232 
233 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_MAC_RW,
234 		0, 1, 0, 0, "adv-pause-cap", "adv_pause_cap"},
235 
236 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_DONT_SHOW,
237 		0, 1, 0, 0, "use-int-xcvr", "use_int_xcvr"},
238 
239 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_DONT_SHOW,
240 		0, 1, 1, 1, "enable-ipg0", "enable_ipg0"},
241 
242 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_DONT_SHOW,
243 		0, 255,	8, 8, "ipg0", "ipg0"},
244 
245 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_DONT_SHOW,
246 		0, 255,	8, 8, "ipg1", "ipg1"},
247 
248 	{ nxge_param_get_mac, nxge_param_set_mac, NXGE_PARAM_DONT_SHOW,
249 		0, 255,	4, 4, "ipg2", "ipg2"},
250 
251 	/* Transmit DMA channels */
252 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ |
253 		NXGE_PARAM_READ_PROP | NXGE_PARAM_DONT_SHOW,
254 		0, 3, 0, 0, "tx-dma-weight", "tx_dma_weight"},
255 
256 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ |
257 		NXGE_PARAM_READ_PROP | NXGE_PARAM_DONT_SHOW,
258 		0, 31, 0, 0, "tx-dma-channels-begin", "tx_dma_channels_begin"},
259 
260 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ |
261 		NXGE_PARAM_READ_PROP | NXGE_PARAM_DONT_SHOW,
262 		0, 32, 0, 0, "tx-dma-channels", "tx_dma_channels"},
263 	{ nxge_param_get_txdma_info, NULL,
264 		NXGE_PARAM_READ | NXGE_PARAM_READ_PROP | NXGE_PARAM_DONT_SHOW,
265 		0, 32, 0, 0, "tx-dma-info", "tx_dma_info"},
266 
267 	/* Receive DMA channels */
268 	{ nxge_param_get_generic, NULL,
269 		NXGE_PARAM_READ | NXGE_PARAM_READ_PROP | NXGE_PARAM_DONT_SHOW,
270 		0, 31, 0, 0, "rx-dma-channels-begin", "rx_dma_channels_begin"},
271 
272 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ |
273 		NXGE_PARAM_READ_PROP | NXGE_PARAM_DONT_SHOW,
274 		0, 32, 0, 0, "rx-dma-channels",	"rx_dma_channels"},
275 
276 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ |
277 		NXGE_PARAM_READ_PROP | NXGE_PARAM_DONT_SHOW,
278 		0, 65535, PT_DRR_WT_DEFAULT_10G, 0,
279 		"rx-drr-weight", "rx_drr_weight"},
280 
281 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ |
282 		NXGE_PARAM_READ_PROP | NXGE_PARAM_DONT_SHOW,
283 		0, 1, 1, 0, "rx-full-header", "rx_full_header"},
284 
285 	{ nxge_param_get_rxdma_info, NULL, NXGE_PARAM_READ |
286 		NXGE_PARAM_DONT_SHOW,
287 		0, 32, 0, 0, "rx-dma-info", "rx_dma_info"},
288 
289 	{ nxge_param_get_rxdma_info, NULL,
290 		NXGE_PARAM_READ | NXGE_PARAM_DONT_SHOW,
291 		NXGE_RBR_RBB_MIN, NXGE_RBR_RBB_MAX, NXGE_RBR_RBB_DEFAULT, 0,
292 		"rx-rbr-size", "rx_rbr_size"},
293 
294 	{ nxge_param_get_rxdma_info, NULL,
295 		NXGE_PARAM_READ | NXGE_PARAM_DONT_SHOW,
296 		NXGE_RCR_MIN, NXGE_RCR_MAX, NXGE_RCR_DEFAULT, 0,
297 		"rx-rcr-size", "rx_rcr_size"},
298 
299 	{ nxge_param_get_generic, nxge_param_set_port_rdc,
300 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
301 		0, 15, 0, 0, "default-port-rdc", "default_port_rdc"},
302 
303 	{ nxge_param_get_rx_intr_time, nxge_param_rx_intr_time,
304 		NXGE_PARAM_RXDMA_RW,
305 		NXGE_RDC_RCR_TIMEOUT_MIN, NXGE_RDC_RCR_TIMEOUT_MAX,
306 		NXGE_RDC_RCR_TIMEOUT, 0, "rxdma-intr-time", "rxdma_intr_time"},
307 
308 	{ nxge_param_get_rx_intr_pkts, nxge_param_rx_intr_pkts,
309 		NXGE_PARAM_RXDMA_RW,
310 		NXGE_RDC_RCR_THRESHOLD_MIN, NXGE_RDC_RCR_THRESHOLD_MAX,
311 		NXGE_RDC_RCR_THRESHOLD, 0,
312 		"rxdma-intr-pkts", "rxdma_intr_pkts"},
313 
314 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ_PROP |
315 		NXGE_PARAM_DONT_SHOW,
316 		0, 8, 0, 0, "rx-rdc-grps-begin", "rx_rdc_grps_begin"},
317 
318 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ_PROP |
319 		NXGE_PARAM_DONT_SHOW,
320 		0, 8, 0, 0, "rx-rdc-grps", "rx_rdc_grps"},
321 
322 	{ nxge_param_get_generic, nxge_param_set_grp_rdc,
323 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
324 		0, 15, 0, 0, "default-grp0-rdc", "default_grp0_rdc"},
325 
326 	{ nxge_param_get_generic, nxge_param_set_grp_rdc,
327 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
328 		0, 15,	2, 0, "default-grp1-rdc", "default_grp1_rdc"},
329 
330 	{ nxge_param_get_generic, nxge_param_set_grp_rdc,
331 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
332 		0, 15, 4, 0, "default-grp2-rdc", "default_grp2_rdc"},
333 
334 	{ nxge_param_get_generic, nxge_param_set_grp_rdc,
335 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
336 		0, 15, 6, 0, "default-grp3-rdc", "default_grp3_rdc"},
337 
338 	{ nxge_param_get_generic, nxge_param_set_grp_rdc,
339 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
340 		0, 15, 8, 0, "default-grp4-rdc", "default_grp4_rdc"},
341 
342 	{ nxge_param_get_generic, nxge_param_set_grp_rdc,
343 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
344 		0, 15, 10, 0, "default-grp5-rdc", "default_grp5_rdc"},
345 
346 	{ nxge_param_get_generic, nxge_param_set_grp_rdc,
347 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
348 		0, 15, 12, 0, "default-grp6-rdc", "default_grp6_rdc"},
349 
350 	{ nxge_param_get_generic, nxge_param_set_grp_rdc,
351 		NXGE_PARAM_RXDMA_RW | NXGE_PARAM_DONT_SHOW,
352 		0, 15, 14, 0, "default-grp7-rdc", "default_grp7_rdc"},
353 
354 	{ nxge_param_get_rxdma_rdcgrp_info, NULL,
355 		NXGE_PARAM_READ | NXGE_PARAM_CMPLX | NXGE_PARAM_DONT_SHOW,
356 		0, 8, 0, 0, "rdc-groups-info", "rdc_groups_info"},
357 
358 	/* Logical device groups */
359 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ | NXGE_PARAM_DONT_SHOW,
360 		0, 63, 0, 0, "start-ldg", "start_ldg"},
361 
362 	{ nxge_param_get_generic, NULL, NXGE_PARAM_READ | NXGE_PARAM_DONT_SHOW,
363 		0, 64, 0, 0, "max-ldg", "max_ldg" },
364 
365 	/* MAC table information */
366 	{ nxge_param_get_mac_rdcgrp, nxge_param_set_mac_rdcgrp,
367 		NXGE_PARAM_L2CLASS_CFG | NXGE_PARAM_DONT_SHOW,
368 		0, 31, 0, 0, "mac-2rdc-grp", "mac_2rdc_grp"},
369 
370 	/* VLAN table information */
371 	{ nxge_param_get_vlan_rdcgrp, nxge_param_set_vlan_rdcgrp,
372 		NXGE_PARAM_L2CLASS_CFG | NXGE_PARAM_DONT_SHOW,
373 		0, 31, 0, 0, "vlan-2rdc-grp", "vlan_2rdc_grp"},
374 
375 	{ nxge_param_get_generic, NULL,
376 		NXGE_PARAM_READ_PROP | NXGE_PARAM_READ |
377 		NXGE_PARAM_PROP_ARR32 | NXGE_PARAM_DONT_SHOW,
378 		0, 0x0ffff, 0x0ffff, 0, "fcram-part-cfg", "fcram_part_cfg"},
379 
380 	{ nxge_param_get_generic, NULL, NXGE_PARAM_CLASS_RWS |
381 		NXGE_PARAM_DONT_SHOW,
382 		0, 0x10, 0xa, 0, "fcram-access-ratio", "fcram_access_ratio"},
383 
384 	{ nxge_param_get_generic, NULL, NXGE_PARAM_CLASS_RWS |
385 		NXGE_PARAM_DONT_SHOW,
386 		0, 0x10, 0xa, 0, "tcam-access-ratio", "tcam_access_ratio"},
387 
388 	{ nxge_param_get_generic, nxge_param_tcam_enable,
389 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
390 		0, 0x1, 0x0, 0, "tcam-enable", "tcam_enable"},
391 
392 	{ nxge_param_get_generic, nxge_param_hash_lookup_enable,
393 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
394 		0, 0x01, 0x0, 0, "hash-lookup-enable", "hash_lookup_enable"},
395 
396 	{ nxge_param_get_generic, nxge_param_llc_snap_enable,
397 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
398 		0, 0x01, 0x01, 0, "llc-snap-enable", "llc_snap_enable"},
399 
400 	{ nxge_param_get_generic, nxge_param_fflp_hash_init,
401 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
402 		0, ALL_FF_32, ALL_FF_32, 0, "h1-init-value", "h1_init_value"},
403 
404 	{ nxge_param_get_generic,	nxge_param_fflp_hash_init,
405 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
406 		0, 0x0ffff, 0x0ffff, 0, "h2-init-value", "h2_init_value"},
407 
408 	{ nxge_param_get_generic, nxge_param_set_ether_usr,
409 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
410 		0, ALL_FF_32, 0x0, 0,
411 		"class-cfg-ether-usr1", "class_cfg_ether_usr1"},
412 
413 	{ nxge_param_get_generic, nxge_param_set_ether_usr,
414 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
415 		0, ALL_FF_32, 0x0, 0,
416 		"class-cfg-ether-usr2", "class_cfg_ether_usr2"},
417 
418 	{ nxge_param_get_generic, nxge_param_set_ip_usr,
419 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
420 		0, ALL_FF_32, 0x0, 0,
421 		"class-cfg-ip-usr4", "class_cfg_ip_usr4"},
422 
423 	{ nxge_param_get_generic, nxge_param_set_ip_usr,
424 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
425 		0, ALL_FF_32, 0x0, 0,
426 		"class-cfg-ip-usr5", "class_cfg_ip_usr5"},
427 
428 	{ nxge_param_get_generic, nxge_param_set_ip_usr,
429 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
430 		0, ALL_FF_32, 0x0, 0,
431 		"class-cfg-ip-usr6", "class_cfg_ip_usr6"},
432 
433 	{ nxge_param_get_generic, nxge_param_set_ip_usr,
434 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
435 		0, ALL_FF_32, 0x0, 0,
436 		"class-cfg-ip-usr7", "class_cfg_ip_usr7"},
437 
438 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt,
439 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
440 		0, ALL_FF_32, 0x0, 0,
441 		"class-opt-ip-usr4", "class_opt_ip_usr4"},
442 
443 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt,
444 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
445 		0, ALL_FF_32, 0x0, 0,
446 		"class-opt-ip-usr5", "class_opt_ip_usr5"},
447 
448 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt,
449 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
450 		0, ALL_FF_32, 0x0, 0,
451 		"class-opt-ip-usr6", "class_opt_ip_usr6"},
452 
453 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt,
454 		NXGE_PARAM_CLASS_RWS | NXGE_PARAM_DONT_SHOW,
455 		0, ALL_FF_32, 0x0, 0,
456 		"class-opt-ip-usr7", "class_opt_ip_usr7"},
457 
458 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt,
459 		NXGE_PARAM_CLASS_RWS,
460 		0, ALL_FF_32, NXGE_CLASS_FLOW_GEN_SERVER, 0,
461 		"class-opt-ipv4-tcp", "class_opt_ipv4_tcp"},
462 
463 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt,
464 		NXGE_PARAM_CLASS_RWS,
465 		0, ALL_FF_32, NXGE_CLASS_FLOW_GEN_SERVER, 0,
466 		"class-opt-ipv4-udp", "class_opt_ipv4_udp"},
467 
468 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt,
469 		NXGE_PARAM_CLASS_RWS,
470 		0, ALL_FF_32, NXGE_CLASS_FLOW_GEN_SERVER, 0,
471 		"class-opt-ipv4-ah", "class_opt_ipv4_ah"},
472 
473 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt,
474 		NXGE_PARAM_CLASS_RWS,
475 		0, ALL_FF_32, NXGE_CLASS_FLOW_GEN_SERVER, 0,
476 		"class-opt-ipv4-sctp", "class_opt_ipv4_sctp"},
477 
478 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt, NXGE_PARAM_CLASS_RWS,
479 		0, ALL_FF_32, NXGE_CLASS_FLOW_GEN_SERVER, 0,
480 		"class-opt-ipv6-tcp", "class_opt_ipv6_tcp"},
481 
482 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt, NXGE_PARAM_CLASS_RWS,
483 		0, ALL_FF_32, NXGE_CLASS_FLOW_GEN_SERVER, 0,
484 		"class-opt-ipv6-udp", "class_opt_ipv6_udp"},
485 
486 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt, NXGE_PARAM_CLASS_RWS,
487 		0, ALL_FF_32, NXGE_CLASS_FLOW_GEN_SERVER, 0,
488 		"class-opt-ipv6-ah", "class_opt_ipv6_ah"},
489 
490 	{ nxge_param_get_ip_opt, nxge_param_set_ip_opt, NXGE_PARAM_CLASS_RWS,
491 		0, ALL_FF_32, NXGE_CLASS_FLOW_GEN_SERVER, 0,
492 		"class-opt-ipv6-sctp",	"class_opt_ipv6_sctp"},
493 
494 	{ nxge_param_get_debug_flag, nxge_param_set_nxge_debug_flag,
495 		NXGE_PARAM_RW | NXGE_PARAM_DONT_SHOW,
496 		0ULL, ALL_FF_64, 0ULL, 0ULL,
497 		"nxge-debug-flag", "nxge_debug_flag"},
498 
499 	{ nxge_param_get_debug_flag, nxge_param_set_npi_debug_flag,
500 		NXGE_PARAM_RW | NXGE_PARAM_DONT_SHOW,
501 		0ULL, ALL_FF_64, 0ULL, 0ULL,
502 		"npi-debug-flag", "npi_debug_flag"},
503 
504 	{ nxge_param_dump_tdc, NULL, NXGE_PARAM_READ | NXGE_PARAM_DONT_SHOW,
505 		0, 0x0fffffff, 0x0fffffff, 0, "dump-tdc", "dump_tdc"},
506 
507 	{ nxge_param_dump_rdc, NULL, NXGE_PARAM_READ | NXGE_PARAM_DONT_SHOW,
508 		0, 0x0fffffff, 0x0fffffff, 0, "dump-rdc", "dump_rdc"},
509 
510 	{ nxge_param_dump_mac_regs, NULL, NXGE_PARAM_READ |
511 		NXGE_PARAM_DONT_SHOW,
512 		0, 0x0fffffff, 0x0fffffff, 0, "dump-mac-regs", "dump_mac_regs"},
513 
514 	{ nxge_param_dump_ipp_regs, NULL, NXGE_PARAM_READ |
515 		NXGE_PARAM_DONT_SHOW,
516 		0, 0x0fffffff, 0x0fffffff, 0, "dump-ipp-regs", "dump_ipp_regs"},
517 
518 	{ nxge_param_dump_fflp_regs, NULL, NXGE_PARAM_READ |
519 		NXGE_PARAM_DONT_SHOW,
520 		0, 0x0fffffff, 0x0fffffff, 0,
521 		"dump-fflp-regs", "dump_fflp_regs"},
522 
523 	{ nxge_param_dump_vlan_table, NULL, NXGE_PARAM_READ |
524 		NXGE_PARAM_DONT_SHOW,
525 		0, 0x0fffffff, 0x0fffffff, 0,
526 		"dump-vlan-table", "dump_vlan_table"},
527 
528 	{ nxge_param_dump_rdc_table, NULL, NXGE_PARAM_READ |
529 		NXGE_PARAM_DONT_SHOW,
530 		0, 0x0fffffff, 0x0fffffff, 0,
531 		"dump-rdc-table", "dump_rdc_table"},
532 
533 	{ nxge_param_dump_ptrs,	NULL, NXGE_PARAM_READ |
534 		NXGE_PARAM_DONT_SHOW,
535 		0, 0x0fffffff, 0x0fffffff, 0, "dump-ptrs", "dump_ptrs"},
536 
537 	{  NULL, NULL, NXGE_PARAM_READ | NXGE_PARAM_DONT_SHOW,
538 		0, 0x0fffffff, 0x0fffffff, 0, "end", "end"},
539 };
540 
541 extern void 		*nxge_list;
542 
543 void
544 nxge_get_param_soft_properties(p_nxge_t nxgep)
545 {
546 
547 	p_nxge_param_t 		param_arr;
548 	uint_t 			prop_len;
549 	int 			i, j;
550 	uint32_t		param_count;
551 	uint32_t		*int_prop_val;
552 
553 	NXGE_DEBUG_MSG((nxgep, DDI_CTL, " ==> nxge_get_param_soft_properties"));
554 
555 	param_arr = nxgep->param_arr;
556 	param_count = nxgep->param_count;
557 	for (i = 0; i < param_count; i++) {
558 		if ((param_arr[i].type & NXGE_PARAM_READ_PROP) == 0)
559 			continue;
560 		if ((param_arr[i].type & NXGE_PARAM_PROP_STR))
561 			continue;
562 		if ((param_arr[i].type & NXGE_PARAM_PROP_ARR32) ||
563 		    (param_arr[i].type & NXGE_PARAM_PROP_ARR64)) {
564 			if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY,
565 			    nxgep->dip, 0, param_arr[i].fcode_name,
566 			    (int **)&int_prop_val,
567 			    (uint_t *)&prop_len)
568 			    == DDI_PROP_SUCCESS) {
569 				uint32_t *cfg_value;
570 				uint64_t prop_count;
571 
572 				if (prop_len > NXGE_PARAM_ARRAY_INIT_SIZE)
573 					prop_len = NXGE_PARAM_ARRAY_INIT_SIZE;
574 #if defined(__i386)
575 				cfg_value =
576 				    (uint32_t *)(int32_t)param_arr[i].value;
577 #else
578 				cfg_value = (uint32_t *)param_arr[i].value;
579 #endif
580 				for (j = 0; j < prop_len; j++) {
581 					cfg_value[j] = int_prop_val[j];
582 				}
583 				prop_count = prop_len;
584 				param_arr[i].type |=
585 				    (prop_count << NXGE_PARAM_ARRAY_CNT_SHIFT);
586 				ddi_prop_free(int_prop_val);
587 			}
588 			continue;
589 		}
590 
591 		if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, nxgep->dip, 0,
592 		    param_arr[i].fcode_name,
593 		    (int **)&int_prop_val,
594 		    &prop_len) == DDI_PROP_SUCCESS) {
595 			if ((*int_prop_val >= param_arr[i].minimum) &&
596 			    (*int_prop_val <= param_arr[i].maximum))
597 				param_arr[i].value = *int_prop_val;
598 #ifdef NXGE_DEBUG_ERROR
599 			else {
600 				NXGE_DEBUG_MSG((nxgep, OBP_CTL,
601 				    "nxge%d: 'prom' file parameter error\n",
602 				    nxgep->instance));
603 				NXGE_DEBUG_MSG((nxgep, OBP_CTL,
604 				    "Parameter keyword '%s'"
605 				    " is outside valid range\n",
606 				    param_arr[i].name));
607 			}
608 #endif
609 			ddi_prop_free(int_prop_val);
610 		}
611 
612 		if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, nxgep->dip, 0,
613 		    param_arr[i].name,
614 		    (int **)&int_prop_val,
615 		    &prop_len) == DDI_PROP_SUCCESS) {
616 			if ((*int_prop_val >= param_arr[i].minimum) &&
617 			    (*int_prop_val <= param_arr[i].maximum))
618 				param_arr[i].value = *int_prop_val;
619 #ifdef NXGE_DEBUG_ERROR
620 			else {
621 				NXGE_DEBUG_MSG((nxgep, OBP_CTL,
622 				    "nxge%d: 'conf' file parameter error\n",
623 				    nxgep->instance));
624 				NXGE_DEBUG_MSG((nxgep, OBP_CTL,
625 				    "Parameter keyword '%s'"
626 				    "is outside valid range\n",
627 				    param_arr[i].name));
628 			}
629 #endif
630 			ddi_prop_free(int_prop_val);
631 		}
632 	}
633 }
634 
635 static int
636 nxge_private_param_register(p_nxge_t nxgep, p_nxge_param_t param_arr)
637 {
638 	int status = B_TRUE;
639 	int channel;
640 	uint8_t grp;
641 	char *prop_name;
642 	char *end;
643 	uint32_t name_chars;
644 
645 	NXGE_DEBUG_MSG((nxgep, NDD2_CTL,
646 	    "nxge_private_param_register %s", param_arr->name));
647 
648 	if ((param_arr->type & NXGE_PARAM_PRIV) != NXGE_PARAM_PRIV)
649 		return (B_TRUE);
650 
651 	prop_name =  param_arr->name;
652 	if (param_arr->type & NXGE_PARAM_RXDMA) {
653 		if (strncmp("rxdma_intr", prop_name, 10) == 0)
654 			return (B_TRUE);
655 		name_chars = strlen("default_grp");
656 		if (strncmp("default_grp", prop_name, name_chars) == 0) {
657 			prop_name += name_chars;
658 			grp = mi_strtol(prop_name, &end, 10);
659 				/* now check if this rdcgrp is in config */
660 			return (nxge_check_rdcgrp_port_member(nxgep, grp));
661 		}
662 		name_chars = strlen(prop_name);
663 		if (strncmp("default_port_rdc", prop_name, name_chars) == 0) {
664 			return (B_TRUE);
665 		}
666 		return (B_FALSE);
667 	}
668 
669 	if (param_arr->type & NXGE_PARAM_TXDMA) {
670 		name_chars = strlen("txdma");
671 		if (strncmp("txdma", prop_name, name_chars) == 0) {
672 			prop_name += name_chars;
673 			channel = mi_strtol(prop_name, &end, 10);
674 				/* now check if this rdc is in config */
675 			NXGE_DEBUG_MSG((nxgep, NDD2_CTL,
676 			    " nxge_private_param_register: %d",
677 			    channel));
678 			return (nxge_check_txdma_port_member(nxgep, channel));
679 		}
680 		return (B_FALSE);
681 	}
682 
683 	status = B_FALSE;
684 	NXGE_DEBUG_MSG((nxgep, NDD2_CTL, "<== nxge_private_param_register"));
685 
686 	return (status);
687 }
688 
689 void
690 nxge_setup_param(p_nxge_t nxgep)
691 {
692 	p_nxge_param_t param_arr;
693 	int i;
694 	pfi_t set_pfi;
695 
696 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_setup_param"));
697 
698 	/*
699 	 * Make sure the param_instance is set to a valid device instance.
700 	 */
701 	if (nxge_param_arr[param_instance].value == 1000)
702 		nxge_param_arr[param_instance].value = nxgep->instance;
703 
704 	param_arr = nxgep->param_arr;
705 	param_arr[param_instance].value = nxgep->instance;
706 	param_arr[param_function_number].value = nxgep->function_num;
707 
708 	for (i = 0; i < nxgep->param_count; i++) {
709 		if ((param_arr[i].type & NXGE_PARAM_PRIV) &&
710 		    (nxge_private_param_register(nxgep,
711 		    &param_arr[i]) == B_FALSE)) {
712 			param_arr[i].setf = NULL;
713 			param_arr[i].getf = NULL;
714 		}
715 
716 		if (param_arr[i].type & NXGE_PARAM_CMPLX)
717 			param_arr[i].setf = NULL;
718 
719 		if (param_arr[i].type & NXGE_PARAM_DONT_SHOW) {
720 			param_arr[i].setf = NULL;
721 			param_arr[i].getf = NULL;
722 		}
723 
724 		set_pfi = (pfi_t)param_arr[i].setf;
725 
726 		if ((set_pfi) && (param_arr[i].type & NXGE_PARAM_INIT_ONLY)) {
727 			set_pfi = NULL;
728 		}
729 
730 	}
731 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_setup_param"));
732 }
733 
734 void
735 nxge_init_param(p_nxge_t nxgep)
736 {
737 	p_nxge_param_t param_arr;
738 	int i, alloc_size;
739 	uint64_t alloc_count;
740 	NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_init_param"));
741 	/*
742 	 * Make sure the param_instance is set to a valid device instance.
743 	 */
744 	if (nxge_param_arr[param_instance].value == 1000)
745 		nxge_param_arr[param_instance].value = nxgep->instance;
746 
747 	param_arr = nxgep->param_arr;
748 	if (param_arr == NULL) {
749 		param_arr = (p_nxge_param_t)
750 		    KMEM_ZALLOC(sizeof (nxge_param_arr), KM_SLEEP);
751 	}
752 
753 	for (i = 0; i < sizeof (nxge_param_arr)/sizeof (nxge_param_t); i++) {
754 		param_arr[i] = nxge_param_arr[i];
755 		if ((param_arr[i].type & NXGE_PARAM_PROP_ARR32) ||
756 		    (param_arr[i].type & NXGE_PARAM_PROP_ARR64)) {
757 			alloc_count = NXGE_PARAM_ARRAY_INIT_SIZE;
758 			alloc_size = alloc_count * sizeof (uint64_t);
759 			param_arr[i].value =
760 #if defined(__i386)
761 			    (uint64_t)(uint32_t)KMEM_ZALLOC(alloc_size,
762 			    KM_SLEEP);
763 #else
764 			(uint64_t)KMEM_ZALLOC(alloc_size, KM_SLEEP);
765 #endif
766 			param_arr[i].old_value =
767 #if defined(__i386)
768 			    (uint64_t)(uint32_t)KMEM_ZALLOC(alloc_size,
769 			    KM_SLEEP);
770 #else
771 			(uint64_t)KMEM_ZALLOC(alloc_size, KM_SLEEP);
772 #endif
773 			param_arr[i].type |=
774 			    (alloc_count << NXGE_PARAM_ARRAY_ALLOC_SHIFT);
775 		}
776 	}
777 
778 	nxgep->param_arr = param_arr;
779 	nxgep->param_count = sizeof (nxge_param_arr)/sizeof (nxge_param_t);
780 
781 	nxge_param_sync(nxgep);
782 
783 	NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_init_param: count %d",
784 	    nxgep->param_count));
785 }
786 
787 void
788 nxge_destroy_param(p_nxge_t nxgep)
789 {
790 	int i;
791 	uint64_t free_size, free_count;
792 
793 	NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_destroy_param"));
794 
795 	if (nxgep->param_arr == NULL)
796 		return;
797 	/*
798 	 * Make sure the param_instance is set to a valid device instance.
799 	 */
800 	if (nxge_param_arr[param_instance].value == nxgep->instance) {
801 		for (i = 0; i <= nxge_param_arr[param_instance].maximum; i++) {
802 			if ((ddi_get_soft_state(nxge_list, i) != NULL) &&
803 			    (i != nxgep->instance))
804 				break;
805 		}
806 		nxge_param_arr[param_instance].value = i;
807 	}
808 
809 	for (i = 0; i < nxgep->param_count; i++)
810 		if ((nxgep->param_arr[i].type & NXGE_PARAM_PROP_ARR32) ||
811 		    (nxgep->param_arr[i].type & NXGE_PARAM_PROP_ARR64)) {
812 			free_count = ((nxgep->param_arr[i].type &
813 			    NXGE_PARAM_ARRAY_ALLOC_MASK) >>
814 			    NXGE_PARAM_ARRAY_ALLOC_SHIFT);
815 			free_count = NXGE_PARAM_ARRAY_INIT_SIZE;
816 			free_size = sizeof (uint64_t) * free_count;
817 #if defined(__i386)
818 			KMEM_FREE((void *)(uint32_t)nxgep->param_arr[i].value,
819 			    free_size);
820 #else
821 			KMEM_FREE((void *)nxgep->param_arr[i].value, free_size);
822 #endif
823 #if defined(__i386)
824 			KMEM_FREE((void *)(uint32_t)
825 			    nxgep->param_arr[i].old_value, free_size);
826 #else
827 			KMEM_FREE((void *)nxgep->param_arr[i].old_value,
828 			    free_size);
829 #endif
830 		}
831 
832 	KMEM_FREE(nxgep->param_arr, sizeof (nxge_param_arr));
833 	NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_destroy_param"));
834 }
835 
836 /*
837  * Extracts the value from the 'nxge' parameter array and prints the
838  * parameter value. cp points to the required parameter.
839  */
840 
841 /* ARGSUSED */
842 int
843 nxge_param_get_generic(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
844 {
845 	p_nxge_param_t pa = (p_nxge_param_t)cp;
846 
847 	NXGE_DEBUG_MSG((nxgep, NDD_CTL,
848 	    "==> nxge_param_get_generic name %s ", pa->name));
849 
850 	if (pa->value > 0xffffffff)
851 		(void) mi_mpprintf(mp, "%x%x",
852 		    (int)(pa->value >> 32), (int)(pa->value & 0xffffffff));
853 	else
854 		(void) mi_mpprintf(mp, "%x", (int)pa->value);
855 
856 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_generic"));
857 	return (0);
858 }
859 
860 /* ARGSUSED */
861 static int
862 nxge_param_get_mac(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
863 {
864 	p_nxge_param_t pa = (p_nxge_param_t)cp;
865 
866 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_mac"));
867 
868 	(void) mi_mpprintf(mp, "%d", (uint32_t)pa->value);
869 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_mac"));
870 	return (0);
871 }
872 
873 /* ARGSUSED */
874 static int
875 nxge_param_get_fw_ver(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
876 {
877 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_fw_ver"));
878 
879 	(void) mi_mpprintf(mp, "Firmware version for nxge%d:  %s\n",
880 	    nxgep->instance, nxgep->vpd_info.ver);
881 
882 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_fw_ver"));
883 	return (0);
884 }
885 
886 /* ARGSUSED */
887 static int
888 nxge_param_get_port_mode(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
889 {
890 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_port_mode"));
891 
892 	switch (nxgep->mac.portmode) {
893 	case PORT_1G_COPPER:
894 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  1G Copper %s\n",
895 		    nxgep->instance,
896 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
897 		break;
898 	case PORT_1G_FIBER:
899 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  1G Fiber %s\n",
900 		    nxgep->instance,
901 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
902 		break;
903 	case PORT_10G_COPPER:
904 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  10G Copper "
905 		    "%s\n", nxgep->instance,
906 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
907 		break;
908 	case PORT_10G_FIBER:
909 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  10G Fiber %s\n",
910 		    nxgep->instance,
911 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
912 		break;
913 	case PORT_10G_SERDES:
914 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  10G Serdes "
915 		    "%s\n", nxgep->instance,
916 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
917 		break;
918 	case PORT_1G_SERDES:
919 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  1G Serdes %s\n",
920 		    nxgep->instance,
921 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
922 		break;
923 	case PORT_1G_RGMII_FIBER:
924 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  1G RGMII "
925 		    "Fiber %s\n", nxgep->instance,
926 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
927 		break;
928 	case PORT_HSP_MODE:
929 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  Hot Swappable "
930 		    "PHY, Currently NOT present\n", nxgep->instance);
931 		break;
932 	case PORT_10G_TN1010:
933 		(void) mi_mpprintf(mp, "Port mode for nxge%d:"
934 		    " 10G Copper with TN1010 %s\n", nxgep->instance,
935 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
936 		break;
937 	case PORT_1G_TN1010:
938 		(void) mi_mpprintf(mp, "Port mode for nxge%d:"
939 		    " 1G Copper with TN1010 %s\n", nxgep->instance,
940 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
941 		break;
942 	default:
943 		(void) mi_mpprintf(mp, "Port mode for nxge%d:  Unknown %s\n",
944 		    nxgep->instance,
945 		    nxgep->hot_swappable_phy ? "[Hot Swappable]" : "");
946 		break;
947 	}
948 
949 	(void) mi_mpprintf(mp, "Software LSO for nxge%d: %s\n",
950 	    nxgep->instance,
951 	    nxgep->soft_lso_enable ? "enable" : "disable");
952 
953 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_port_mode"));
954 	return (0);
955 }
956 
957 /* ARGSUSED */
958 static int
959 nxge_param_get_rx_intr_time(p_nxge_t nxgep, queue_t *q, mblk_t *mp, caddr_t cp)
960 {
961 	p_nxge_param_t pa = (p_nxge_param_t)cp;
962 
963 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_rx_intr_time"));
964 
965 	pa->value = (uint32_t)nxgep->intr_timeout;
966 	(void) mi_mpprintf(mp, "%d", (uint32_t)nxgep->intr_timeout);
967 
968 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_rx_intr_time"));
969 	return (0);
970 }
971 
972 /* ARGSUSED */
973 static int
974 nxge_param_get_rx_intr_pkts(p_nxge_t nxgep, queue_t *q, mblk_t *mp, caddr_t cp)
975 {
976 	p_nxge_param_t pa = (p_nxge_param_t)cp;
977 
978 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_rx_intr_pkts"));
979 
980 	pa->value = (uint32_t)nxgep->intr_threshold;
981 	(void) mi_mpprintf(mp, "%d", (uint32_t)nxgep->intr_threshold);
982 
983 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_rx_intr_pkts"));
984 	return (0);
985 }
986 
987 /* ARGSUSED */
988 int
989 nxge_param_get_txdma_info(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
990 {
991 
992 	uint_t print_len, buf_len;
993 	p_mblk_t np;
994 
995 	int buff_alloc_size = NXGE_NDD_INFODUMP_BUFF_SIZE;
996 	int tdc;
997 
998 	nxge_grp_set_t *set;
999 
1000 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_txdma_info"));
1001 
1002 	(void) mi_mpprintf(mp, "TXDMA Information for Port\t %d \n",
1003 	    nxgep->function_num);
1004 
1005 	if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) {
1006 		(void) mi_mpprintf(mp, "%s\n", "out of buffer");
1007 		return (0);
1008 	}
1009 
1010 	buf_len = buff_alloc_size;
1011 	mp->b_cont = np;
1012 	print_len = 0;
1013 
1014 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
1015 	    "TDC\t HW TDC\t\n");
1016 	((mblk_t *)np)->b_wptr += print_len;
1017 	buf_len -= print_len;
1018 
1019 	set = &nxgep->tx_set;
1020 	for (tdc = 0; tdc < NXGE_MAX_TDCS; tdc++) {
1021 		if ((1 << tdc) & set->owned.map) {
1022 			print_len = snprintf((char *)((mblk_t *)np)->b_wptr,
1023 			    buf_len, "%d\n", tdc);
1024 			((mblk_t *)np)->b_wptr += print_len;
1025 			buf_len -= print_len;
1026 		}
1027 	}
1028 
1029 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_txdma_info"));
1030 	return (0);
1031 }
1032 
1033 /* ARGSUSED */
1034 int
1035 nxge_param_get_rxdma_info(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
1036 {
1037 	uint_t			print_len, buf_len;
1038 	p_mblk_t		np;
1039 	int			rdc;
1040 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
1041 	p_nxge_hw_pt_cfg_t	p_cfgp;
1042 	int			buff_alloc_size = NXGE_NDD_INFODUMP_BUFF_SIZE;
1043 	p_rx_rcr_rings_t 	rx_rcr_rings;
1044 	p_rx_rcr_ring_t		*rcr_rings;
1045 	p_rx_rbr_rings_t 	rx_rbr_rings;
1046 	p_rx_rbr_ring_t		*rbr_rings;
1047 	nxge_grp_set_t		*set;
1048 
1049 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_rxdma_info"));
1050 
1051 	(void) mi_mpprintf(mp, "RXDMA Information for Port\t %d \n",
1052 	    nxgep->function_num);
1053 
1054 	if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) {
1055 		/* The following may work even if we cannot get a large buf. */
1056 		(void) mi_mpprintf(mp, "%s\n", "out of buffer");
1057 		return (0);
1058 	}
1059 
1060 	buf_len = buff_alloc_size;
1061 	mp->b_cont = np;
1062 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
1063 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
1064 
1065 	rx_rcr_rings = nxgep->rx_rcr_rings;
1066 	rcr_rings = rx_rcr_rings->rcr_rings;
1067 	rx_rbr_rings = nxgep->rx_rbr_rings;
1068 	rbr_rings = rx_rbr_rings->rbr_rings;
1069 
1070 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
1071 	    "Total RDCs\t %d\n", p_cfgp->max_rdcs);
1072 
1073 	((mblk_t *)np)->b_wptr += print_len;
1074 	buf_len -= print_len;
1075 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
1076 	    "RDC\t HW RDC\t Timeout\t Packets RBR ptr \t"
1077 	    "chunks\t RCR ptr\n");
1078 
1079 	((mblk_t *)np)->b_wptr += print_len;
1080 	buf_len -= print_len;
1081 
1082 	set = &nxgep->rx_set;
1083 	for (rdc = 0; rdc < NXGE_MAX_RDCS; rdc++) {
1084 		if ((1 << rdc) & set->owned.map) {
1085 			print_len = snprintf((char *)
1086 			    ((mblk_t *)np)->b_wptr, buf_len,
1087 			    " %d\t   %x\t\t %x\t $%p\t 0x%x\t $%p\n",
1088 			    rdc,
1089 			    p_dma_cfgp->rcr_timeout[rdc],
1090 			    p_dma_cfgp->rcr_threshold[rdc],
1091 			    (void *)rbr_rings[rdc],
1092 			    rbr_rings[rdc]->num_blocks, (void *)rcr_rings[rdc]);
1093 			((mblk_t *)np)->b_wptr += print_len;
1094 			buf_len -= print_len;
1095 		}
1096 	}
1097 
1098 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_rxdma_info"));
1099 	return (0);
1100 }
1101 
1102 /* ARGSUSED */
1103 int
1104 nxge_param_get_rxdma_rdcgrp_info(p_nxge_t nxgep, queue_t *q,
1105 	p_mblk_t mp, caddr_t cp)
1106 {
1107 	uint_t			print_len, buf_len;
1108 	p_mblk_t		np;
1109 	int			offset, rdc, i, rdc_grp;
1110 	p_nxge_rdc_grp_t	rdc_grp_p;
1111 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
1112 	p_nxge_hw_pt_cfg_t	p_cfgp;
1113 
1114 	int buff_alloc_size = NXGE_NDD_INFODUMP_BUFF_SIZE;
1115 	NXGE_DEBUG_MSG((nxgep, NDD_CTL,
1116 	    "==> nxge_param_get_rxdma_rdcgrp_info"));
1117 
1118 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
1119 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
1120 
1121 	(void) mi_mpprintf(mp, "RXDMA RDC Group Information for Port\t %d \n",
1122 	    nxgep->function_num);
1123 
1124 	rdc_grp = p_cfgp->def_mac_rxdma_grpid;
1125 	if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) {
1126 		/* The following may work even if we cannot get a large buf. */
1127 		(void) mi_mpprintf(mp, "%s\n", "out of buffer");
1128 		return (0);
1129 	}
1130 
1131 	buf_len = buff_alloc_size;
1132 	mp->b_cont = np;
1133 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
1134 	    "Total RDC Groups\t %d \n"
1135 	    "default RDC group\t %d\n",
1136 	    p_cfgp->max_rdc_grpids,
1137 	    p_cfgp->def_mac_rxdma_grpid);
1138 
1139 	((mblk_t *)np)->b_wptr += print_len;
1140 	buf_len -= print_len;
1141 
1142 	for (i = 0; i < NXGE_MAX_RDC_GROUPS; i++) {
1143 		if (p_cfgp->grpids[i]) {
1144 			rdc_grp_p = &p_dma_cfgp->rdc_grps[i];
1145 			print_len = snprintf((char *)((mblk_t *)np)->b_wptr,
1146 			    buf_len,
1147 			    "\nRDC Group Info for Group [%d] %d\n"
1148 			    "RDC Count %d\tstart RDC %d\n"
1149 			    "RDC Group Population Information"
1150 			    " (offsets 0 - 15)\n",
1151 			    i, rdc_grp, rdc_grp_p->max_rdcs,
1152 			    rdc_grp_p->start_rdc);
1153 
1154 			((mblk_t *)np)->b_wptr += print_len;
1155 			buf_len -= print_len;
1156 			print_len = snprintf((char *)((mblk_t *)np)->b_wptr,
1157 			    buf_len, "\n");
1158 			((mblk_t *)np)->b_wptr += print_len;
1159 			buf_len -= print_len;
1160 
1161 			for (rdc = 0; rdc < rdc_grp_p->max_rdcs; rdc++) {
1162 				print_len = snprintf(
1163 				    (char *)((mblk_t *)np)->b_wptr,
1164 				    buf_len, "[%d]=%d ", rdc,
1165 				    rdc_grp_p->start_rdc + rdc);
1166 				((mblk_t *)np)->b_wptr += print_len;
1167 				buf_len -= print_len;
1168 			}
1169 			print_len = snprintf((char *)((mblk_t *)np)->b_wptr,
1170 			    buf_len, "\n");
1171 			((mblk_t *)np)->b_wptr += print_len;
1172 			buf_len -= print_len;
1173 
1174 			for (offset = 0; offset < 16; offset++) {
1175 				print_len = snprintf(
1176 				    (char *)((mblk_t *)np)->b_wptr,
1177 				    buf_len, " %c",
1178 				    rdc_grp_p->map & (1 << offset) ?
1179 				    '1' : '0');
1180 				((mblk_t *)np)->b_wptr += print_len;
1181 				buf_len -= print_len;
1182 			}
1183 			print_len = snprintf((char *)((mblk_t *)np)->b_wptr,
1184 			    buf_len, "\n");
1185 			((mblk_t *)np)->b_wptr += print_len;
1186 			buf_len -= print_len;
1187 		}
1188 	}
1189 	NXGE_DEBUG_MSG((nxgep, NDD_CTL,
1190 	    "<== nxge_param_get_rxdma_rdcgrp_info"));
1191 	return (0);
1192 }
1193 
1194 int
1195 nxge_mk_mblk_tail_space(p_mblk_t mp, p_mblk_t *nmp, size_t size)
1196 {
1197 	p_mblk_t tmp;
1198 
1199 	tmp = mp;
1200 	while (tmp->b_cont)
1201 		tmp = tmp->b_cont;
1202 	if ((tmp->b_wptr + size) >= tmp->b_datap->db_lim) {
1203 		tmp->b_cont = allocb(1024, BPRI_HI);
1204 		tmp = tmp->b_cont;
1205 		if (!tmp)
1206 			return (ENOMEM);
1207 	}
1208 
1209 	*nmp = tmp;
1210 	return (0);
1211 }
1212 
1213 
1214 /* ARGSUSED */
1215 int
1216 nxge_param_set_generic(p_nxge_t nxgep, queue_t *q, mblk_t *mp,
1217 			    char *value, caddr_t cp)
1218 {
1219 	char *end;
1220 	uint32_t new_value;
1221 	p_nxge_param_t pa = (p_nxge_param_t)cp;
1222 
1223 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, " ==> nxge_param_set_generic"));
1224 	new_value = (uint32_t)mi_strtol(value, &end, 10);
1225 	if (end == value || new_value < pa->minimum ||
1226 	    new_value > pa->maximum) {
1227 			return (EINVAL);
1228 	}
1229 	pa->value = new_value;
1230 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, " <== nxge_param_set_generic"));
1231 	return (0);
1232 }
1233 
1234 
1235 /* ARGSUSED */
1236 int
1237 nxge_param_set_instance(p_nxge_t nxgep, queue_t *q, mblk_t *mp,
1238 	char *value, caddr_t cp)
1239 {
1240 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, " ==> nxge_param_set_instance"));
1241 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, " <== nxge_param_set_instance"));
1242 	return (0);
1243 }
1244 
1245 
1246 /* ARGSUSED */
1247 int
1248 nxge_param_set_mac(p_nxge_t nxgep, queue_t *q, mblk_t *mp,
1249 	char *value, caddr_t cp)
1250 {
1251 	char		*end;
1252 	uint32_t	new_value;
1253 	int		status = 0;
1254 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1255 
1256 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_mac"));
1257 	new_value = (uint32_t)mi_strtol(value, &end, BASE_DECIMAL);
1258 	if (PARAM_OUTOF_RANGE(value, end, new_value, pa)) {
1259 		return (EINVAL);
1260 	}
1261 
1262 	if (pa->value != new_value) {
1263 		pa->old_value = pa->value;
1264 		pa->value = new_value;
1265 	}
1266 
1267 	if (!nxge_param_link_update(nxgep)) {
1268 		NXGE_DEBUG_MSG((nxgep, NDD_CTL,
1269 		    " false ret from nxge_param_link_update"));
1270 		status = EINVAL;
1271 	}
1272 
1273 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_mac"));
1274 	return (status);
1275 }
1276 
1277 /* ARGSUSED */
1278 int
1279 nxge_param_rx_intr_pkts(p_nxge_t nxgep, queue_t *q, mblk_t *mp,
1280 	char *value, caddr_t cp)
1281 {
1282 	char		*end;
1283 	uint32_t	cfg_value;
1284 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1285 
1286 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_rx_intr_pkts"));
1287 
1288 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_ANY);
1289 
1290 	if ((cfg_value > NXGE_RDC_RCR_THRESHOLD_MAX) ||
1291 	    (cfg_value < NXGE_RDC_RCR_THRESHOLD_MIN)) {
1292 		return (EINVAL);
1293 	}
1294 
1295 	if ((pa->value != cfg_value)) {
1296 		pa->old_value = pa->value;
1297 		pa->value = cfg_value;
1298 		nxgep->intr_threshold = pa->value;
1299 	}
1300 
1301 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_rx_intr_pkts"));
1302 	return (0);
1303 }
1304 
1305 /* ARGSUSED */
1306 int
1307 nxge_param_rx_intr_time(p_nxge_t nxgep, queue_t *q, mblk_t *mp,
1308 	char *value, caddr_t cp)
1309 {
1310 	char		*end;
1311 	uint32_t	cfg_value;
1312 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1313 
1314 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_rx_intr_time"));
1315 
1316 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_ANY);
1317 
1318 	if ((cfg_value > NXGE_RDC_RCR_TIMEOUT_MAX) ||
1319 	    (cfg_value < NXGE_RDC_RCR_TIMEOUT_MIN)) {
1320 		return (EINVAL);
1321 	}
1322 
1323 	if ((pa->value != cfg_value)) {
1324 		pa->old_value = pa->value;
1325 		pa->value = cfg_value;
1326 		nxgep->intr_timeout = pa->value;
1327 	}
1328 
1329 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_rx_intr_time"));
1330 	return (0);
1331 }
1332 
1333 /* ARGSUSED */
1334 static int
1335 nxge_param_set_mac_rdcgrp(p_nxge_t nxgep, queue_t *q,
1336 	mblk_t *mp, char *value, caddr_t cp)
1337 {
1338 	char			 *end;
1339 	uint32_t		status = 0, cfg_value;
1340 	p_nxge_param_t		pa = (p_nxge_param_t)cp;
1341 	uint32_t		cfg_it = B_FALSE;
1342 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
1343 	p_nxge_hw_pt_cfg_t	p_cfgp;
1344 	uint32_t		*val_ptr, *old_val_ptr;
1345 	nxge_param_map_t	*mac_map;
1346 	p_nxge_class_pt_cfg_t	p_class_cfgp;
1347 	nxge_mv_cfg_t		*mac_host_info;
1348 
1349 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_mac_rdcgrp "));
1350 
1351 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
1352 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
1353 	p_class_cfgp = (p_nxge_class_pt_cfg_t)&nxgep->class_config;
1354 	mac_host_info = (nxge_mv_cfg_t	*)&p_class_cfgp->mac_host_info[0];
1355 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_HEX);
1356 
1357 	/*
1358 	 * now do decoding
1359 	 */
1360 	mac_map = (nxge_param_map_t *)&cfg_value;
1361 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, " cfg_value %x id %x map_to %x",
1362 	    cfg_value, mac_map->param_id, mac_map->map_to));
1363 
1364 	if ((mac_map->param_id < p_cfgp->max_macs) &&
1365 	    p_cfgp->grpids[mac_map->map_to]) {
1366 		NXGE_DEBUG_MSG((nxgep, NDD_CTL,
1367 		    " nxge_param_set_mac_rdcgrp mapping"
1368 		    " id %d grp %d", mac_map->param_id, mac_map->map_to));
1369 #if defined(__i386)
1370 		val_ptr = (uint32_t *)(uint32_t)pa->value;
1371 #else
1372 		val_ptr = (uint32_t *)pa->value;
1373 #endif
1374 #if defined(__i386)
1375 		old_val_ptr = (uint32_t *)(uint32_t)pa->old_value;
1376 #else
1377 		old_val_ptr = (uint32_t *)pa->old_value;
1378 #endif
1379 		if (val_ptr[mac_map->param_id] != cfg_value) {
1380 			old_val_ptr[mac_map->param_id] =
1381 			    val_ptr[mac_map->param_id];
1382 			val_ptr[mac_map->param_id] = cfg_value;
1383 			mac_host_info[mac_map->param_id].mpr_npr =
1384 			    mac_map->pref;
1385 			mac_host_info[mac_map->param_id].flag = 1;
1386 			mac_host_info[mac_map->param_id].rdctbl =
1387 			    mac_map->map_to;
1388 			cfg_it = B_TRUE;
1389 		}
1390 	} else {
1391 		return (EINVAL);
1392 	}
1393 
1394 	if (cfg_it == B_TRUE) {
1395 		status = nxge_logical_mac_assign_rdc_table(nxgep,
1396 		    (uint8_t)mac_map->param_id);
1397 		if (status != NXGE_OK)
1398 			return (EINVAL);
1399 	}
1400 
1401 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_mac_rdcgrp"));
1402 	return (0);
1403 }
1404 
1405 /* ARGSUSED */
1406 static int
1407 nxge_param_set_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q,
1408 	mblk_t	*mp, char *value, caddr_t cp)
1409 {
1410 	char			*end;
1411 	uint32_t		status = 0, cfg_value;
1412 	p_nxge_param_t		pa = (p_nxge_param_t)cp;
1413 	uint32_t		cfg_it = B_FALSE;
1414 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
1415 	p_nxge_hw_pt_cfg_t	p_cfgp;
1416 	uint32_t		*val_ptr, *old_val_ptr;
1417 	nxge_param_map_t	*vmap, *old_map;
1418 	p_nxge_class_pt_cfg_t	p_class_cfgp;
1419 	uint64_t		cfgd_vlans;
1420 	int			i, inc = 0, cfg_position;
1421 	nxge_mv_cfg_t		*vlan_tbl;
1422 
1423 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_vlan_rdcgrp "));
1424 
1425 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
1426 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
1427 	p_class_cfgp = (p_nxge_class_pt_cfg_t)&nxgep->class_config;
1428 	vlan_tbl = (nxge_mv_cfg_t *)&p_class_cfgp->vlan_tbl[0];
1429 
1430 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_HEX);
1431 
1432 	/* now do decoding */
1433 	cfgd_vlans = ((pa->type &  NXGE_PARAM_ARRAY_CNT_MASK) >>
1434 	    NXGE_PARAM_ARRAY_CNT_SHIFT);
1435 
1436 	if (cfgd_vlans == NXGE_PARAM_ARRAY_INIT_SIZE) {
1437 		/*
1438 		 * for now, we process only upto max
1439 		 * NXGE_PARAM_ARRAY_INIT_SIZE parameters
1440 		 * In the future, we may want to expand
1441 		 * the storage array and continue
1442 		 */
1443 		return (EINVAL);
1444 	}
1445 
1446 	vmap = (nxge_param_map_t *)&cfg_value;
1447 	if ((vmap->param_id) &&
1448 	    (vmap->param_id < NXGE_MAX_VLANS) &&
1449 	    (vmap->map_to < p_cfgp->max_rdc_grpids)) {
1450 		NXGE_DEBUG_MSG((nxgep, NDD_CTL,
1451 		    "nxge_param_set_vlan_rdcgrp mapping"
1452 		    " id %d grp %d",
1453 		    vmap->param_id, vmap->map_to));
1454 #if defined(__i386)
1455 		val_ptr = (uint32_t *)(uint32_t)pa->value;
1456 #else
1457 		val_ptr = (uint32_t *)pa->value;
1458 #endif
1459 #if defined(__i386)
1460 		old_val_ptr = (uint32_t *)(uint32_t)pa->old_value;
1461 #else
1462 		old_val_ptr = (uint32_t *)pa->old_value;
1463 #endif
1464 
1465 		/* search to see if this vlan id is already configured */
1466 		for (i = 0; i < cfgd_vlans; i++) {
1467 			old_map = (nxge_param_map_t *)&val_ptr[i];
1468 			if ((old_map->param_id == 0) ||
1469 			    (vmap->param_id == old_map->param_id) ||
1470 			    (vlan_tbl[vmap->param_id].flag)) {
1471 				cfg_position = i;
1472 				break;
1473 			}
1474 		}
1475 
1476 		if (cfgd_vlans == 0) {
1477 			cfg_position = 0;
1478 			inc++;
1479 		}
1480 
1481 		if (i == cfgd_vlans) {
1482 			cfg_position = i;
1483 			inc++;
1484 		}
1485 
1486 		NXGE_DEBUG_MSG((nxgep, NDD2_CTL,
1487 		    "set_vlan_rdcgrp mapping"
1488 		    " i %d cfgd_vlans %llx position %d ",
1489 		    i, cfgd_vlans, cfg_position));
1490 		if (val_ptr[cfg_position] != cfg_value) {
1491 			old_val_ptr[cfg_position] = val_ptr[cfg_position];
1492 			val_ptr[cfg_position] = cfg_value;
1493 			vlan_tbl[vmap->param_id].mpr_npr = vmap->pref;
1494 			vlan_tbl[vmap->param_id].flag = 1;
1495 			vlan_tbl[vmap->param_id].rdctbl =
1496 			    vmap->map_to + p_cfgp->def_mac_rxdma_grpid;
1497 			cfg_it = B_TRUE;
1498 			if (inc) {
1499 				cfgd_vlans++;
1500 				pa->type &= ~NXGE_PARAM_ARRAY_CNT_MASK;
1501 				pa->type |= (cfgd_vlans <<
1502 				    NXGE_PARAM_ARRAY_CNT_SHIFT);
1503 
1504 			}
1505 			NXGE_DEBUG_MSG((nxgep, NDD2_CTL,
1506 			    "after: param_set_vlan_rdcgrp "
1507 			    " cfg_vlans %llx position %d \n",
1508 			    cfgd_vlans, cfg_position));
1509 		}
1510 	} else {
1511 		return (EINVAL);
1512 	}
1513 
1514 	if (cfg_it == B_TRUE) {
1515 		status = nxge_fflp_config_vlan_table(nxgep,
1516 		    (uint16_t)vmap->param_id);
1517 		if (status != NXGE_OK)
1518 			return (EINVAL);
1519 	}
1520 
1521 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_vlan_rdcgrp"));
1522 	return (0);
1523 }
1524 
1525 /* ARGSUSED */
1526 static int
1527 nxge_param_get_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q,
1528 	mblk_t *mp, caddr_t cp)
1529 {
1530 
1531 	uint_t 			print_len, buf_len;
1532 	p_mblk_t		np;
1533 	int			i;
1534 	uint32_t		*val_ptr;
1535 	nxge_param_map_t	*vmap;
1536 	p_nxge_param_t		pa = (p_nxge_param_t)cp;
1537 	p_nxge_class_pt_cfg_t 	p_class_cfgp;
1538 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
1539 	p_nxge_hw_pt_cfg_t	p_cfgp;
1540 	uint64_t		cfgd_vlans = 0;
1541 	nxge_mv_cfg_t		*vlan_tbl;
1542 	int			buff_alloc_size =
1543 	    NXGE_NDD_INFODUMP_BUFF_SIZE * 32;
1544 
1545 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_vlan_rdcgrp "));
1546 	(void) mi_mpprintf(mp, "VLAN RDC Mapping Information for Port\t %d \n",
1547 	    nxgep->function_num);
1548 
1549 	if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) {
1550 		(void) mi_mpprintf(mp, "%s\n", "out of buffer");
1551 		return (0);
1552 	}
1553 
1554 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
1555 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
1556 
1557 	buf_len = buff_alloc_size;
1558 	mp->b_cont = np;
1559 	cfgd_vlans = (pa->type &  NXGE_PARAM_ARRAY_CNT_MASK) >>
1560 	    NXGE_PARAM_ARRAY_CNT_SHIFT;
1561 
1562 	i = (int)cfgd_vlans;
1563 	p_class_cfgp = (p_nxge_class_pt_cfg_t)&nxgep->class_config;
1564 	vlan_tbl = (nxge_mv_cfg_t *)&p_class_cfgp->vlan_tbl[0];
1565 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
1566 	    "Configured VLANs %d\n"
1567 	    "VLAN ID\t RDC GRP (Actual/Port)\t"
1568 	    " Prefernce\n", i);
1569 	((mblk_t *)np)->b_wptr += print_len;
1570 	buf_len -= print_len;
1571 #if defined(__i386)
1572 	val_ptr = (uint32_t *)(uint32_t)pa->value;
1573 #else
1574 	val_ptr = (uint32_t *)pa->value;
1575 #endif
1576 
1577 	for (i = 0; i < cfgd_vlans; i++) {
1578 		vmap = (nxge_param_map_t *)&val_ptr[i];
1579 		if (p_class_cfgp->vlan_tbl[vmap->param_id].flag) {
1580 			print_len = snprintf((char *)((mblk_t *)np)->b_wptr,
1581 			    buf_len,
1582 			    "  %d\t\t %d/%d\t\t %d\n",
1583 			    vmap->param_id,
1584 			    vlan_tbl[vmap->param_id].rdctbl,
1585 			    vlan_tbl[vmap->param_id].rdctbl -
1586 			    p_cfgp->def_mac_rxdma_grpid,
1587 			    vlan_tbl[vmap->param_id].mpr_npr);
1588 			((mblk_t *)np)->b_wptr += print_len;
1589 			buf_len -= print_len;
1590 		}
1591 	}
1592 
1593 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_vlan_rdcgrp"));
1594 	return (0);
1595 }
1596 
1597 /* ARGSUSED */
1598 static int
1599 nxge_param_get_mac_rdcgrp(p_nxge_t nxgep, queue_t *q,
1600 	mblk_t *mp, caddr_t cp)
1601 {
1602 	uint_t			print_len, buf_len;
1603 	p_mblk_t		np;
1604 	int			i;
1605 	p_nxge_class_pt_cfg_t 	p_class_cfgp;
1606 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
1607 	p_nxge_hw_pt_cfg_t	p_cfgp;
1608 	nxge_mv_cfg_t		*mac_host_info;
1609 
1610 	int buff_alloc_size = NXGE_NDD_INFODUMP_BUFF_SIZE * 32;
1611 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_mac_rdcgrp "));
1612 	(void) mi_mpprintf(mp,
1613 	    "MAC ADDR RDC Mapping Information for Port\t %d\n",
1614 	    nxgep->function_num);
1615 
1616 	if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) {
1617 		(void) mi_mpprintf(mp, "%s\n", "out of buffer");
1618 		return (0);
1619 	}
1620 
1621 	buf_len = buff_alloc_size;
1622 	mp->b_cont = np;
1623 	p_class_cfgp = (p_nxge_class_pt_cfg_t)&nxgep->class_config;
1624 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
1625 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
1626 	mac_host_info = (nxge_mv_cfg_t	*)&p_class_cfgp->mac_host_info[0];
1627 	print_len = snprintf((char *)np->b_wptr, buf_len,
1628 	    "MAC ID\t RDC GRP (Actual/Port)\t"
1629 	    " Prefernce\n");
1630 	((mblk_t *)np)->b_wptr += print_len;
1631 	buf_len -= print_len;
1632 	for (i = 0; i < p_cfgp->max_macs; i++) {
1633 		if (mac_host_info[i].flag) {
1634 			print_len = snprintf((char *)((mblk_t *)np)->b_wptr,
1635 			    buf_len,
1636 			    "   %d\t  %d/%d\t\t %d\n",
1637 			    i, mac_host_info[i].rdctbl,
1638 			    mac_host_info[i].rdctbl -
1639 			    p_cfgp->def_mac_rxdma_grpid,
1640 			    mac_host_info[i].mpr_npr);
1641 			((mblk_t *)np)->b_wptr += print_len;
1642 			buf_len -= print_len;
1643 		}
1644 	}
1645 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
1646 	    "Done Info Dumping \n");
1647 	((mblk_t *)np)->b_wptr += print_len;
1648 	buf_len -= print_len;
1649 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_macrdcgrp"));
1650 	return (0);
1651 }
1652 
1653 /* ARGSUSED */
1654 static int
1655 nxge_param_tcam_enable(p_nxge_t nxgep, queue_t *q,
1656 	mblk_t *mp, char *value, caddr_t cp)
1657 {
1658 	uint32_t	status = 0, cfg_value;
1659 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1660 	uint32_t	cfg_it = B_FALSE;
1661 	char		*end;
1662 
1663 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_tcam_enable"));
1664 
1665 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_BINARY);
1666 	if (pa->value != cfg_value) {
1667 		pa->old_value = pa->value;
1668 		pa->value = cfg_value;
1669 		cfg_it = B_TRUE;
1670 	}
1671 
1672 	if (cfg_it == B_TRUE) {
1673 		if (pa->value)
1674 			status = nxge_fflp_config_tcam_enable(nxgep);
1675 		else
1676 			status = nxge_fflp_config_tcam_disable(nxgep);
1677 		if (status != NXGE_OK)
1678 			return (EINVAL);
1679 	}
1680 
1681 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, " <== nxge_param_tcam_enable"));
1682 	return (0);
1683 }
1684 
1685 /* ARGSUSED */
1686 static int
1687 nxge_param_hash_lookup_enable(p_nxge_t nxgep, queue_t *q,
1688 	mblk_t *mp, char *value, caddr_t cp)
1689 {
1690 	uint32_t	status = 0, cfg_value;
1691 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1692 	uint32_t	cfg_it = B_FALSE;
1693 	char		*end;
1694 
1695 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_hash_lookup_enable"));
1696 
1697 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_BINARY);
1698 	if (pa->value != cfg_value) {
1699 		pa->old_value = pa->value;
1700 		pa->value = cfg_value;
1701 		cfg_it = B_TRUE;
1702 	}
1703 
1704 	if (cfg_it == B_TRUE) {
1705 		if (pa->value)
1706 			status = nxge_fflp_config_hash_lookup_enable(nxgep);
1707 		else
1708 			status = nxge_fflp_config_hash_lookup_disable(nxgep);
1709 		if (status != NXGE_OK)
1710 			return (EINVAL);
1711 	}
1712 
1713 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, " <== nxge_param_hash_lookup_enable"));
1714 	return (0);
1715 }
1716 
1717 /* ARGSUSED */
1718 static int
1719 nxge_param_llc_snap_enable(p_nxge_t nxgep, queue_t *q,
1720 	mblk_t *mp, char *value, caddr_t cp)
1721 {
1722 	char		*end;
1723 	uint32_t	status = 0, cfg_value;
1724 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1725 	uint32_t	cfg_it = B_FALSE;
1726 
1727 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_llc_snap_enable"));
1728 
1729 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_BINARY);
1730 	if (pa->value != cfg_value) {
1731 		pa->old_value = pa->value;
1732 		pa->value = cfg_value;
1733 		cfg_it = B_TRUE;
1734 	}
1735 
1736 	if (cfg_it == B_TRUE) {
1737 		if (pa->value)
1738 			status = nxge_fflp_config_tcam_enable(nxgep);
1739 		else
1740 			status = nxge_fflp_config_tcam_disable(nxgep);
1741 		if (status != NXGE_OK)
1742 			return (EINVAL);
1743 	}
1744 
1745 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, " <== nxge_param_llc_snap_enable"));
1746 	return (0);
1747 }
1748 
1749 /* ARGSUSED */
1750 static int
1751 nxge_param_set_ether_usr(p_nxge_t nxgep, queue_t *q,
1752 	mblk_t	*mp, char *value, caddr_t cp)
1753 {
1754 	char		*end;
1755 	uint8_t		ether_class;
1756 	uint32_t	status = 0, cfg_value;
1757 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1758 	uint8_t		cfg_it = B_FALSE;
1759 
1760 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_ether_usr"));
1761 
1762 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_HEX);
1763 	if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) {
1764 		return (EINVAL);
1765 	}
1766 
1767 	if (pa->value != cfg_value) {
1768 		pa->old_value = pa->value;
1769 		pa->value = cfg_value;
1770 		cfg_it = B_TRUE;
1771 	}
1772 
1773 	/* do the actual hw setup  */
1774 	if (cfg_it == B_TRUE) {
1775 		ether_class = mi_strtol(pa->name, &end, 10);
1776 #ifdef lint
1777 		ether_class = ether_class;
1778 #endif
1779 		NXGE_DEBUG_MSG((nxgep, NDD_CTL, " nxge_param_set_ether_usr"));
1780 	}
1781 
1782 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_ether_usr"));
1783 	return (status);
1784 }
1785 
1786 /* ARGSUSED */
1787 static int
1788 nxge_param_set_ip_usr(p_nxge_t nxgep, queue_t *q,
1789 	mblk_t *mp, char *value, caddr_t cp)
1790 {
1791 	char		*end;
1792 	tcam_class_t	class;
1793 	uint32_t	status, cfg_value;
1794 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1795 	uint32_t	cfg_it = B_FALSE;
1796 
1797 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_ip_usr"));
1798 
1799 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_HEX);
1800 	if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) {
1801 		return (EINVAL);
1802 	}
1803 
1804 	if (pa->value != cfg_value) {
1805 		pa->old_value = pa->value;
1806 		pa->value = cfg_value;
1807 		cfg_it = B_TRUE;
1808 	}
1809 
1810 	/* do the actual hw setup with cfg_value. */
1811 	if (cfg_it == B_TRUE) {
1812 		class = mi_strtol(pa->name, &end, 10);
1813 		status = nxge_fflp_ip_usr_class_config(nxgep, class, pa->value);
1814 	}
1815 
1816 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_ip_usr"));
1817 	return (status);
1818 }
1819 
1820 /* ARGSUSED */
1821 static int
1822 nxge_class_name_2value(p_nxge_t nxgep, char *name)
1823 {
1824 	int		i;
1825 	int		class_instance = param_class_opt_ip_usr4;
1826 	p_nxge_param_t	param_arr;
1827 
1828 	param_arr = nxgep->param_arr;
1829 	for (i = TCAM_CLASS_IP_USER_4; i <= TCAM_CLASS_SCTP_IPV6; i++) {
1830 		if (strcmp(param_arr[class_instance].name, name) == 0)
1831 			return (i);
1832 		class_instance++;
1833 	}
1834 	return (-1);
1835 }
1836 
1837 /* ARGSUSED */
1838 int
1839 nxge_param_set_ip_opt(p_nxge_t nxgep, queue_t *q,
1840 	mblk_t *mp, char *value, caddr_t cp)
1841 {
1842 	char		*end;
1843 	uint32_t	status, cfg_value;
1844 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1845 	tcam_class_t	class;
1846 	uint32_t	cfg_it = B_FALSE;
1847 
1848 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_ip_opt"));
1849 
1850 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_HEX);
1851 	if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) {
1852 		return (EINVAL);
1853 	}
1854 
1855 	if (pa->value != cfg_value) {
1856 		pa->old_value = pa->value;
1857 		pa->value = cfg_value;
1858 		cfg_it = B_TRUE;
1859 	}
1860 
1861 	if (cfg_it == B_TRUE) {
1862 		/* do the actual hw setup  */
1863 		class = nxge_class_name_2value(nxgep, pa->name);
1864 		if (class == -1)
1865 			return (EINVAL);
1866 
1867 		/* Filter out the allowed bits */
1868 		pa->value &= (NXGE_CLASS_FLOW_USE_PORTNUM |
1869 		    NXGE_CLASS_FLOW_USE_L2DA | NXGE_CLASS_FLOW_USE_VLAN |
1870 		    NXGE_CLASS_FLOW_USE_PROTO | NXGE_CLASS_FLOW_USE_IPSRC |
1871 		    NXGE_CLASS_FLOW_USE_IPDST | NXGE_CLASS_FLOW_USE_SRC_PORT |
1872 		    NXGE_CLASS_FLOW_USE_DST_PORT);
1873 
1874 		status = nxge_fflp_ip_class_config(nxgep, class, pa->value);
1875 		if (status != NXGE_OK)
1876 			return (EINVAL);
1877 	}
1878 
1879 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_ip_opt"));
1880 	return (0);
1881 }
1882 
1883 /* ARGSUSED */
1884 static int
1885 nxge_param_get_ip_opt(p_nxge_t nxgep, queue_t *q,
1886 	mblk_t *mp, caddr_t cp)
1887 {
1888 	uint32_t status, cfg_value;
1889 	p_nxge_param_t pa = (p_nxge_param_t)cp;
1890 	tcam_class_t class;
1891 
1892 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_ip_opt"));
1893 
1894 	/* do the actual hw setup  */
1895 	class = nxge_class_name_2value(nxgep, pa->name);
1896 	if (class == -1)
1897 		return (EINVAL);
1898 
1899 	cfg_value = 0;
1900 	status = nxge_fflp_ip_class_config_get(nxgep, class, &cfg_value);
1901 	if (status != NXGE_OK)
1902 		return (EINVAL);
1903 
1904 	/* Filter out the allowed bits */
1905 	cfg_value &= (NXGE_CLASS_FLOW_USE_PORTNUM | NXGE_CLASS_FLOW_USE_L2DA |
1906 	    NXGE_CLASS_FLOW_USE_VLAN | NXGE_CLASS_FLOW_USE_PROTO |
1907 	    NXGE_CLASS_FLOW_USE_IPSRC | NXGE_CLASS_FLOW_USE_IPDST |
1908 	    NXGE_CLASS_FLOW_USE_SRC_PORT | NXGE_CLASS_FLOW_USE_DST_PORT);
1909 
1910 	NXGE_DEBUG_MSG((nxgep, NDD_CTL,
1911 	    "nxge_param_get_ip_opt_get %x ", cfg_value));
1912 
1913 	pa->value = cfg_value;
1914 	(void) mi_mpprintf(mp, "%x", cfg_value);
1915 
1916 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_ip_opt status "));
1917 	return (0);
1918 }
1919 
1920 /* ARGSUSED */
1921 static int
1922 nxge_param_fflp_hash_init(p_nxge_t nxgep, queue_t *q,
1923 	mblk_t *mp, char *value, caddr_t cp)
1924 {
1925 	char		*end;
1926 	uint32_t	status, cfg_value;
1927 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
1928 	tcam_class_t	class;
1929 	uint32_t	cfg_it = B_FALSE;
1930 
1931 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_fflp_hash_init"));
1932 
1933 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_HEX);
1934 	if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) {
1935 		return (EINVAL);
1936 	}
1937 
1938 	NXGE_DEBUG_MSG((nxgep, NDD_CTL,
1939 	    "nxge_param_fflp_hash_init value %x", cfg_value));
1940 
1941 	if (pa->value != cfg_value) {
1942 		pa->old_value = pa->value;
1943 		pa->value = cfg_value;
1944 		cfg_it = B_TRUE;
1945 	}
1946 
1947 	if (cfg_it == B_TRUE) {
1948 		char *h_name;
1949 
1950 		/* do the actual hw setup */
1951 		h_name = pa->name;
1952 		h_name++;
1953 		class = mi_strtol(h_name, &end, 10);
1954 		switch (class) {
1955 			case 1:
1956 				status = nxge_fflp_set_hash1(nxgep,
1957 				    (uint32_t)pa->value);
1958 				break;
1959 			case 2:
1960 				status = nxge_fflp_set_hash2(nxgep,
1961 				    (uint16_t)pa->value);
1962 				break;
1963 
1964 			default:
1965 			NXGE_DEBUG_MSG((nxgep, NDD_CTL,
1966 			    " nxge_param_fflp_hash_init"
1967 			    " %s Wrong hash var %d",
1968 			    pa->name, class));
1969 			return (EINVAL);
1970 		}
1971 		if (status != NXGE_OK)
1972 			return (EINVAL);
1973 	}
1974 
1975 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, " <== nxge_param_fflp_hash_init"));
1976 	return (0);
1977 }
1978 
1979 /* ARGSUSED */
1980 static int
1981 nxge_param_set_grp_rdc(p_nxge_t nxgep, queue_t *q,
1982 	mblk_t *mp, char *value, caddr_t cp)
1983 {
1984 	char			*end;
1985 	uint32_t		status = 0, cfg_value;
1986 	p_nxge_param_t		pa = (p_nxge_param_t)cp;
1987 	uint32_t		cfg_it = B_FALSE;
1988 	int			rdc_grp;
1989 	uint8_t			real_rdc;
1990 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
1991 	p_nxge_hw_pt_cfg_t	p_cfgp;
1992 	p_nxge_rdc_grp_t	rdc_grp_p;
1993 
1994 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
1995 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
1996 
1997 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_grp_rdc"));
1998 
1999 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_ANY);
2000 	if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) {
2001 		return (EINVAL);
2002 	}
2003 
2004 	if (cfg_value >= p_cfgp->max_rdcs) {
2005 		return (EINVAL);
2006 	}
2007 
2008 	if (pa->value != cfg_value) {
2009 		pa->old_value = pa->value;
2010 		pa->value = cfg_value;
2011 		cfg_it = B_TRUE;
2012 	}
2013 
2014 	if (cfg_it == B_TRUE) {
2015 		char *grp_name;
2016 		grp_name = pa->name;
2017 		grp_name += strlen("default-grp");
2018 		rdc_grp = mi_strtol(grp_name, &end, 10);
2019 		rdc_grp_p = &p_dma_cfgp->rdc_grps[rdc_grp];
2020 		real_rdc = rdc_grp_p->start_rdc + cfg_value;
2021 		if (nxge_check_rxdma_rdcgrp_member(nxgep, rdc_grp,
2022 		    cfg_value) == B_FALSE) {
2023 			pa->value = pa->old_value;
2024 			NXGE_DEBUG_MSG((nxgep, NDD_CTL,
2025 			    " nxge_param_set_grp_rdc"
2026 			    " %d read %d actual %d outof range",
2027 			    rdc_grp, cfg_value, real_rdc));
2028 			return (EINVAL);
2029 		}
2030 		status = nxge_rxdma_cfg_rdcgrp_default_rdc(nxgep, rdc_grp,
2031 		    real_rdc);
2032 		if (status != NXGE_OK)
2033 			return (EINVAL);
2034 	}
2035 
2036 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_grp_rdc"));
2037 	return (0);
2038 }
2039 
2040 /* ARGSUSED */
2041 static int
2042 nxge_param_set_port_rdc(p_nxge_t nxgep, queue_t *q,
2043 	mblk_t *mp, char *value, caddr_t cp)
2044 {
2045 	char		*end;
2046 	uint32_t	status = B_TRUE, cfg_value;
2047 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
2048 	uint32_t	cfg_it = B_FALSE;
2049 
2050 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
2051 	p_nxge_hw_pt_cfg_t	p_cfgp;
2052 
2053 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_port_rdc"));
2054 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
2055 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
2056 
2057 	cfg_value = (uint32_t)mi_strtol(value, &end, BASE_ANY);
2058 	if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) {
2059 		return (EINVAL);
2060 	}
2061 
2062 	if (pa->value != cfg_value) {
2063 		if (cfg_value >= p_cfgp->max_rdcs)
2064 			return (EINVAL);
2065 		pa->old_value = pa->value;
2066 		pa->value = cfg_value;
2067 		cfg_it = B_TRUE;
2068 	}
2069 
2070 	if (cfg_it == B_TRUE) {
2071 		int rdc;
2072 		if ((rdc = nxge_dci_map(nxgep, VP_BOUND_RX, cfg_value)) < 0)
2073 			return (EINVAL);
2074 		status = nxge_rxdma_cfg_port_default_rdc(nxgep,
2075 		    nxgep->function_num, rdc);
2076 		if (status != NXGE_OK)
2077 			return (EINVAL);
2078 	}
2079 
2080 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_port_rdc"));
2081 	return (0);
2082 }
2083 
2084 /* ARGSUSED */
2085 static int
2086 nxge_param_set_nxge_debug_flag(p_nxge_t nxgep, queue_t *q,
2087 	mblk_t *mp, char *value, caddr_t cp)
2088 {
2089 	char *end;
2090 	uint32_t status = 0;
2091 	uint64_t cfg_value = 0;
2092 	p_nxge_param_t pa = (p_nxge_param_t)cp;
2093 	uint32_t cfg_it = B_FALSE;
2094 
2095 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_nxge_debug_flag"));
2096 	cfg_value = mi_strtol(value, &end, BASE_HEX);
2097 
2098 	if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) {
2099 		NXGE_DEBUG_MSG((nxgep, NDD_CTL,
2100 		    " nxge_param_set_nxge_debug_flag"
2101 		    " outof range %llx", cfg_value));
2102 		return (EINVAL);
2103 	}
2104 	if (pa->value != cfg_value) {
2105 		pa->old_value = pa->value;
2106 		pa->value = cfg_value;
2107 		cfg_it = B_TRUE;
2108 	}
2109 
2110 	if (cfg_it == B_TRUE) {
2111 		nxgep->nxge_debug_level = pa->value;
2112 	}
2113 
2114 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_nxge_debug_flag"));
2115 	return (status);
2116 }
2117 
2118 /* ARGSUSED */
2119 static int
2120 nxge_param_get_debug_flag(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2121 {
2122 	int		status = 0;
2123 	p_nxge_param_t	pa = (p_nxge_param_t)cp;
2124 
2125 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_debug_flag"));
2126 
2127 	if (pa->value > 0xffffffff)
2128 		(void) mi_mpprintf(mp, "%x%x",  (int)(pa->value >> 32),
2129 		    (int)(pa->value & 0xffffffff));
2130 	else
2131 		(void) mi_mpprintf(mp, "%x", (int)pa->value);
2132 
2133 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_debug_flag"));
2134 	return (status);
2135 }
2136 
2137 /* ARGSUSED */
2138 static int
2139 nxge_param_set_npi_debug_flag(p_nxge_t nxgep, queue_t *q,
2140 	mblk_t *mp, char *value, caddr_t cp)
2141 {
2142 	char		*end;
2143 	uint32_t	status = 0;
2144 	uint64_t	 cfg_value = 0;
2145 	p_nxge_param_t	pa;
2146 	uint32_t	cfg_it = B_FALSE;
2147 
2148 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_npi_debug_flag"));
2149 	cfg_value = mi_strtol(value, &end, BASE_HEX);
2150 	pa = (p_nxge_param_t)cp;
2151 	if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) {
2152 		NXGE_DEBUG_MSG((nxgep, NDD_CTL, " nxge_param_set_npi_debug_flag"
2153 		    " outof range %llx", cfg_value));
2154 		return (EINVAL);
2155 	}
2156 	if (pa->value != cfg_value) {
2157 		pa->old_value = pa->value;
2158 		pa->value = cfg_value;
2159 		cfg_it = B_TRUE;
2160 	}
2161 
2162 	if (cfg_it == B_TRUE) {
2163 		npi_debug_level = pa->value;
2164 	}
2165 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_set_debug_flag"));
2166 	return (status);
2167 }
2168 
2169 /* ARGSUSED */
2170 static int
2171 nxge_param_dump_rdc(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2172 {
2173 	nxge_grp_set_t *set = &nxgep->rx_set;
2174 	int rdc;
2175 
2176 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_dump_rdc"));
2177 
2178 	if (!isLDOMguest(nxgep))
2179 		(void) npi_rxdma_dump_fzc_regs(NXGE_DEV_NPI_HANDLE(nxgep));
2180 
2181 	for (rdc = 0; rdc < NXGE_MAX_TDCS; rdc++) {
2182 		if ((1 << rdc) & set->owned.map) {
2183 			(void) nxge_dump_rxdma_channel(nxgep, rdc);
2184 		}
2185 	}
2186 
2187 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_dump_rdc"));
2188 	return (0);
2189 }
2190 
2191 /* ARGSUSED */
2192 static int
2193 nxge_param_dump_tdc(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2194 {
2195 	nxge_grp_set_t *set = &nxgep->tx_set;
2196 	int tdc;
2197 
2198 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_dump_tdc"));
2199 
2200 	for (tdc = 0; tdc < NXGE_MAX_TDCS; tdc++) {
2201 		if ((1 << tdc) & set->owned.map) {
2202 			(void) nxge_txdma_regs_dump(nxgep, tdc);
2203 		}
2204 	}
2205 
2206 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_dump_tdc"));
2207 	return (0);
2208 }
2209 
2210 /* ARGSUSED */
2211 static int
2212 nxge_param_dump_fflp_regs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2213 {
2214 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_dump_fflp_regs"));
2215 
2216 	(void) npi_fflp_dump_regs(NXGE_DEV_NPI_HANDLE(nxgep));
2217 
2218 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_dump_fflp_regs"));
2219 	return (0);
2220 }
2221 
2222 /* ARGSUSED */
2223 static int
2224 nxge_param_dump_mac_regs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2225 {
2226 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_dump_mac_regs"));
2227 
2228 	(void) npi_mac_dump_regs(NXGE_DEV_NPI_HANDLE(nxgep),
2229 	    nxgep->function_num);
2230 
2231 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_dump_mac_regs"));
2232 	return (0);
2233 }
2234 
2235 /* ARGSUSED */
2236 static int
2237 nxge_param_dump_ipp_regs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2238 {
2239 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_dump_ipp_regs"));
2240 
2241 	(void) npi_ipp_dump_regs(NXGE_DEV_NPI_HANDLE(nxgep),
2242 	    nxgep->function_num);
2243 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_dump_ipp_regs"));
2244 	return (0);
2245 }
2246 
2247 /* ARGSUSED */
2248 static int
2249 nxge_param_dump_vlan_table(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2250 {
2251 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_dump_vlan_table"));
2252 
2253 	(void) npi_fflp_vlan_tbl_dump(NXGE_DEV_NPI_HANDLE(nxgep));
2254 
2255 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_dump_vlan_table"));
2256 	return (0);
2257 }
2258 
2259 /* ARGSUSED */
2260 static int
2261 nxge_param_dump_rdc_table(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2262 {
2263 	uint8_t	table;
2264 
2265 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_dump_rdc_table"));
2266 	for (table = 0; table < NXGE_MAX_RDC_GROUPS; table++) {
2267 		(void) npi_rxdma_dump_rdc_table(NXGE_DEV_NPI_HANDLE(nxgep),
2268 		    table);
2269 	}
2270 
2271 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_dump_rdc_table"));
2272 	return (0);
2273 }
2274 
2275 typedef struct block_info {
2276 	char		*name;
2277 	uint32_t	offset;
2278 } block_info_t;
2279 
2280 block_info_t reg_block[] = {
2281 	{"PIO",		PIO},
2282 	{"FZC_PIO",	FZC_PIO},
2283 	{"FZC_XMAC",	FZC_MAC},
2284 	{"FZC_IPP",	FZC_IPP},
2285 	{"FFLP",	FFLP},
2286 	{"FZC_FFLP",	FZC_FFLP},
2287 	{"PIO_VADDR",	PIO_VADDR},
2288 	{"ZCP",	ZCP},
2289 	{"FZC_ZCP",	FZC_ZCP},
2290 	{"DMC",	DMC},
2291 	{"FZC_DMC",	FZC_DMC},
2292 	{"TXC",	TXC},
2293 	{"FZC_TXC",	FZC_TXC},
2294 	{"PIO_LDSV",	PIO_LDSV},
2295 	{"PIO_LDGIM",	PIO_LDGIM},
2296 	{"PIO_IMASK0",	PIO_IMASK0},
2297 	{"PIO_IMASK1",	PIO_IMASK1},
2298 	{"FZC_PROM",	FZC_PROM},
2299 	{"END",	ALL_FF_32},
2300 };
2301 
2302 /* ARGSUSED */
2303 static int
2304 nxge_param_dump_ptrs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp)
2305 {
2306 	uint_t			print_len, buf_len;
2307 	p_mblk_t		np;
2308 	int			rdc, tdc, block;
2309 	uint64_t		base;
2310 	p_nxge_dma_pt_cfg_t	p_dma_cfgp;
2311 	p_nxge_hw_pt_cfg_t	p_cfgp;
2312 	int			buff_alloc_size = NXGE_NDD_INFODUMP_BUFF_8K;
2313 	p_tx_ring_t 		*tx_rings;
2314 	p_rx_rcr_rings_t 	rx_rcr_rings;
2315 	p_rx_rcr_ring_t		*rcr_rings;
2316 	p_rx_rbr_rings_t 	rx_rbr_rings;
2317 	p_rx_rbr_ring_t		*rbr_rings;
2318 
2319 	NXGE_DEBUG_MSG((nxgep, IOC_CTL,
2320 	    "==> nxge_param_dump_ptrs"));
2321 
2322 	(void) mi_mpprintf(mp, "ptr information for Port\t %d \n",
2323 	    nxgep->function_num);
2324 
2325 	if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) {
2326 		/* The following may work even if we cannot get a large buf. */
2327 		(void) mi_mpprintf(mp, "%s\n", "out of buffer");
2328 		return (0);
2329 	}
2330 
2331 	buf_len = buff_alloc_size;
2332 	mp->b_cont = np;
2333 	p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config;
2334 	p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config;
2335 
2336 	rx_rcr_rings = nxgep->rx_rcr_rings;
2337 	rcr_rings = rx_rcr_rings->rcr_rings;
2338 	rx_rbr_rings = nxgep->rx_rbr_rings;
2339 	rbr_rings = rx_rbr_rings->rbr_rings;
2340 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
2341 	    "nxgep (nxge_t) $%p\n"
2342 	    "dev_regs (dev_regs_t) $%p\n",
2343 	    (void *)nxgep, (void *)nxgep->dev_regs);
2344 
2345 	ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2346 
2347 	/* do register pointers */
2348 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
2349 	    "reg base (npi_reg_ptr_t) $%p\t "
2350 	    "pci reg (npi_reg_ptr_t) $%p\n",
2351 	    (void *)nxgep->dev_regs->nxge_regp,
2352 	    (void *)nxgep->dev_regs->nxge_pciregp);
2353 
2354 	ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2355 
2356 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
2357 	    "\nBlock \t Offset \n");
2358 
2359 	ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2360 	block = 0;
2361 #if defined(__i386)
2362 	base = (uint64_t)(uint32_t)nxgep->dev_regs->nxge_regp;
2363 #else
2364 	base = (uint64_t)nxgep->dev_regs->nxge_regp;
2365 #endif
2366 	while (reg_block[block].offset != ALL_FF_32) {
2367 		print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
2368 		    "%9s\t 0x%llx\n",
2369 		    reg_block[block].name,
2370 		    (unsigned long long)(reg_block[block].offset + base));
2371 		ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2372 		block++;
2373 	}
2374 
2375 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
2376 	    "\nRDC\t rcrp (rx_rcr_ring_t)\t "
2377 	    "rbrp (rx_rbr_ring_t)\n");
2378 
2379 	ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2380 
2381 	for (rdc = 0; rdc < p_cfgp->max_rdcs; rdc++) {
2382 		print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
2383 		    " %d\t  $%p\t\t   $%p\n",
2384 		    rdc, (void *)rcr_rings[rdc],
2385 		    (void *)rbr_rings[rdc]);
2386 		ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2387 	}
2388 
2389 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
2390 	    "\nTDC\t tdcp (tx_ring_t)\n");
2391 
2392 	ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2393 	tx_rings = nxgep->tx_rings->rings;
2394 	for (tdc = 0; tdc < p_cfgp->tdc.count; tdc++) {
2395 		print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len,
2396 		    " %d\t  $%p\n", tdc, (void *)tx_rings[tdc]);
2397 		ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2398 	}
2399 
2400 	print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, "\n\n");
2401 
2402 	ADVANCE_PRINT_BUFFER(np, print_len, buf_len);
2403 	NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_dump_ptrs"));
2404 	return (0);
2405 }
2406 
2407 
2408 /* ARGSUSED */
2409 int
2410 nxge_nd_get_names(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t param)
2411 {
2412 	ND		*nd;
2413 	NDE		*nde;
2414 	char		*rwtag;
2415 	boolean_t	get_ok, set_ok;
2416 	size_t		param_len;
2417 	int		status = 0;
2418 
2419 	nd = (ND *)param;
2420 	if (!nd)
2421 		return (ENOENT);
2422 
2423 	for (nde = nd->nd_tbl; nde->nde_name; nde++) {
2424 		get_ok = (nde->nde_get_pfi != nxge_get_default) &&
2425 		    (nde->nde_get_pfi != NULL);
2426 		set_ok = (nde->nde_set_pfi != nxge_set_default) &&
2427 		    (nde->nde_set_pfi != NULL);
2428 		if (get_ok) {
2429 			if (set_ok)
2430 				rwtag = "read and write";
2431 			else
2432 				rwtag = "read only";
2433 		} else if (set_ok)
2434 			rwtag = "write only";
2435 		else {
2436 			continue;
2437 		}
2438 		param_len = strlen(rwtag);
2439 		param_len += strlen(nde->nde_name);
2440 		param_len += 4;
2441 
2442 		(void) mi_mpprintf(mp, "%s (%s)", nde->nde_name, rwtag);
2443 	}
2444 	return (status);
2445 }
2446 
2447 /* ARGSUSED */
2448 int
2449 nxge_get_default(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t data)
2450 {
2451 	return (EACCES);
2452 }
2453 
2454 /* ARGSUSED */
2455 int
2456 nxge_set_default(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, char *value,
2457 	caddr_t data)
2458 {
2459 	return (EACCES);
2460 }
2461 
2462 boolean_t
2463 nxge_param_link_update(p_nxge_t nxgep)
2464 {
2465 	p_nxge_param_t 		param_arr;
2466 	nxge_param_index_t 	i;
2467 	boolean_t 		update_xcvr;
2468 	boolean_t 		update_dev;
2469 	int 			instance;
2470 	boolean_t 		status = B_TRUE;
2471 
2472 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_link_update"));
2473 
2474 	param_arr = nxgep->param_arr;
2475 	instance = nxgep->instance;
2476 	update_xcvr = B_FALSE;
2477 	for (i = param_anar_1000fdx; i < param_anar_asmpause; i++) {
2478 		update_xcvr |= param_arr[i].value;
2479 	}
2480 
2481 	if (update_xcvr) {
2482 		update_xcvr = B_FALSE;
2483 		for (i = param_autoneg; i < param_enable_ipg0; i++) {
2484 			update_xcvr |=
2485 			    (param_arr[i].value != param_arr[i].old_value);
2486 			param_arr[i].old_value = param_arr[i].value;
2487 		}
2488 		if (update_xcvr) {
2489 			NXGE_DEBUG_MSG((nxgep, NDD_CTL,
2490 			    "==> nxge_param_link_update: update xcvr"));
2491 			RW_ENTER_WRITER(&nxgep->filter_lock);
2492 			(void) nxge_link_monitor(nxgep, LINK_MONITOR_STOP);
2493 			(void) nxge_link_init(nxgep);
2494 			(void) nxge_mac_init(nxgep);
2495 			(void) nxge_link_monitor(nxgep, LINK_MONITOR_START);
2496 			RW_EXIT(&nxgep->filter_lock);
2497 		}
2498 	} else {
2499 		cmn_err(CE_WARN, " Last setting will leave nxge%d with "
2500 		    " no link capabilities.", instance);
2501 		cmn_err(CE_WARN, " Restoring previous setting.");
2502 		for (i = param_anar_1000fdx; i < param_anar_asmpause; i++)
2503 			param_arr[i].value = param_arr[i].old_value;
2504 	}
2505 
2506 	update_dev = B_FALSE;
2507 
2508 	if (update_dev) {
2509 		RW_ENTER_WRITER(&nxgep->filter_lock);
2510 		NXGE_DEBUG_MSG((nxgep, NDD_CTL,
2511 		    "==> nxge_param_link_update: update dev"));
2512 		(void) nxge_rx_mac_disable(nxgep);
2513 		(void) nxge_tx_mac_disable(nxgep);
2514 		(void) nxge_tx_mac_enable(nxgep);
2515 		(void) nxge_rx_mac_enable(nxgep);
2516 		RW_EXIT(&nxgep->filter_lock);
2517 	}
2518 
2519 nxge_param_hw_update_exit:
2520 	NXGE_DEBUG_MSG((nxgep, DDI_CTL,
2521 	    "<== nxge_param_link_update status = 0x%08x", status));
2522 	return (status);
2523 }
2524 
2525 /*
2526  * synchronize the  adv* and en* parameters.
2527  *
2528  * See comments in <sys/dld.h> for details of the *_en_*
2529  * parameters.  The usage of ndd for setting adv parameters will
2530  * synchronize all the en parameters with the nxge parameters,
2531  * implicitly disabling any settings made via dladm.
2532  */
2533 static void
2534 nxge_param_sync(p_nxge_t nxgep)
2535 {
2536 	p_nxge_param_t	param_arr;
2537 	param_arr = nxgep->param_arr;
2538 
2539 	nxgep->param_en_pause	= param_arr[param_anar_pause].value;
2540 	nxgep->param_en_1000fdx	= param_arr[param_anar_1000fdx].value;
2541 	nxgep->param_en_100fdx	= param_arr[param_anar_100fdx].value;
2542 	nxgep->param_en_10fdx	= param_arr[param_anar_10fdx].value;
2543 }
2544 
2545 /* ARGSUSED */
2546 int
2547 nxge_dld_get_ip_opt(p_nxge_t nxgep, caddr_t cp)
2548 {
2549 	uint32_t status, cfg_value;
2550 	p_nxge_param_t pa = (p_nxge_param_t)cp;
2551 	tcam_class_t class;
2552 
2553 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_dld_get_ip_opt"));
2554 
2555 	/* do the actual hw setup  */
2556 	class = nxge_class_name_2value(nxgep, pa->name);
2557 	if (class == -1)
2558 		return (EINVAL);
2559 
2560 	cfg_value = 0;
2561 	status = nxge_fflp_ip_class_config_get(nxgep, class, &cfg_value);
2562 	if (status != NXGE_OK)
2563 		return (EINVAL);
2564 
2565 	/* Filter out the allowed bits */
2566 	cfg_value &= (NXGE_CLASS_FLOW_USE_PORTNUM | NXGE_CLASS_FLOW_USE_L2DA |
2567 	    NXGE_CLASS_FLOW_USE_VLAN | NXGE_CLASS_FLOW_USE_PROTO |
2568 	    NXGE_CLASS_FLOW_USE_IPSRC | NXGE_CLASS_FLOW_USE_IPDST |
2569 	    NXGE_CLASS_FLOW_USE_SRC_PORT | NXGE_CLASS_FLOW_USE_DST_PORT);
2570 
2571 	NXGE_DEBUG_MSG((nxgep, NDD_CTL,
2572 	    "nxge_param_get_ip_opt_get %x ", cfg_value));
2573 
2574 	pa->value = cfg_value;
2575 
2576 	NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_ip_opt status "));
2577 	return (0);
2578 }
2579