xref: /freebsd/sys/dev/ocs_fc/ocs_mgmt.c (revision eac7052fdebb90caf2f653e06187bdbca837b9c7)
1 /*-
2  * Copyright (c) 2017 Broadcom. All rights reserved.
3  * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright notice,
9  *    this list of conditions and the following disclaimer.
10  *
11  * 2. Redistributions in binary form must reproduce the above copyright notice,
12  *    this list of conditions and the following disclaimer in the documentation
13  *    and/or other materials provided with the distribution.
14  *
15  * 3. Neither the name of the copyright holder nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  *
31  * $FreeBSD$
32  */
33 
34 /**
35  * @file
36  * The ocs_mgmt top level functions for Fibre Channel.
37  */
38 
39 /**
40  * @defgroup mgmt Management Functions
41  */
42 
43 #include "ocs.h"
44 #include "ocs_mgmt.h"
45 #include "ocs_vpd.h"
46 
47 #define SFP_PAGE_SIZE 128
48 
49 /* Executables*/
50 
51 static int ocs_mgmt_firmware_write(ocs_t *ocs, char *, void *buf, uint32_t buf_len, void*, uint32_t);
52 static int ocs_mgmt_firmware_reset(ocs_t *ocs, char *, void *buf, uint32_t buf_len, void*, uint32_t);
53 static int ocs_mgmt_function_reset(ocs_t *ocs, char *, void *buf, uint32_t buf_len, void*, uint32_t);
54 
55 static void ocs_mgmt_fw_write_cb(int32_t status, uint32_t actual_write_length, uint32_t change_status, void *arg);
56 static int ocs_mgmt_force_assert(ocs_t *ocs, char *, void *buf, uint32_t buf_len, void*, uint32_t);
57 
58 #if defined(OCS_INCLUDE_RAMD)
59 static int32_t
60 ocs_mgmt_read_phys(ocs_t *ocs, char *, void *, uint32_t , void *, uint32_t);
61 #endif
62 
63 /* Getters */
64 
65 static void get_nodes_count(ocs_t *, char *, ocs_textbuf_t*);
66 static void get_desc(ocs_t *, char *, ocs_textbuf_t*);
67 static void get_fw_rev(ocs_t *, char *, ocs_textbuf_t*);
68 static void get_fw_rev2(ocs_t *, char *, ocs_textbuf_t*);
69 static void get_ipl(ocs_t *, char *, ocs_textbuf_t*);
70 static void get_wwnn(ocs_t *, char *, ocs_textbuf_t*);
71 static void get_wwpn(ocs_t *, char *, ocs_textbuf_t*);
72 static void get_fcid(ocs_t *, char *, ocs_textbuf_t *);
73 static void get_sn(ocs_t *, char *, ocs_textbuf_t*);
74 static void get_pn(ocs_t *, char *, ocs_textbuf_t*);
75 static void get_sli4_intf_reg(ocs_t *, char *, ocs_textbuf_t*);
76 static void get_phy_port_num(ocs_t *, char *, ocs_textbuf_t*);
77 static void get_asic_id(ocs_t *, char *, ocs_textbuf_t*);
78 static void get_pci_vendor(ocs_t *, char *, ocs_textbuf_t*);
79 static void get_pci_device(ocs_t *, char *, ocs_textbuf_t*);
80 static void get_pci_subsystem_vendor(ocs_t *, char *, ocs_textbuf_t*);
81 static void get_pci_subsystem_device(ocs_t *, char *, ocs_textbuf_t*);
82 static void get_businfo(ocs_t *, char *, ocs_textbuf_t*);
83 static void get_sfp_a0(ocs_t *, char *, ocs_textbuf_t*);
84 static void get_sfp_a2(ocs_t *, char *, ocs_textbuf_t*);
85 static void get_hw_rev1(ocs_t *, char *, ocs_textbuf_t*);
86 static void get_hw_rev2(ocs_t *, char *, ocs_textbuf_t*);
87 static void get_hw_rev3(ocs_t *, char *, ocs_textbuf_t*);
88 static void get_debug_mq_dump(ocs_t*, char*, ocs_textbuf_t*);
89 static void get_debug_cq_dump(ocs_t*, char*, ocs_textbuf_t*);
90 static void get_debug_wq_dump(ocs_t*, char*, ocs_textbuf_t*);
91 static void get_debug_eq_dump(ocs_t*, char*, ocs_textbuf_t*);
92 static void get_logmask(ocs_t*, char*, ocs_textbuf_t*);
93 static void get_current_speed(ocs_t*, char*, ocs_textbuf_t*);
94 static void get_current_topology(ocs_t*, char*, ocs_textbuf_t*);
95 static void get_current_link_state(ocs_t*, char*, ocs_textbuf_t*);
96 static void get_configured_speed(ocs_t*, char*, ocs_textbuf_t*);
97 static void get_configured_topology(ocs_t*, char*, ocs_textbuf_t*);
98 static void get_configured_link_state(ocs_t*, char*, ocs_textbuf_t*);
99 static void get_linkcfg(ocs_t*, char*, ocs_textbuf_t*);
100 static void get_req_wwnn(ocs_t*, char*, ocs_textbuf_t*);
101 static void get_req_wwpn(ocs_t*, char*, ocs_textbuf_t*);
102 static void get_nodedb_mask(ocs_t*, char*, ocs_textbuf_t*);
103 static void get_profile_list(ocs_t*, char*, ocs_textbuf_t*);
104 static void get_active_profile(ocs_t*, char*, ocs_textbuf_t*);
105 static void get_port_protocol(ocs_t*, char*, ocs_textbuf_t*);
106 static void get_driver_version(ocs_t*, char*, ocs_textbuf_t*);
107 static void get_chip_type(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
108 static void get_tgt_rscn_delay(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
109 static void get_tgt_rscn_period(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
110 static void get_inject_drop_cmd(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
111 static void get_inject_free_drop_cmd(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
112 static void get_inject_drop_data(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
113 static void get_inject_drop_resp(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
114 static void get_cmd_err_inject(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
115 static void get_cmd_delay_value(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
116 static void get_nv_wwpn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
117 static void get_nv_wwnn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
118 static void get_loglevel(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
119 static void get_node_abort_cnt(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
120 
121 /* Setters */
122 static int set_debug_mq_dump(ocs_t*, char*, char*);
123 static int set_debug_cq_dump(ocs_t*, char*, char*);
124 static int set_debug_wq_dump(ocs_t*, char*, char*);
125 static int set_debug_eq_dump(ocs_t*, char*, char*);
126 static int set_logmask(ocs_t*, char*, char*);
127 static int set_configured_link_state(ocs_t*, char*, char*);
128 static int set_linkcfg(ocs_t*, char*, char*);
129 static int set_nodedb_mask(ocs_t*, char*, char*);
130 static int set_port_protocol(ocs_t*, char*, char*);
131 static int set_active_profile(ocs_t*, char*, char*);
132 static int set_tgt_rscn_delay(ocs_t*, char*, char*);
133 static int set_tgt_rscn_period(ocs_t*, char*, char*);
134 static int set_inject_drop_cmd(ocs_t*, char*, char*);
135 static int set_inject_free_drop_cmd(ocs_t*, char*, char*);
136 static int set_inject_drop_data(ocs_t*, char*, char*);
137 static int set_inject_drop_resp(ocs_t*, char*, char*);
138 static int set_cmd_err_inject(ocs_t*, char*, char*);
139 static int set_cmd_delay_value(ocs_t*, char*, char*);
140 static int set_nv_wwn(ocs_t*, char*, char*);
141 static int set_loglevel(ocs_t*, char*, char*);
142 
143 static void ocs_mgmt_linkcfg_cb(int32_t status, uintptr_t value, void *arg);
144 #if defined(OCS_INCLUDE_RAMD)
145 static void* find_address_in_target(ocs_ramdisc_t **ramdisc_array, uint32_t ramdisc_count, uintptr_t target_addr);
146 #endif
147 
148 ocs_mgmt_table_entry_t mgmt_table[] = {
149 		{"nodes_count", get_nodes_count, NULL, NULL},
150 		{"desc", get_desc, NULL, NULL},
151 		{"fw_rev", get_fw_rev, NULL, NULL},
152 		{"fw_rev2", get_fw_rev2, NULL, NULL},
153 		{"ipl", get_ipl, NULL, NULL},
154 		{"hw_rev1", get_hw_rev1, NULL, NULL},
155 		{"hw_rev2", get_hw_rev2, NULL, NULL},
156 		{"hw_rev3", get_hw_rev3, NULL, NULL},
157 		{"wwnn", get_wwnn, NULL, NULL},
158 		{"wwpn", get_wwpn, NULL, NULL},
159 		{"fc_id", get_fcid, NULL, NULL},
160 		{"sn", get_sn, NULL, NULL},
161 		{"pn", get_pn, NULL, NULL},
162 		{"sli4_intf_reg", get_sli4_intf_reg, NULL, NULL},
163 		{"phy_port_num", get_phy_port_num, NULL, NULL},
164 		{"asic_id_reg", get_asic_id, NULL, NULL},
165 		{"pci_vendor", get_pci_vendor, NULL, NULL},
166 		{"pci_device", get_pci_device, NULL, NULL},
167 		{"pci_subsystem_vendor", get_pci_subsystem_vendor, NULL, NULL},
168 		{"pci_subsystem_device", get_pci_subsystem_device, NULL, NULL},
169 		{"businfo", get_businfo, NULL, NULL},
170 		{"sfp_a0", get_sfp_a0, NULL, NULL},
171 		{"sfp_a2", get_sfp_a2, NULL, NULL},
172 		{"profile_list", get_profile_list, NULL, NULL},
173 		{"driver_version", get_driver_version, NULL, NULL},
174 		{"current_speed", get_current_speed, NULL, NULL},
175 		{"current_topology", get_current_topology, NULL, NULL},
176 		{"current_link_state", get_current_link_state, NULL, NULL},
177 		{"chip_type", get_chip_type, NULL, NULL},
178 		{"configured_speed", get_configured_speed, set_configured_speed, NULL},
179 		{"configured_topology", get_configured_topology, set_configured_topology, NULL},
180 		{"configured_link_state", get_configured_link_state, set_configured_link_state, NULL},
181 		{"debug_mq_dump", get_debug_mq_dump, set_debug_mq_dump, NULL},
182 		{"debug_cq_dump", get_debug_cq_dump, set_debug_cq_dump, NULL},
183 		{"debug_wq_dump", get_debug_wq_dump, set_debug_wq_dump, NULL},
184 		{"debug_eq_dump", get_debug_eq_dump, set_debug_eq_dump, NULL},
185 		{"logmask", get_logmask, set_logmask, NULL},
186 		{"loglevel", get_loglevel, set_loglevel, NULL},
187 		{"linkcfg", get_linkcfg, set_linkcfg, NULL},
188 		{"requested_wwnn", get_req_wwnn, set_req_wwnn, NULL},
189 		{"requested_wwpn", get_req_wwpn, set_req_wwpn, NULL},
190 		{"nodedb_mask", get_nodedb_mask, set_nodedb_mask, NULL},
191 		{"port_protocol", get_port_protocol, set_port_protocol, NULL},
192 		{"active_profile", get_active_profile, set_active_profile, NULL},
193 		{"firmware_write", NULL, NULL, ocs_mgmt_firmware_write},
194 		{"firmware_reset", NULL, NULL, ocs_mgmt_firmware_reset},
195 		{"function_reset", NULL, NULL, ocs_mgmt_function_reset},
196 #if defined(OCS_INCLUDE_RAMD)
197 		{"read_phys", NULL, NULL, ocs_mgmt_read_phys},
198 #endif
199 		{"force_assert", NULL, NULL, ocs_mgmt_force_assert},
200 
201 		{"tgt_rscn_delay", get_tgt_rscn_delay, set_tgt_rscn_delay, NULL},
202 		{"tgt_rscn_period", get_tgt_rscn_period, set_tgt_rscn_period, NULL},
203 		{"inject_drop_cmd", get_inject_drop_cmd, set_inject_drop_cmd, NULL},
204 		{"inject_free_drop_cmd", get_inject_free_drop_cmd, set_inject_free_drop_cmd, NULL},
205 		{"inject_drop_data", get_inject_drop_data, set_inject_drop_data, NULL},
206 		{"inject_drop_resp", get_inject_drop_resp, set_inject_drop_resp, NULL},
207 		{"cmd_err_inject", get_cmd_err_inject, set_cmd_err_inject, NULL},
208 		{"cmd_delay_value", get_cmd_delay_value, set_cmd_delay_value, NULL},
209 		{"nv_wwpn", get_nv_wwpn, NULL, NULL},
210 		{"nv_wwnn", get_nv_wwnn, NULL, NULL},
211 		{"nv_wwn", NULL, set_nv_wwn, NULL},
212 		{"node_abort_cnt", get_node_abort_cnt, NULL, NULL},
213 };
214 
215 /**
216  * @ingroup mgmt
217  * @brief Get a list of options supported by the driver.
218  *
219  * @par Description
220  * This is the top level "get list" handler for the driver. It
221  * performs the following:
222  *  - Adds entries to the textbuf for any actions supported by this level in the driver.
223  *  - Calls a back-end function to add any actions supported by the back-end.
224  *  - Calls a function on each child (domain) to recursively add supported actions.
225  *
226  * @param ocs Pointer to the ocs structure.
227  * @param textbuf Pointer to an ocs_textbuf, which is used to accumulate the results.
228  *
229  * @return Returns 0 on success, or a negative value on failure.
230  */
231 
232 void
233 ocs_mgmt_get_list(ocs_t *ocs, ocs_textbuf_t *textbuf)
234 {
235 	ocs_domain_t *domain;
236 	uint32_t i;
237 	int access;
238 
239 	ocs_mgmt_start_unnumbered_section(textbuf, "ocs");
240 
241 	for (i=0;i<ARRAY_SIZE(mgmt_table);i++) {
242 		access = 0;
243 		if (mgmt_table[i].get_handler) {
244 			access |= MGMT_MODE_RD;
245 		}
246 		if (mgmt_table[i].set_handler) {
247 			access |= MGMT_MODE_WR;
248 		}
249 		if (mgmt_table[i].action_handler) {
250 			access |= MGMT_MODE_EX;
251 		}
252 		ocs_mgmt_emit_property_name(textbuf, access, mgmt_table[i].name);
253 	}
254 
255 	if ((ocs->mgmt_functions) && (ocs->mgmt_functions->get_list_handler)) {
256 		ocs->mgmt_functions->get_list_handler(textbuf, ocs);
257 	}
258 
259 	if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->get_list_handler)) {
260 		ocs->tgt_mgmt_functions->get_list_handler(textbuf, &(ocs->tgt_ocs));
261 	}
262 
263 	/* Have each of my children add their actions */
264 	if (ocs_device_lock_try(ocs) == TRUE) {
265 		/* If we get here then we are holding the device lock */
266 		ocs_list_foreach(&ocs->domain_list, domain) {
267 			if ((domain->mgmt_functions) && (domain->mgmt_functions->get_list_handler)) {
268 				domain->mgmt_functions->get_list_handler(textbuf, domain);
269 			}
270 		}
271 		ocs_device_unlock(ocs);
272 	}
273 
274 	ocs_mgmt_end_unnumbered_section(textbuf, "ocs");
275 
276 }
277 
278 /**
279  * @ingroup mgmt
280  * @brief Return the value of a management item.
281  *
282  * @par Description
283  * This is the top level "get" handler for the driver. It
284  * performs the following:
285  *  - Checks that the qualifier portion of the name begins with my qualifier (ocs).
286  *  - If the remaining part of the name matches a parameter that is known at this level,
287  *    writes the value into textbuf.
288  *  - If the name is not known, sends the request to the back-ends to fulfill (if possible).
289  *  - If the request has not been fulfilled by the back-end,
290  *    passes the request to each of the children (domains) to
291  *    have them (recursively) try to respond.
292  *
293  *  In passing the request to other entities, the request is considered to be answered
294  *  when a response has been written into textbuf, indicated by textbuf->buffer_written
295  *  being non-zero.
296  *
297  * @param ocs Pointer to the ocs structure.
298  * @param name Name of the status item to be retrieved.
299  * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
300  *
301  * @return Returns 0 if the value was found and returned, or -1 if an error occurred.
302  */
303 
304 int
305 ocs_mgmt_get(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
306 {
307 	ocs_domain_t *domain;
308 	char qualifier[6];
309 	int retval = -1;
310 	uint32_t i;
311 
312 	ocs_mgmt_start_unnumbered_section(textbuf, "ocs");
313 
314 	snprintf(qualifier, sizeof(qualifier), "/ocs");
315 
316 	/* See if the name starts with my qualifier.  If not then this request isn't for me */
317 	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
318 		char *unqualified_name = name + strlen(qualifier) + 1;
319 
320 		for (i=0;i<ARRAY_SIZE(mgmt_table);i++) {
321 			if (ocs_strcmp(unqualified_name, mgmt_table[i].name) == 0) {
322 				if (mgmt_table[i].get_handler) {
323 					mgmt_table[i].get_handler(ocs, name, textbuf);
324 					ocs_mgmt_end_unnumbered_section(textbuf, "ocs");
325 					return 0;
326 				}
327 			}
328 		}
329 
330 		if ((ocs->mgmt_functions) && (ocs->mgmt_functions->get_handler)) {
331 			retval = ocs->mgmt_functions->get_handler(textbuf, qualifier, (char*)name, ocs);
332 		}
333 
334 		if (retval != 0) {
335 			if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->get_handler)) {
336 				retval = ocs->tgt_mgmt_functions->get_handler(textbuf, qualifier,
337 						(char*)name, &(ocs->tgt_ocs));
338 			}
339 		}
340 
341 		if (retval != 0) {
342 			/* The driver didn't handle it, pass it to each domain */
343 
344 			ocs_device_lock(ocs);
345 			ocs_list_foreach(&ocs->domain_list, domain) {
346 				if ((domain->mgmt_functions) && (domain->mgmt_functions->get_handler)) {
347 					retval = domain->mgmt_functions->get_handler(textbuf, qualifier, (char*)name, domain);
348 				}
349 
350 				if (retval ==  0) {
351 					break;
352 				}
353 			}
354 			ocs_device_unlock(ocs);
355 		}
356 	}
357 
358 	ocs_mgmt_end_unnumbered_section(textbuf, "ocs");
359 
360 	return retval;
361 }
362 
363 /**
364  * @ingroup mgmt
365  * @brief Set the value of a mgmt item.
366  *
367  * @par Description
368  * This is the top level "set" handler for the driver. It
369  * performs the following:
370  *  - Checks that the qualifier portion of the name begins with my qualifier (ocs).
371  *  - If the remaining part of the name matches a parameter that is known at this level,
372  *    calls the correct function to change the configuration.
373  *  - If the name is not known, sends the request to the back-ends to fulfill (if possible).
374  *  - If the request has not been fulfilled by the back-end, passes the request to each of the
375  *    children (domains) to have them (recursively) try to respond.
376  *
377  *  In passing the request to other entities, the request is considered to be handled
378  *  if the function returns 0.
379  *
380  * @param ocs Pointer to the ocs structure.
381  * @param name Name of the property to be changed.
382  * @param value Requested new value of the property.
383  *
384  * @return Returns 0 if the configuration value was updated, or -1 otherwise.
385  */
386 
387 int
388 ocs_mgmt_set(ocs_t *ocs, char *name, char *value)
389 {
390 	ocs_domain_t *domain;
391 	int result = -1;
392 	char qualifier[80];
393 	uint32_t i;
394 
395 	snprintf(qualifier, sizeof(qualifier), "/ocs");
396 
397 	/* If it doesn't start with my qualifier I don't know what to do with it */
398 	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
399 		char *unqualified_name = name + strlen(qualifier) +1;
400 
401 		/* See if it's a value I can set */
402 		for (i=0;i<ARRAY_SIZE(mgmt_table);i++) {
403 			if (ocs_strcmp(unqualified_name, mgmt_table[i].name) == 0) {
404 				if (mgmt_table[i].set_handler) {
405 					return mgmt_table[i].set_handler(ocs, name, value);
406 				}
407 			}
408 		}
409 
410 		if ((ocs->mgmt_functions) && (ocs->mgmt_functions->set_handler)) {
411 			result = ocs->mgmt_functions->set_handler(qualifier, name, (char *)value, ocs);
412 		}
413 
414 		if (result != 0) {
415 			if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->set_handler)) {
416 				result = ocs->tgt_mgmt_functions->set_handler(qualifier, name,
417 						(char *)value, &(ocs->tgt_ocs));
418 			}
419 		}
420 
421 		/* If I didn't know how to set this config value pass the request to each of my children */
422 		if (result != 0) {
423 			ocs_device_lock(ocs);
424 			ocs_list_foreach(&ocs->domain_list, domain) {
425 				if ((domain->mgmt_functions) && (domain->mgmt_functions->set_handler)) {
426 					result = domain->mgmt_functions->set_handler(qualifier, name, (char*)value, domain);
427 				}
428 				if (result == 0) {
429 					break;
430 				}
431 			}
432 			ocs_device_unlock(ocs);
433 		}
434 	}
435 
436 	return result;
437 }
438 
439 /**
440  * @ingroup mgmt
441  * @brief Perform a management action.
442  *
443  * @par Description
444  * This is the top level "exec" handler for the driver. It
445  * performs the following:
446  *  - Checks that the qualifier portion of the name begins with my qualifier (ocs).
447  *  - If the remaining part of the name matches an action that is known at this level,
448  *    calls the correct function to perform the action.
449  *  - If the name is not known, sends the request to the back-ends to fulfill (if possible).
450  *  - If the request has not been fulfilled by the back-end, passes the request to each of the
451  *    children (domains) to have them (recursively) try to respond.
452  *
453  *  In passing the request to other entities, the request is considered to be handled
454  *  if the function returns 0.
455  *
456  * @param ocs Pointer to the ocs structure.
457  * @param action Name of the action to be performed.
458  * @param arg_in Pointer to an argument being passed to the action.
459  * @param arg_in_length Length of the argument pointed to by @c arg_in.
460  * @param arg_out Pointer to an argument being passed to the action.
461  * @param arg_out_length Length of the argument pointed to by @c arg_out.
462  *
463  * @return Returns 0 if the action was completed, or -1 otherwise.
464  *
465  *
466  */
467 
468 int
469 ocs_mgmt_exec(ocs_t *ocs, char *action, void *arg_in,
470 		uint32_t arg_in_length, void *arg_out, uint32_t arg_out_length)
471 {
472 	ocs_domain_t *domain;
473 	int result = -1;
474 	char qualifier[80];
475 	uint32_t i;
476 
477 	snprintf(qualifier, sizeof(qualifier), "/ocs");
478 
479 	/* If it doesn't start with my qualifier I don't know what to do with it */
480 	if (ocs_strncmp(action, qualifier, strlen(qualifier)) == 0) {
481 		char *unqualified_name = action + strlen(qualifier) +1;
482 
483 		/* See if it's an action I can perform */
484 		for (i=0;i<ARRAY_SIZE(mgmt_table); i++) {
485 			if (ocs_strcmp(unqualified_name, mgmt_table[i].name) == 0) {
486 				if (mgmt_table[i].action_handler) {
487 					return mgmt_table[i].action_handler(ocs, action, arg_in, arg_in_length,
488 							arg_out, arg_out_length);
489 				}
490 			}
491 		}
492 
493 		if ((ocs->mgmt_functions) && (ocs->mgmt_functions->exec_handler)) {
494 			result = ocs->mgmt_functions->exec_handler(qualifier, action, arg_in, arg_in_length,
495 								   arg_out, arg_out_length, ocs);
496 		}
497 
498 		if (result != 0) {
499 			if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->exec_handler)) {
500 				result = ocs->tgt_mgmt_functions->exec_handler(qualifier, action,
501 						arg_in, arg_in_length, arg_out, arg_out_length,
502 						&(ocs->tgt_ocs));
503 			}
504 		}
505 
506 		/* If I didn't know how to do this action pass the request to each of my children */
507 		if (result != 0) {
508 			ocs_device_lock(ocs);
509 			ocs_list_foreach(&ocs->domain_list, domain) {
510 				if ((domain->mgmt_functions) && (domain->mgmt_functions->exec_handler)) {
511 					result = domain->mgmt_functions->exec_handler(qualifier, action, arg_in, arg_in_length, arg_out,
512 							arg_out_length, domain);
513 				}
514 				if (result == 0) {
515 					break;
516 				}
517 			}
518 			ocs_device_unlock(ocs);
519 		}
520 	}
521 
522 	return result;
523 }
524 
525 void
526 ocs_mgmt_get_all(ocs_t *ocs, ocs_textbuf_t *textbuf)
527 {
528 	ocs_domain_t *domain;
529 	uint32_t i;
530 
531 	ocs_mgmt_start_unnumbered_section(textbuf, "ocs");
532 
533 	for (i=0;i<ARRAY_SIZE(mgmt_table);i++) {
534 		if (mgmt_table[i].get_handler) {
535 			mgmt_table[i].get_handler(ocs, mgmt_table[i].name, textbuf);
536 		} else if (mgmt_table[i].action_handler) {
537 			/* No get_handler, but there's an action_handler. Just report
538 			   the name */
539 			ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, mgmt_table[i].name);
540 		}
541 	}
542 
543 	if ((ocs->mgmt_functions) && (ocs->mgmt_functions->get_all_handler)) {
544 		ocs->mgmt_functions->get_all_handler(textbuf, ocs);
545 	}
546 
547 	if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->get_all_handler)) {
548 		ocs->tgt_mgmt_functions->get_all_handler(textbuf, &(ocs->tgt_ocs));
549 	}
550 
551 	ocs_device_lock(ocs);
552 	ocs_list_foreach(&ocs->domain_list, domain) {
553 		if ((domain->mgmt_functions) && (domain->mgmt_functions->get_all_handler)) {
554 			domain->mgmt_functions->get_all_handler(textbuf, domain);
555 		}
556 	}
557 	ocs_device_unlock(ocs);
558 
559 	ocs_mgmt_end_unnumbered_section(textbuf, "ocs");
560 }
561 
562 #if defined(OCS_INCLUDE_RAMD)
563 static int32_t
564 ocs_mgmt_read_phys(ocs_t *ocs, char *name, void *arg_in, uint32_t arg_in_length, void *arg_out, uint32_t arg_out_length)
565 {
566         uint32_t length;
567         char addr_str[80];
568         uintptr_t target_addr;
569         void* vaddr = NULL;
570         ocs_ramdisc_t **ramdisc_array;
571         uint32_t ramdisc_count;
572 
573         if ((arg_in == NULL) ||
574             (arg_in_length == 0) ||
575             (arg_out == NULL) ||
576             (arg_out_length == 0)) {
577                 return -1;
578         }
579 
580         if (arg_in_length > 80) {
581                 arg_in_length = 80;
582         }
583 
584         if (ocs_copy_from_user(addr_str, arg_in, arg_in_length)) {
585                 ocs_log_test(ocs, "Failed to copy addr from user\n");
586                 return -EFAULT;
587         }
588 
589         target_addr = (uintptr_t)ocs_strtoul(addr_str, NULL, 0);
590         /* addr_str must be the physical address of a buffer that was reported
591          * in an SGL.  Search ramdiscs looking for a segment that contains that
592          * physical address
593          */
594 
595         if (ocs->tgt_ocs.use_global_ramd) {
596                 /* Only one target */
597                 ramdisc_count = ocs->tgt_ocs.rdisc_count;
598                 ramdisc_array = ocs->tgt_ocs.rdisc;
599                 vaddr = find_address_in_target(ramdisc_array, ramdisc_count, target_addr);
600         } else {
601                 /* Multiple targets.  Each target is on a sport */
602 		uint32_t domain_idx;
603 
604 		for (domain_idx=0; domain_idx<ocs->domain_instance_count; domain_idx++) {
605 			ocs_domain_t *domain;
606 			uint32_t sport_idx;
607 
608 			domain = ocs_domain_get_instance(ocs, domain_idx);
609 			for (sport_idx=0; sport_idx < domain->sport_instance_count; sport_idx++) {
610 				ocs_sport_t *sport;
611 
612 				sport = ocs_sport_get_instance(domain, sport_idx);
613 				ramdisc_count = sport->tgt_sport.rdisc_count;
614 				ramdisc_array = sport->tgt_sport.rdisc;
615 				vaddr = find_address_in_target(ramdisc_array, ramdisc_count, target_addr);
616 
617 				if (vaddr != NULL) {
618 					break;
619 				}
620 			}
621                 }
622         }
623 
624         length = arg_out_length;
625 
626         if (vaddr != NULL) {
627                 if (ocs_copy_to_user(arg_out, vaddr, length)) {
628                         ocs_log_test(ocs, "Failed to copy buffer to user\n");
629                         return -EFAULT;
630                 }
631 
632                 return 0;
633         } else {
634                 return -EFAULT;
635 	}
636 
637 }
638 
639 /*
640  * This function searches a target for a given physical address.
641  * The target is made up of a number of LUNs, each represented by
642  * a ocs_ramdisc_t.
643  */
644 static void* find_address_in_target(ocs_ramdisc_t **ramdisc_array, uint32_t ramdisc_count, uintptr_t target_addr)
645 {
646 	void *vaddr = NULL;
647 	uint32_t ramdisc_idx;
648 
649 	/* Check each ramdisc */
650 	for (ramdisc_idx=0; ramdisc_idx<ramdisc_count; ramdisc_idx++) {
651 		uint32_t segment_idx;
652 		ocs_ramdisc_t *rdisc;
653 		rdisc = ramdisc_array[ramdisc_idx];
654 		/* Check each segment in the ramdisc */
655 		for (segment_idx=0; segment_idx<rdisc->segment_count; segment_idx++) {
656 			ramdisc_segment_t *segment = rdisc->segments[segment_idx];
657 			uintptr_t segment_start;
658 			uintptr_t segment_end;
659 			uint32_t offset;
660 
661 			segment_start = segment->data_segment.phys;
662 			segment_end = segment->data_segment.phys + segment->data_segment.size - 1;
663 			if ((target_addr >= segment_start) && (target_addr <= segment_end)) {
664 				/* Found the target address */
665 				offset = target_addr - segment_start;
666 				vaddr = (uint32_t*)segment->data_segment.virt + offset;
667 			}
668 
669 			if (rdisc->dif_separate) {
670 				segment_start = segment->dif_segment.phys;
671 				segment_end = segment->data_segment.phys + segment->dif_segment.size - 1;
672 				if ((target_addr >= segment_start) && (target_addr <= segment_end)) {
673 					/* Found the target address */
674 					offset = target_addr - segment_start;
675 					vaddr = (uint32_t*)segment->dif_segment.virt + offset;
676 				}
677 			}
678 
679 			if (vaddr != NULL) {
680 				break;
681 			}
682 		}
683 
684 		if (vaddr != NULL) {
685 			break;
686 		}
687 	}
688 
689 	return vaddr;
690 }
691 #endif
692 
693 static int32_t
694 ocs_mgmt_firmware_reset(ocs_t *ocs, char *name, void *buf, uint32_t buf_len, void *arg_out, uint32_t arg_out_length)
695 {
696 	int rc = 0;
697 	int index = 0;
698 	uint8_t bus, dev, func;
699 	ocs_t *other_ocs;
700 
701 	ocs_get_bus_dev_func(ocs, &bus, &dev, &func);
702 
703 	ocs_log_debug(ocs, "Resetting port\n");
704 	if (ocs_hw_reset(&ocs->hw, OCS_HW_RESET_FIRMWARE)) {
705 		ocs_log_test(ocs, "failed to reset port\n");
706 		rc = -1;
707 	} else {
708 		ocs_log_debug(ocs, "successfully reset port\n");
709 
710 		/* now reset all functions on the same device */
711 
712 		while ((other_ocs = ocs_get_instance(index++)) != NULL) {
713 			uint8_t other_bus, other_dev, other_func;
714 
715 			ocs_get_bus_dev_func(other_ocs, &other_bus, &other_dev, &other_func);
716 
717 			if ((bus == other_bus) && (dev == other_dev)) {
718 				if (other_ocs->hw.state !=
719                                       OCS_HW_STATE_UNINITIALIZED) {
720                                         other_ocs->hw.state =
721                                                 OCS_HW_STATE_QUEUES_ALLOCATED;
722                                 }
723 
724 				ocs_device_detach(other_ocs);
725 				if (ocs_device_attach(other_ocs)) {
726 					ocs_log_err(other_ocs,
727 						"device %d attach failed \n", index);
728 					rc = -1;
729 				}
730 			}
731 		}
732 	}
733 	return rc;
734 }
735 
736 static int32_t
737 ocs_mgmt_function_reset(ocs_t *ocs, char *name, void *buf, uint32_t buf_len, void *arg_out, uint32_t arg_out_length)
738 {
739 	int32_t rc;
740 
741 	ocs_device_detach(ocs);
742 	rc = ocs_device_attach(ocs);
743 
744 	return rc;
745 }
746 
747 static int32_t
748 ocs_mgmt_firmware_write(ocs_t *ocs, char *name, void *buf, uint32_t buf_len, void *arg_out, uint32_t arg_out_length)
749 {
750 	int rc = 0;
751 	uint32_t bytes_left;
752 	uint32_t xfer_size;
753 	uint32_t offset;
754 	uint8_t *userp;
755 	ocs_dma_t dma;
756 	int last = 0;
757 	ocs_mgmt_fw_write_result_t result;
758 	uint32_t change_status = 0;
759         char status_str[80];
760 
761 	ocs_sem_init(&(result.semaphore), 0, "fw_write");
762 
763 	bytes_left = buf_len;
764 	offset = 0;
765 	userp = (uint8_t *)buf;
766 
767 	if (ocs_dma_alloc(ocs, &dma, FW_WRITE_BUFSIZE, 4096)) {
768 		ocs_log_err(ocs, "ocs_mgmt_firmware_write: malloc failed");
769 		return -ENOMEM;
770 	}
771 
772 	while (bytes_left > 0) {
773 		if (bytes_left > FW_WRITE_BUFSIZE) {
774 			xfer_size = FW_WRITE_BUFSIZE;
775 		} else {
776 			xfer_size = bytes_left;
777 		}
778 
779 		/* Copy xfer_size bytes from user space to kernel buffer */
780 		if (ocs_copy_from_user(dma.virt, userp, xfer_size)) {
781 			rc = -EFAULT;
782 			break;
783 		}
784 
785 		/* See if this is the last block */
786 		if (bytes_left == xfer_size) {
787 			last = 1;
788 		}
789 
790 		/* Send the HW command */
791 		ocs_hw_firmware_write(&ocs->hw, &dma, xfer_size, offset, last, ocs_mgmt_fw_write_cb, &result);
792 
793 		/* Wait for semaphore to be signaled when the command completes
794 		 * TODO:  Should there be a timeout on this?  If so, how long? */
795 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
796 			ocs_log_err(ocs, "ocs_sem_p failed\n");
797 			rc = -ENXIO;
798 			break;
799 		}
800 
801 		if (result.actual_xfer == 0) {
802 			ocs_log_test(ocs, "actual_write_length is %d\n", result.actual_xfer);
803 			rc = -EFAULT;
804 			break;
805 		}
806 
807 		/* Check status */
808 		if (result.status != 0) {
809 			ocs_log_test(ocs, "write returned status %d\n", result.status);
810 			rc = -EFAULT;
811 			break;
812 		}
813 
814 		if (last) {
815 			change_status = result.change_status;
816 		}
817 
818 		bytes_left -= result.actual_xfer;
819 		offset += result.actual_xfer;
820 		userp += result.actual_xfer;
821 	}
822 
823 	/* Create string with status and copy to userland */
824 	if ((arg_out_length > 0) && (arg_out != NULL)) {
825 		if (arg_out_length > sizeof(status_str)) {
826 			arg_out_length = sizeof(status_str);
827 		}
828 		ocs_memset(status_str, 0, sizeof(status_str));
829 		ocs_snprintf(status_str, arg_out_length, "%d", change_status);
830 		if (ocs_copy_to_user(arg_out, status_str, arg_out_length)) {
831 			ocs_log_test(ocs, "copy to user failed for change_status\n");
832 		}
833 	}
834 
835 	ocs_dma_free(ocs, &dma);
836 
837 	return rc;
838 }
839 
840 static void
841 ocs_mgmt_fw_write_cb(int32_t status, uint32_t actual_write_length, uint32_t change_status, void *arg)
842 {
843 	ocs_mgmt_fw_write_result_t *result = arg;
844 
845 	result->status = status;
846 	result->actual_xfer = actual_write_length;
847 	result->change_status = change_status;
848 
849 	ocs_sem_v(&(result->semaphore));
850 }
851 
852 typedef struct ocs_mgmt_sfp_result {
853 	ocs_sem_t semaphore;
854 	ocs_lock_t cb_lock;
855 	int32_t running;
856 	int32_t status;
857 	uint32_t bytes_read;
858 	uint32_t page_data[32];
859 } ocs_mgmt_sfp_result_t;
860 
861 static void
862 ocs_mgmt_sfp_cb(void *os, int32_t status, uint32_t bytes_read, uint32_t *data, void *arg)
863 {
864 	ocs_mgmt_sfp_result_t *result = arg;
865 	ocs_t *ocs = os;
866 
867 	ocs_lock(&(result->cb_lock));
868 	result->running++;
869 	if(result->running == 2) {
870 		/* get_sfp() has timed out */
871 		ocs_unlock(&(result->cb_lock));
872 		ocs_free(ocs, result, sizeof(ocs_mgmt_sfp_result_t));
873 		return;
874 	}
875 
876 	result->status = status;
877 	result->bytes_read = bytes_read;
878 	ocs_memcpy(&result->page_data, data, SFP_PAGE_SIZE);
879 
880 	ocs_sem_v(&(result->semaphore));
881 	ocs_unlock(&(result->cb_lock));
882 }
883 
884 static int32_t
885 ocs_mgmt_get_sfp(ocs_t *ocs, uint16_t page, void *buf, uint32_t buf_len)
886 {
887 	int rc = 0;
888 	ocs_mgmt_sfp_result_t *result = ocs_malloc(ocs, sizeof(ocs_mgmt_sfp_result_t),  OCS_M_ZERO | OCS_M_NOWAIT);
889 
890 	ocs_sem_init(&(result->semaphore), 0, "get_sfp");
891 	ocs_lock_init(ocs, &(result->cb_lock), "get_sfp");
892 
893 	/* Send the HW command */
894 	ocs_hw_get_sfp(&ocs->hw, page, ocs_mgmt_sfp_cb, result);
895 
896 	/* Wait for semaphore to be signaled when the command completes */
897 	if (ocs_sem_p(&(result->semaphore), 5 * 1000 * 1000) != 0) {
898 		/* Timed out, callback will free memory */
899 		ocs_lock(&(result->cb_lock));
900 		result->running++;
901 		if(result->running == 1) {
902 			ocs_log_err(ocs, "ocs_sem_p failed\n");
903 			ocs_unlock(&(result->cb_lock));
904 			return (-ENXIO);
905 		}
906 		/* sfp_cb() has already executed, proceed as normal */
907 		ocs_unlock(&(result->cb_lock));
908 	}
909 
910 	/* Check status */
911 	if (result->status != 0) {
912 		ocs_log_test(ocs, "read_transceiver_data returned status %d\n",
913 			     result->status);
914 		rc = -EFAULT;
915 	}
916 
917 	if (rc == 0) {
918 		rc = (result->bytes_read > buf_len ? buf_len : result->bytes_read);
919 		/* Copy the results back to the supplied buffer */
920 		ocs_memcpy(buf, result->page_data, rc);
921 	}
922 
923 	ocs_free(ocs, result, sizeof(ocs_mgmt_sfp_result_t));
924 	return rc;
925 }
926 
927 static int32_t
928 ocs_mgmt_force_assert(ocs_t *ocs, char *name, void *buf, uint32_t buf_len, void *arg_out, uint32_t arg_out_length)
929 {
930 	ocs_assert(FALSE, 0);
931 }
932 
933 static void
934 get_nodes_count(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
935 {
936 	ocs_xport_t *xport = ocs->xport;
937 
938 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "nodes_count", "%d", xport->nodes_count);
939 }
940 
941 static void
942 get_driver_version(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
943 {
944 	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "driver_version", ocs->driver_version);
945 }
946 
947 static void
948 get_desc(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
949 {
950 	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "desc", ocs->desc);
951 }
952 
953 static void
954 get_fw_rev(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
955 {
956 	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "fw_rev", ocs_hw_get_ptr(&ocs->hw, OCS_HW_FW_REV));
957 }
958 
959 static void
960 get_fw_rev2(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
961 {
962 	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "fw_rev2", ocs_hw_get_ptr(&ocs->hw, OCS_HW_FW_REV2));
963 }
964 
965 static void
966 get_ipl(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
967 {
968 	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ipl", ocs_hw_get_ptr(&ocs->hw, OCS_HW_IPL));
969 }
970 
971 static void
972 get_hw_rev1(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
973 {
974 	uint32_t value;
975 
976 	ocs_hw_get(&ocs->hw, OCS_HW_HW_REV1, &value);
977 
978 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_rev1", "%u", value);
979 }
980 
981 static void
982 get_hw_rev2(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
983 {
984 	uint32_t value;
985 
986 	ocs_hw_get(&ocs->hw, OCS_HW_HW_REV2, &value);
987 
988 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_rev2", "%u", value);
989 }
990 
991 static void
992 get_hw_rev3(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
993 {
994 	uint32_t value;
995 	ocs_hw_get(&ocs->hw, OCS_HW_HW_REV3, &value);
996 
997 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_rev3", "%u", value);
998 }
999 
1000 static void
1001 get_wwnn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1002 {
1003 	uint64_t *wwnn;
1004 
1005 	wwnn = ocs_hw_get_ptr(&ocs->hw, OCS_HW_WWN_NODE);
1006 
1007 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwnn", "0x%llx", (unsigned long long)ocs_htobe64(*wwnn));
1008 }
1009 
1010 static void
1011 get_wwpn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1012 {
1013 	uint64_t *wwpn;
1014 
1015 	wwpn = ocs_hw_get_ptr(&ocs->hw, OCS_HW_WWN_PORT);
1016 
1017 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwpn", "0x%llx", (unsigned long long)ocs_htobe64(*wwpn));
1018 }
1019 
1020 static void
1021 get_fcid(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1022 {
1023 
1024 	if (ocs->domain && ocs->domain->attached) {
1025 		ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fc_id", "0x%06x",
1026 						ocs->domain->sport->fc_id);
1027 	} else {
1028 		ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fc_id", "UNKNOWN");
1029 	}
1030 
1031 }
1032 
1033 static void
1034 get_sn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1035 {
1036 	uint8_t *pserial;
1037 	uint32_t len;
1038 	char sn_buf[256];
1039 
1040 	pserial = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_SERIALNUMBER);
1041 	if (pserial) {
1042 		len = *pserial ++;
1043 		strncpy(sn_buf, (char*)pserial, len);
1044 		sn_buf[len] = '\0';
1045 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sn", sn_buf);
1046 	}
1047 }
1048 
1049 static void
1050 get_pn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1051 {
1052 	uint8_t *pserial;
1053 	uint32_t len;
1054 	char sn_buf[256];
1055 
1056 	pserial = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_PARTNUMBER);
1057 	if (pserial) {
1058 		len = *pserial ++;
1059 		strncpy(sn_buf, (char*)pserial, len);
1060 		sn_buf[len] = '\0';
1061 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "pn", sn_buf);
1062 	} else {
1063 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "pn", ocs->model);
1064 	}
1065 }
1066 
1067 static void
1068 get_sli4_intf_reg(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1069 {
1070 
1071 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "sli4_intf_reg", "0x%04x",
1072 		ocs_config_read32(ocs, SLI4_INTF_REG));
1073 }
1074 
1075 static void
1076 get_phy_port_num(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1077 {
1078 	char *phy_port = NULL;
1079 
1080 	phy_port = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_PORTNUM);
1081 	if (phy_port) {
1082 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "phy_port_num", phy_port);
1083 	} else {
1084 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "phy_port_num", "unknown");
1085 	}
1086 }
1087 static void
1088 get_asic_id(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1089 {
1090 
1091 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "asic_id_reg", "0x%04x",
1092 		ocs_config_read32(ocs, SLI4_ASIC_ID_REG));
1093 }
1094 
1095 static void
1096 get_chip_type(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1097 {
1098 	uint32_t family;
1099 	uint32_t asic_id;
1100 	uint32_t asic_gen_num;
1101 	uint32_t asic_rev_num;
1102 	uint32_t rev_id;
1103 	char result_buf[80];
1104 	char tmp_buf[80];
1105 
1106 	family = (ocs_config_read32(ocs, SLI4_INTF_REG) & 0x00000f00) >> 8;
1107 	asic_id = ocs_config_read32(ocs, SLI4_ASIC_ID_REG);
1108 	asic_rev_num = asic_id & 0xff;
1109 	asic_gen_num = (asic_id & 0xff00) >> 8;
1110 
1111 	rev_id = ocs_config_read32(ocs, SLI4_PCI_CLASS_REVISION) & 0xff;
1112 
1113 	switch(family) {
1114 	case 0x00:
1115 		/* BE2 */
1116 		ocs_strncpy(result_buf,  "BE2 A", sizeof(result_buf));
1117 		ocs_snprintf(tmp_buf, 2, "%d", rev_id);
1118 		strcat(result_buf, tmp_buf);
1119 		break;
1120 	case 0x01:
1121 		/* BE3 */
1122 		ocs_strncpy(result_buf, "BE3", sizeof(result_buf));
1123 		if (rev_id >= 0x10) {
1124 			strcat(result_buf, "-R");
1125 		}
1126 		ocs_snprintf(tmp_buf, 3, " %c", ((rev_id & 0xf0) >> 4) + 'A');
1127 		strcat(result_buf, tmp_buf);
1128 		ocs_snprintf(tmp_buf, 2, "%d", rev_id & 0x0f);
1129 		strcat(result_buf, tmp_buf);
1130 		break;
1131 	case 0x02:
1132 		/* Skyhawk A0 */
1133 		ocs_strncpy(result_buf, "Skyhawk A0", sizeof(result_buf));
1134 		break;
1135 	case 0x0a:
1136 		/* Lancer A0 */
1137 		ocs_strncpy(result_buf, "Lancer A", sizeof(result_buf));
1138 		ocs_snprintf(tmp_buf, 2, "%d", rev_id & 0x0f);
1139 		strcat(result_buf, tmp_buf);
1140 		break;
1141 	case 0x0b:
1142 		/* Lancer B0 or D0 */
1143 		ocs_strncpy(result_buf, "Lancer", sizeof(result_buf));
1144 		ocs_snprintf(tmp_buf, 3, " %c", ((rev_id & 0xf0) >> 4) + 'A');
1145 		strcat(result_buf, tmp_buf);
1146 		ocs_snprintf(tmp_buf, 2, "%d", rev_id & 0x0f);
1147 		strcat(result_buf, tmp_buf);
1148 		break;
1149 	case 0x0c:
1150 		ocs_strncpy(result_buf, "Lancer G6", sizeof(result_buf));
1151 		break;
1152 	case 0x0f:
1153 		/* Refer to ASIC_ID */
1154 		switch(asic_gen_num) {
1155 		case 0x00:
1156 			ocs_strncpy(result_buf, "BE2", sizeof(result_buf));
1157 			break;
1158 		case 0x03:
1159 			ocs_strncpy(result_buf, "BE3-R", sizeof(result_buf));
1160 			break;
1161 		case 0x04:
1162 			ocs_strncpy(result_buf, "Skyhawk-R", sizeof(result_buf));
1163 			break;
1164 		case 0x05:
1165 			ocs_strncpy(result_buf, "Corsair", sizeof(result_buf));
1166 			break;
1167 		case 0x0b:
1168 			ocs_strncpy(result_buf, "Lancer", sizeof(result_buf));
1169 			break;
1170 		case 0x0c:
1171 			ocs_strncpy(result_buf, "LancerG6", sizeof(result_buf));
1172 			break;
1173 		default:
1174 			ocs_strncpy(result_buf, "Unknown", sizeof(result_buf));
1175 		}
1176 		if (ocs_strcmp(result_buf, "Unknown") != 0) {
1177 			ocs_snprintf(tmp_buf, 3, " %c", ((asic_rev_num & 0xf0) >> 4) + 'A');
1178 			strcat(result_buf, tmp_buf);
1179 			ocs_snprintf(tmp_buf, 2, "%d", asic_rev_num & 0x0f);
1180 			strcat(result_buf, tmp_buf);
1181 		}
1182 		break;
1183 	default:
1184 		ocs_strncpy(result_buf, "Unknown", sizeof(result_buf));
1185 	}
1186 
1187 	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "chip_type", result_buf);
1188 
1189 }
1190 
1191 static void
1192 get_pci_vendor(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1193 {
1194 
1195 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "pci_vendor", "0x%04x", ocs->pci_vendor);
1196 }
1197 
1198 static void
1199 get_pci_device(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1200 {
1201 
1202 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "pci_device", "0x%04x", ocs->pci_device);
1203 }
1204 
1205 static void
1206 get_pci_subsystem_vendor(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1207 {
1208 
1209 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "pci_subsystem_vendor", "0x%04x", ocs->pci_subsystem_vendor);
1210 }
1211 
1212 static void
1213 get_pci_subsystem_device(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1214 {
1215 
1216 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "pci_subsystem_device", "0x%04x", ocs->pci_subsystem_device);
1217 }
1218 
1219 static void
1220 get_tgt_rscn_delay(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1221 {
1222 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "tgt_rscn_delay", "%ld", (unsigned long)ocs->tgt_rscn_delay_msec / 1000);
1223 }
1224 
1225 static void
1226 get_tgt_rscn_period(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1227 {
1228 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "tgt_rscn_period", "%ld", (unsigned long)ocs->tgt_rscn_period_msec / 1000);
1229 }
1230 
1231 static void
1232 get_inject_drop_cmd(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1233 {
1234 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "inject_drop_cmd", "%d",
1235 			(ocs->err_injection == INJECT_DROP_CMD ? 1:0));
1236 }
1237 
1238 static void
1239 get_inject_free_drop_cmd(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1240 {
1241 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "inject_free_drop_cmd", "%d",
1242 			(ocs->err_injection == INJECT_FREE_DROPPED ? 1:0));
1243 }
1244 
1245 static void
1246 get_inject_drop_data(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1247 {
1248 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "inject_drop_data", "%d",
1249 			(ocs->err_injection == INJECT_DROP_DATA ? 1:0));
1250 }
1251 
1252 static void
1253 get_inject_drop_resp(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1254 {
1255 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "inject_drop_resp", "%d",
1256 			(ocs->err_injection == INJECT_DROP_RESP ? 1:0));
1257 }
1258 
1259 static void
1260 get_cmd_err_inject(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1261 {
1262 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "cmd_err_inject", "0x%02x", ocs->cmd_err_inject);
1263 }
1264 
1265 static void
1266 get_cmd_delay_value(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1267 {
1268 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "cmd_delay_value", "%ld", (unsigned long)ocs->delay_value_msec);
1269 }
1270 
1271 static void
1272 get_businfo(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1273 {
1274 	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "businfo", ocs->businfo);
1275 }
1276 
1277 static void
1278 get_sfp_a0(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1279 {
1280 	uint8_t *page_data;
1281 	char *buf;
1282 	int i;
1283 	int32_t bytes_read;
1284 
1285 	page_data = ocs_malloc(ocs, SFP_PAGE_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
1286 	if (page_data == NULL) {
1287 		return;
1288 	}
1289 
1290 	buf = ocs_malloc(ocs, (SFP_PAGE_SIZE * 3) + 1, OCS_M_ZERO | OCS_M_NOWAIT);
1291 	if (buf == NULL) {
1292 		ocs_free(ocs, page_data, SFP_PAGE_SIZE);
1293 		return;
1294 	}
1295 
1296 	bytes_read = ocs_mgmt_get_sfp(ocs, 0xa0, page_data, SFP_PAGE_SIZE);
1297 
1298 	if (bytes_read <= 0) {
1299 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sfp_a0", "(unknown)");
1300 	} else {
1301 		char *d = buf;
1302 		uint8_t *s = page_data;
1303 		int buffer_remaining = (SFP_PAGE_SIZE * 3) + 1;
1304 		int bytes_added;
1305 
1306 		for (i = 0; i < bytes_read; i++) {
1307 			bytes_added = ocs_snprintf(d, buffer_remaining, "%02x ", *s);
1308 			++s;
1309 			d += bytes_added;
1310 			buffer_remaining -= bytes_added;
1311 		}
1312 		*d = '\0';
1313 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sfp_a0", buf);
1314 	}
1315 
1316 	ocs_free(ocs, page_data, SFP_PAGE_SIZE);
1317 	ocs_free(ocs, buf, (3 * SFP_PAGE_SIZE) + 1);
1318 }
1319 
1320 static void
1321 get_sfp_a2(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1322 {
1323 	uint8_t *page_data;
1324 	char *buf;
1325 	int i;
1326 	int32_t bytes_read;
1327 
1328 	page_data = ocs_malloc(ocs, SFP_PAGE_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
1329 	if (page_data == NULL) {
1330 		return;
1331 	}
1332 
1333 	buf = ocs_malloc(ocs, (SFP_PAGE_SIZE * 3) + 1, OCS_M_ZERO | OCS_M_NOWAIT);
1334 	if (buf == NULL) {
1335 		ocs_free(ocs, page_data, SFP_PAGE_SIZE);
1336 		return;
1337 	}
1338 
1339 	bytes_read = ocs_mgmt_get_sfp(ocs, 0xa2, page_data, SFP_PAGE_SIZE);
1340 
1341 	if (bytes_read <= 0) {
1342 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sfp_a2", "(unknown)");
1343 	} else {
1344 		char *d = buf;
1345 		uint8_t *s = page_data;
1346 		int buffer_remaining = (SFP_PAGE_SIZE * 3) + 1;
1347 		int bytes_added;
1348 
1349 		for (i=0; i < bytes_read; i++) {
1350 			bytes_added = ocs_snprintf(d, buffer_remaining, "%02x ", *s);
1351 			++s;
1352 			d += bytes_added;
1353 			buffer_remaining -= bytes_added;
1354 		}
1355 		*d = '\0';
1356 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sfp_a2", buf);
1357 	}
1358 
1359 	ocs_free(ocs, page_data, SFP_PAGE_SIZE);
1360 	ocs_free(ocs, buf, (3 * SFP_PAGE_SIZE) + 1);
1361 }
1362 
1363 static void
1364 get_debug_mq_dump(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1365 {
1366 
1367 	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RW, "debug_mq_dump",
1368 		ocs_debug_is_enabled(OCS_DEBUG_ENABLE_MQ_DUMP));
1369 }
1370 
1371 static void
1372 get_debug_cq_dump(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1373 {
1374 
1375 	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RW, "debug_cq_dump",
1376 		ocs_debug_is_enabled(OCS_DEBUG_ENABLE_CQ_DUMP));
1377 }
1378 
1379 static void
1380 get_debug_wq_dump(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1381 {
1382 	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RW, "debug_wq_dump",
1383 		ocs_debug_is_enabled(OCS_DEBUG_ENABLE_WQ_DUMP));
1384 }
1385 
1386 static void
1387 get_debug_eq_dump(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1388 {
1389 	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RW, "debug_eq_dump",
1390 		ocs_debug_is_enabled(OCS_DEBUG_ENABLE_EQ_DUMP));
1391 }
1392 
1393 static void
1394 get_logmask(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1395 {
1396 
1397 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "logmask", "0x%02x", ocs->logmask);
1398 
1399 }
1400 
1401 static void
1402 get_loglevel(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1403 {
1404 
1405 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "loglevel", "%d", loglevel);
1406 
1407 }
1408 
1409 static void
1410 get_current_speed(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1411 {
1412 	uint32_t value;
1413 
1414 	ocs_hw_get(&(ocs->hw), OCS_HW_LINK_SPEED, &value);
1415 
1416 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "current_speed", "%d", value);
1417 }
1418 
1419 static void
1420 get_configured_speed(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1421 {
1422 	uint32_t value;
1423 
1424 	ocs_hw_get(&(ocs->hw), OCS_HW_LINK_CONFIG_SPEED, &value);
1425 	if (value == 0) {
1426 		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "configured_speed", "auto");
1427 	} else {
1428 		ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "configured_speed", "%d", value);
1429 	}
1430 
1431 }
1432 
1433 static void
1434 get_current_topology(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1435 {
1436 	uint32_t value;
1437 
1438 	ocs_hw_get(&(ocs->hw), OCS_HW_TOPOLOGY, &value);
1439 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "current_topology", "%d", value);
1440 
1441 }
1442 
1443 static void
1444 get_configured_topology(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1445 {
1446 	uint32_t value;
1447 
1448 	ocs_hw_get(&(ocs->hw), OCS_HW_CONFIG_TOPOLOGY, &value);
1449 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "configured_topology", "%d", value);
1450 
1451 }
1452 
1453 static void
1454 get_current_link_state(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1455 {
1456 	ocs_xport_stats_t value;
1457 
1458 	if (ocs_xport_status(ocs->xport, OCS_XPORT_PORT_STATUS, &value) == 0) {
1459 		if (value.value == OCS_XPORT_PORT_ONLINE) {
1460 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "current_link_state", "online");
1461 		} else {
1462 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "current_link_state", "offline");
1463 		}
1464 	}
1465 }
1466 
1467 static void
1468 get_configured_link_state(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1469 {
1470 	ocs_xport_stats_t value;
1471 
1472 	if (ocs_xport_status(ocs->xport, OCS_XPORT_CONFIG_PORT_STATUS, &value) == 0) {
1473 		if (value.value == OCS_XPORT_PORT_ONLINE) {
1474 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "configured_link_state", "online");
1475 		} else {
1476 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "configured_link_state", "offline");
1477 		}
1478 	}
1479 }
1480 
1481 /**
1482  * @brief HW link config enum to mgmt string value mapping.
1483  *
1484  * This structure provides a mapping from the ocs_hw_linkcfg_e
1485  * enum (enum exposed for the OCS_HW_PORT_SET_LINK_CONFIG port
1486  * control) to the mgmt string that is passed in by the mgmt application
1487  * (elxsdkutil).
1488  */
1489 typedef struct ocs_mgmt_linkcfg_map_s {
1490 	ocs_hw_linkcfg_e linkcfg;
1491 	const char *mgmt_str;
1492 } ocs_mgmt_linkcfg_map_t;
1493 
1494 static ocs_mgmt_linkcfg_map_t mgmt_linkcfg_map[] = {
1495 	{OCS_HW_LINKCFG_4X10G, OCS_CONFIG_LINKCFG_4X10G},
1496 	{OCS_HW_LINKCFG_1X40G, OCS_CONFIG_LINKCFG_1X40G},
1497 	{OCS_HW_LINKCFG_2X16G, OCS_CONFIG_LINKCFG_2X16G},
1498 	{OCS_HW_LINKCFG_4X8G, OCS_CONFIG_LINKCFG_4X8G},
1499 	{OCS_HW_LINKCFG_4X1G, OCS_CONFIG_LINKCFG_4X1G},
1500 	{OCS_HW_LINKCFG_2X10G, OCS_CONFIG_LINKCFG_2X10G},
1501 	{OCS_HW_LINKCFG_2X10G_2X8G, OCS_CONFIG_LINKCFG_2X10G_2X8G}};
1502 
1503 /**
1504  * @brief Get the HW linkcfg enum from the mgmt config string.
1505  *
1506  * @param mgmt_str mgmt string value.
1507  *
1508  * @return Returns the HW linkcfg enum corresponding to clp_str.
1509  */
1510 static ocs_hw_linkcfg_e
1511 ocs_hw_linkcfg_from_mgmt(const char *mgmt_str)
1512 {
1513 	uint32_t i;
1514 	for (i = 0; i < ARRAY_SIZE(mgmt_linkcfg_map); i++) {
1515 		if (ocs_strncmp(mgmt_linkcfg_map[i].mgmt_str,
1516 				mgmt_str, ocs_strlen(mgmt_str)) == 0) {
1517 			return mgmt_linkcfg_map[i].linkcfg;
1518 		}
1519 	}
1520 	return OCS_HW_LINKCFG_NA;
1521 }
1522 
1523 /**
1524  * @brief Get the mgmt string value from the HW linkcfg enum.
1525  *
1526  * @param linkcfg HW linkcfg enum.
1527  *
1528  * @return Returns the mgmt string value corresponding to the given HW linkcfg.
1529  */
1530 static const char *
1531 ocs_mgmt_from_hw_linkcfg(ocs_hw_linkcfg_e linkcfg)
1532 {
1533 	uint32_t i;
1534 	for (i = 0; i < ARRAY_SIZE(mgmt_linkcfg_map); i++) {
1535 		if (mgmt_linkcfg_map[i].linkcfg == linkcfg) {
1536 			return mgmt_linkcfg_map[i].mgmt_str;
1537 		}
1538 	}
1539 	return OCS_CONFIG_LINKCFG_UNKNOWN;
1540 }
1541 
1542 /**
1543  * @brief Link configuration callback argument
1544  */
1545 typedef struct ocs_mgmt_linkcfg_arg_s {
1546 	ocs_sem_t semaphore;
1547 	int32_t status;
1548 	ocs_hw_linkcfg_e linkcfg;
1549 } ocs_mgmt_linkcfg_arg_t;
1550 
1551 /**
1552  * @brief Get linkcfg config value
1553  *
1554  * @param ocs Pointer to the ocs structure.
1555  * @param name Not used.
1556  * @param textbuf The textbuf to which the result is written.
1557  *
1558  * @return None.
1559  */
1560 static void
1561 get_linkcfg(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1562 {
1563 	const char *linkcfg_str = NULL;
1564 	uint32_t value;
1565 	ocs_hw_linkcfg_e linkcfg;
1566 	ocs_hw_get(&ocs->hw, OCS_HW_LINKCFG, &value);
1567 	linkcfg = (ocs_hw_linkcfg_e)value;
1568 	linkcfg_str = ocs_mgmt_from_hw_linkcfg(linkcfg);
1569 	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "linkcfg", linkcfg_str);
1570 }
1571 
1572 /**
1573  * @brief Get requested WWNN config value
1574  *
1575  * @param ocs Pointer to the ocs structure.
1576  * @param name Not used.
1577  * @param textbuf The textbuf to which the result is written.
1578  *
1579  * @return None.
1580  */
1581 static void
1582 get_req_wwnn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1583 {
1584 	ocs_xport_t *xport = ocs->xport;
1585 
1586 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "requested_wwnn", "0x%llx", (unsigned long long)xport->req_wwnn);
1587 }
1588 
1589 /**
1590  * @brief Get requested WWPN config value
1591  *
1592  * @param ocs Pointer to the ocs structure.
1593  * @param name Not used.
1594  * @param textbuf The textbuf to which the result is written.
1595  *
1596  * @return None.
1597  */
1598 static void
1599 get_req_wwpn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1600 {
1601 	ocs_xport_t *xport = ocs->xport;
1602 
1603 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "requested_wwpn", "0x%llx", (unsigned long long)xport->req_wwpn);
1604 }
1605 
1606 /**
1607  * @brief Get requested nodedb_mask config value
1608  *
1609  * @param ocs Pointer to the ocs structure.
1610  * @param name Not used.
1611  * @param textbuf The textbuf to which the result is written.
1612  *
1613  * @return None.
1614  */
1615 static void
1616 get_nodedb_mask(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
1617 {
1618 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "nodedb_mask", "0x%08x", ocs->nodedb_mask);
1619 }
1620 
1621 /**
1622  * @brief Set requested WWNN value.
1623  *
1624  * @param ocs Pointer to the ocs structure.
1625  * @param name Not used.
1626  * @param value Value to which the linkcfg is set.
1627  *
1628  * @return Returns 0 on success.
1629  */
1630 
1631 int
1632 set_req_wwnn(ocs_t *ocs, char *name, char *value)
1633 {
1634 	int rc;
1635 	uint64_t wwnn;
1636 
1637 	if (ocs_strcasecmp(value, "default") == 0) {
1638 		wwnn = 0;
1639 	}
1640 	else if (parse_wwn(value, &wwnn) != 0) {
1641 		ocs_log_test(ocs, "Invalid WWNN: %s\n", value);
1642 		return 1;
1643 	}
1644 
1645 	rc = ocs_xport_control(ocs->xport, OCS_XPORT_WWNN_SET, wwnn);
1646 
1647 	if(rc) {
1648 		ocs_log_test(ocs, "OCS_XPORT_WWNN_SET failed: %d\n", rc);
1649 		return rc;
1650 	}
1651 
1652 	rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
1653 	if (rc) {
1654 		ocs_log_test(ocs, "port offline failed : %d\n", rc);
1655 	}
1656 
1657 	rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
1658 	if (rc) {
1659 		ocs_log_test(ocs, "port online failed : %d\n", rc);
1660 	}
1661 
1662 	return rc;
1663 }
1664 
1665 /**
1666  * @brief Set requested WWNP value.
1667  *
1668  * @param ocs Pointer to the ocs structure.
1669  * @param name Not used.
1670  * @param value Value to which the linkcfg is set.
1671  *
1672  * @return Returns 0 on success.
1673  */
1674 
1675 int
1676 set_req_wwpn(ocs_t *ocs, char *name, char *value)
1677 {
1678 	int rc;
1679 	uint64_t wwpn;
1680 
1681 	if (ocs_strcasecmp(value, "default") == 0) {
1682 		wwpn = 0;
1683 	}
1684 	else if (parse_wwn(value, &wwpn) != 0) {
1685 		ocs_log_test(ocs, "Invalid WWPN: %s\n", value);
1686 		return 1;
1687 	}
1688 
1689 	rc = ocs_xport_control(ocs->xport, OCS_XPORT_WWPN_SET, wwpn);
1690 
1691 	if(rc) {
1692 		ocs_log_test(ocs, "OCS_XPORT_WWPN_SET failed: %d\n", rc);
1693 		return rc;
1694 	}
1695 
1696 	rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
1697 	if (rc) {
1698 		ocs_log_test(ocs, "port offline failed : %d\n", rc);
1699 	}
1700 
1701 	rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
1702 	if (rc) {
1703 		ocs_log_test(ocs, "port online failed : %d\n", rc);
1704 	}
1705 
1706 	return rc;
1707 }
1708 
1709 /**
1710  * @brief Set node debug mask value
1711  *
1712  * @param ocs Pointer to the ocs structure.
1713  * @param name Not used.
1714  * @param value Value to which the nodedb_mask is set.
1715  *
1716  * @return Returns 0 on success.
1717  */
1718 static int
1719 set_nodedb_mask(ocs_t *ocs, char *name, char *value)
1720 {
1721 	ocs->nodedb_mask = ocs_strtoul(value, 0, 0);
1722 	return 0;
1723 }
1724 
1725 /**
1726  * @brief Set linkcfg config value.
1727  *
1728  * @param ocs Pointer to the ocs structure.
1729  * @param name Not used.
1730  * @param value Value to which the linkcfg is set.
1731  *
1732  * @return Returns 0 on success.
1733  */
1734 static int
1735 set_linkcfg(ocs_t *ocs, char *name, char *value)
1736 {
1737 	ocs_hw_linkcfg_e linkcfg;
1738 	ocs_mgmt_linkcfg_arg_t cb_arg;
1739 	ocs_hw_rtn_e status;
1740 
1741 	ocs_sem_init(&cb_arg.semaphore, 0, "mgmt_linkcfg");
1742 
1743 	/* translate mgmt linkcfg string to HW linkcfg enum */
1744 	linkcfg = ocs_hw_linkcfg_from_mgmt(value);
1745 
1746 	/* set HW linkcfg */
1747 	status = ocs_hw_port_control(&ocs->hw, OCS_HW_PORT_SET_LINK_CONFIG,
1748 				      (uintptr_t)linkcfg, ocs_mgmt_linkcfg_cb, &cb_arg);
1749 	if (status) {
1750 		ocs_log_test(ocs, "ocs_hw_set_linkcfg failed\n");
1751 		return -1;
1752 	}
1753 
1754 	if (ocs_sem_p(&cb_arg.semaphore, OCS_SEM_FOREVER)) {
1755 		ocs_log_err(ocs, "ocs_sem_p failed\n");
1756 		return -1;
1757 	}
1758 
1759 	if (cb_arg.status) {
1760 		ocs_log_test(ocs, "failed to set linkcfg from HW status=%d\n",
1761 			     cb_arg.status);
1762 		return -1;
1763 	}
1764 
1765 	return 0;
1766 }
1767 
1768 /**
1769  * @brief Linkcfg callback
1770  *
1771  * @param status Result of the linkcfg get/set operation.
1772  * @param value Resulting linkcfg value.
1773  * @param arg Callback argument.
1774  *
1775  * @return None.
1776  */
1777 static void
1778 ocs_mgmt_linkcfg_cb(int32_t status, uintptr_t value, void *arg)
1779 {
1780 	ocs_mgmt_linkcfg_arg_t *cb_arg = (ocs_mgmt_linkcfg_arg_t *)arg;
1781 	cb_arg->status = status;
1782 	cb_arg->linkcfg = (ocs_hw_linkcfg_e)value;
1783 	ocs_sem_v(&cb_arg->semaphore);
1784 }
1785 
1786 static int
1787 set_debug_mq_dump(ocs_t *ocs, char *name, char *value)
1788 {
1789 	int result;
1790 
1791 	if (ocs_strcasecmp(value, "false") == 0) {
1792 		ocs_debug_disable(OCS_DEBUG_ENABLE_MQ_DUMP);
1793 		result = 0;
1794 	} else if (ocs_strcasecmp(value, "true") == 0) {
1795 		ocs_debug_enable(OCS_DEBUG_ENABLE_MQ_DUMP);
1796 		result = 0;
1797 	} else {
1798 		result = -1;
1799 	}
1800 
1801 	return result;
1802 }
1803 
1804 static int
1805 set_debug_cq_dump(ocs_t *ocs, char *name, char *value)
1806 {
1807 	int result;
1808 
1809 	if (ocs_strcasecmp(value, "false") == 0) {
1810 		ocs_debug_disable(OCS_DEBUG_ENABLE_CQ_DUMP);
1811 		result = 0;
1812 	} else if (ocs_strcasecmp(value, "true") == 0) {
1813 		ocs_debug_enable(OCS_DEBUG_ENABLE_CQ_DUMP);
1814 		result = 0;
1815 	} else {
1816 		result = -1;
1817 	}
1818 
1819 	return result;
1820 }
1821 
1822 static int
1823 set_debug_wq_dump(ocs_t *ocs, char *name, char *value)
1824 {
1825 	int result;
1826 
1827 	if (ocs_strcasecmp(value, "false") == 0) {
1828 		ocs_debug_disable(OCS_DEBUG_ENABLE_WQ_DUMP);
1829 		result = 0;
1830 	} else if (ocs_strcasecmp(value, "true") == 0) {
1831 		ocs_debug_enable(OCS_DEBUG_ENABLE_WQ_DUMP);
1832 		result = 0;
1833 	} else {
1834 		result = -1;
1835 	}
1836 
1837 	return result;
1838 }
1839 
1840 static int
1841 set_debug_eq_dump(ocs_t *ocs, char *name, char *value)
1842 {
1843 	int result;
1844 
1845 	if (ocs_strcasecmp(value, "false") == 0) {
1846 		ocs_debug_disable(OCS_DEBUG_ENABLE_EQ_DUMP);
1847 		result = 0;
1848 	} else if (ocs_strcasecmp(value, "true") == 0) {
1849 		ocs_debug_enable(OCS_DEBUG_ENABLE_EQ_DUMP);
1850 		result = 0;
1851 	} else {
1852 		result = -1;
1853 	}
1854 
1855 	return result;
1856 }
1857 
1858 static int
1859 set_logmask(ocs_t *ocs, char *name, char *value)
1860 {
1861 
1862 	ocs->logmask = ocs_strtoul(value, NULL, 0);
1863 
1864 	return 0;
1865 }
1866 
1867 static int
1868 set_loglevel(ocs_t *ocs, char *name, char *value)
1869 {
1870 
1871 	loglevel = ocs_strtoul(value, NULL, 0);
1872 
1873 	return 0;
1874 }
1875 
1876 int
1877 set_configured_speed(ocs_t *ocs, char *name, char *value)
1878 {
1879 	int result = 0;
1880 	ocs_hw_rtn_e hw_rc;
1881 	int xport_rc;
1882 	uint32_t spd;
1883 
1884 	spd = ocs_strtoul(value, NULL, 0);
1885 
1886 	if ((spd != 0) && (spd != 2000) && (spd != 4000) &&
1887 		(spd != 8000) && (spd != 16000) && (spd != 32000)) {
1888 		ocs_log_test(ocs, "unsupported speed %d\n", spd);
1889 		return 1;
1890 	}
1891 
1892 	ocs_log_debug(ocs, "Taking port offline\n");
1893 	xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
1894 	if (xport_rc != 0) {
1895 		ocs_log_test(ocs, "Port offline failed\n");
1896 		result = 1;
1897 	} else {
1898 		ocs_log_debug(ocs, "Setting port to speed %d\n", spd);
1899 		hw_rc = ocs_hw_set(&ocs->hw, OCS_HW_LINK_SPEED, spd);
1900 		if (hw_rc != OCS_HW_RTN_SUCCESS) {
1901 			ocs_log_test(ocs, "Speed set failed\n");
1902 			result = 1;
1903 		}
1904 
1905 		/* If we failed to set the speed we still want to try to bring
1906 		 * the port back online */
1907 
1908 		ocs_log_debug(ocs, "Bringing port online\n");
1909 		xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
1910 		if (xport_rc != 0) {
1911 			result = 1;
1912 		}
1913 	}
1914 
1915 	return result;
1916 }
1917 
1918 int
1919 set_configured_topology(ocs_t *ocs, char *name, char *value)
1920 {
1921 	int result = 0;
1922 	ocs_hw_rtn_e hw_rc;
1923 	int xport_rc;
1924 	uint32_t topo;
1925 
1926 	topo = ocs_strtoul(value, NULL, 0);
1927 	if (topo >= OCS_HW_TOPOLOGY_NONE) {
1928 		return 1;
1929 	}
1930 
1931 	ocs_log_debug(ocs, "Taking port offline\n");
1932 	xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
1933 	if (xport_rc != 0) {
1934 		ocs_log_test(ocs, "Port offline failed\n");
1935 		result = 1;
1936 	} else {
1937 		ocs_log_debug(ocs, "Setting port to topology %d\n", topo);
1938 		hw_rc = ocs_hw_set(&ocs->hw, OCS_HW_TOPOLOGY, topo);
1939 		if (hw_rc != OCS_HW_RTN_SUCCESS) {
1940 			ocs_log_test(ocs, "Topology set failed\n");
1941 			result = 1;
1942 		}
1943 
1944 		/* If we failed to set the topology we still want to try to bring
1945 		 * the port back online */
1946 
1947 		ocs_log_debug(ocs, "Bringing port online\n");
1948 		xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
1949 		if (xport_rc != 0) {
1950 			result = 1;
1951 		}
1952 	}
1953 
1954 	return result;
1955 }
1956 
1957 static int
1958 set_configured_link_state(ocs_t *ocs, char *name, char *value)
1959 {
1960 	int result = 0;
1961 	int xport_rc;
1962 
1963 	if (ocs_strcasecmp(value, "offline") == 0) {
1964 		ocs_log_debug(ocs, "Setting port to %s\n", value);
1965 		xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
1966 		if (xport_rc != 0) {
1967 			ocs_log_test(ocs, "Setting port to offline failed\n");
1968 			result = -1;
1969 		}
1970 	} else if (ocs_strcasecmp(value, "online") == 0) {
1971 		ocs_log_debug(ocs, "Setting port to %s\n", value);
1972 		xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
1973 		if (xport_rc != 0) {
1974 			ocs_log_test(ocs, "Setting port to online failed\n");
1975 			result = -1;
1976 		}
1977 	} else {
1978 		ocs_log_test(ocs, "Unsupported link state \"%s\"\n", value);
1979 		result = -1;
1980 	}
1981 
1982 	return result;
1983 }
1984 
1985 typedef struct ocs_mgmt_get_port_protocol_result {
1986 	ocs_sem_t semaphore;
1987 	int32_t status;
1988 	ocs_hw_port_protocol_e port_protocol;
1989 } ocs_mgmt_get_port_protocol_result_t;
1990 
1991 static void
1992 ocs_mgmt_get_port_protocol_cb(int32_t status,
1993 			      ocs_hw_port_protocol_e port_protocol,
1994 			      void    *arg)
1995 {
1996 	ocs_mgmt_get_port_protocol_result_t *result = arg;
1997 
1998 	result->status = status;
1999 	result->port_protocol = port_protocol;
2000 
2001 	ocs_sem_v(&(result->semaphore));
2002 }
2003 
2004 static void
2005 get_port_protocol(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
2006 {
2007 	ocs_mgmt_get_port_protocol_result_t result;
2008 	uint8_t bus;
2009 	uint8_t dev;
2010 	uint8_t func;
2011 
2012 	ocs_sem_init(&(result.semaphore), 0, "get_port_protocol");
2013 
2014 	ocs_get_bus_dev_func(ocs, &bus, &dev, &func);
2015 
2016 	if(ocs_hw_get_port_protocol(&ocs->hw, func, ocs_mgmt_get_port_protocol_cb, &result) == OCS_HW_RTN_SUCCESS) {
2017 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2018 			/* Undefined failure */
2019 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2020 		}
2021 		if (result.status == 0) {
2022 			switch (result.port_protocol) {
2023 			case OCS_HW_PORT_PROTOCOL_ISCSI:
2024 				ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "iSCSI");
2025 				break;
2026 			case OCS_HW_PORT_PROTOCOL_FCOE:
2027 				ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "FCoE");
2028 				break;
2029 			case OCS_HW_PORT_PROTOCOL_FC:
2030 				ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "FC");
2031 				break;
2032 			case OCS_HW_PORT_PROTOCOL_OTHER:
2033 				ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "Other");
2034 				break;
2035 			}
2036 		} else {
2037 			ocs_log_test(ocs, "getting port profile status 0x%x\n", result.status);
2038 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "Unknown");
2039 		}
2040 	}
2041 }
2042 
2043 typedef struct ocs_mgmt_set_port_protocol_result {
2044 	ocs_sem_t semaphore;
2045 	int32_t status;
2046 } ocs_mgmt_set_port_protocol_result_t;
2047 
2048 static void
2049 ocs_mgmt_set_port_protocol_cb(int32_t status,
2050 			      void    *arg)
2051 {
2052 	ocs_mgmt_get_port_protocol_result_t *result = arg;
2053 
2054 	result->status = status;
2055 
2056 	ocs_sem_v(&(result->semaphore));
2057 }
2058 
2059 /**
2060  * @brief  Set port protocol
2061  * @par Description
2062  * This is a management action handler to set the current
2063  * port protocol.  Input value should be one of iSCSI,
2064  * FC, or FCoE.
2065  *
2066  * @param ocs Pointer to the ocs structure.
2067  * @param name Name of the action being performed.
2068  * @param value The value to be assigned
2069  *
2070  * @return Returns 0 on success, non-zero on failure.
2071  */
2072 static int32_t
2073 set_port_protocol(ocs_t *ocs, char *name, char *value)
2074 {
2075 	ocs_mgmt_set_port_protocol_result_t result;
2076 	int32_t rc = 0;
2077 	ocs_hw_port_protocol_e new_protocol;
2078 	uint8_t bus;
2079 	uint8_t dev;
2080 	uint8_t func;
2081 
2082 	ocs_get_bus_dev_func(ocs, &bus, &dev, &func);
2083 
2084 	ocs_sem_init(&(result.semaphore), 0, "set_port_protocol");
2085 
2086 	if (ocs_strcasecmp(value, "iscsi") == 0) {
2087 		new_protocol = OCS_HW_PORT_PROTOCOL_ISCSI;
2088 	} else if (ocs_strcasecmp(value, "fc") == 0) {
2089 		new_protocol = OCS_HW_PORT_PROTOCOL_FC;
2090 	} else if (ocs_strcasecmp(value, "fcoe") == 0) {
2091 		new_protocol = OCS_HW_PORT_PROTOCOL_FCOE;
2092 	} else {
2093 		return -1;
2094 	}
2095 
2096 	rc = ocs_hw_set_port_protocol(&ocs->hw, new_protocol, func,
2097 				       ocs_mgmt_set_port_protocol_cb, &result);
2098 	if (rc == OCS_HW_RTN_SUCCESS) {
2099 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2100 			/* Undefined failure */
2101 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2102 			return -ENXIO;
2103 		}
2104 		if (result.status == 0) {
2105 			/* Success. */
2106 			rc = 0;
2107 		} else {
2108 			rc = -1;
2109 			ocs_log_test(ocs, "setting active profile status 0x%x\n",
2110 				     result.status);
2111 		}
2112 	}
2113 
2114 	return rc;
2115 }
2116 
2117 typedef struct ocs_mgmt_get_profile_list_result_s {
2118 	ocs_sem_t semaphore;
2119 	int32_t status;
2120 	ocs_hw_profile_list_t *list;
2121 } ocs_mgmt_get_profile_list_result_t;
2122 
2123 static void
2124 ocs_mgmt_get_profile_list_cb(int32_t status, ocs_hw_profile_list_t *list, void *ul_arg)
2125 {
2126 	ocs_mgmt_get_profile_list_result_t *result = ul_arg;
2127 
2128 	result->status = status;
2129 	result->list = list;
2130 
2131 	ocs_sem_v(&(result->semaphore));
2132 }
2133 
2134 /**
2135  * @brief  Get list of profiles
2136  * @par Description
2137  * This is a management action handler to get the list of
2138  * profiles supported by the SLI port.  Although the spec says
2139  * that all SLI platforms support this, only Skyhawk actually
2140  * has a useful implementation.
2141  *
2142  * @param ocs Pointer to the ocs structure.
2143  * @param name Name of the action being performed.
2144  * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
2145  *
2146  * @return none
2147  */
2148 static void
2149 get_profile_list(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
2150 {
2151 	ocs_mgmt_get_profile_list_result_t result;
2152 
2153 	ocs_sem_init(&(result.semaphore), 0, "get_profile_list");
2154 
2155 	if(ocs_hw_get_profile_list(&ocs->hw, ocs_mgmt_get_profile_list_cb, &result) == OCS_HW_RTN_SUCCESS) {
2156 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2157 			/* Undefined failure */
2158 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2159 		}
2160 		if (result.status == 0) {
2161 			/* Success. */
2162 #define MAX_LINE_SIZE 520
2163 #define BUFFER_SIZE MAX_LINE_SIZE*40
2164 			char *result_buf;
2165 			char result_line[MAX_LINE_SIZE];
2166 			uint32_t bytes_left;
2167 			uint32_t i;
2168 
2169 			result_buf = ocs_malloc(ocs, BUFFER_SIZE, OCS_M_ZERO);
2170 			bytes_left = BUFFER_SIZE;
2171 
2172 			for (i=0; i<result.list->num_descriptors; i++) {
2173 				sprintf(result_line, "0x%02x:%s\n", result.list->descriptors[i].profile_id,
2174 					result.list->descriptors[i].profile_description);
2175 				if (strlen(result_line) < bytes_left) {
2176 					strcat(result_buf, result_line);
2177 					bytes_left -= strlen(result_line);
2178 				}
2179 			}
2180 
2181 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "profile_list", result_buf);
2182 
2183 			ocs_free(ocs, result_buf, BUFFER_SIZE);
2184 			ocs_free(ocs, result.list, sizeof(ocs_hw_profile_list_t));
2185 		} else {
2186 			ocs_log_test(ocs, "getting profile list status 0x%x\n", result.status);
2187 		}
2188 	}
2189 }
2190 
2191 typedef struct ocs_mgmt_get_active_profile_result {
2192 	ocs_sem_t semaphore;
2193 	int32_t status;
2194 	uint32_t active_profile_id;
2195 } ocs_mgmt_get_active_profile_result_t;
2196 
2197 static void
2198 ocs_mgmt_get_active_profile_cb(int32_t status, uint32_t active_profile, void *ul_arg)
2199 {
2200 	ocs_mgmt_get_active_profile_result_t *result = ul_arg;
2201 
2202 	result->status = status;
2203 	result->active_profile_id = active_profile;
2204 
2205 	ocs_sem_v(&(result->semaphore));
2206 }
2207 
2208 #define MAX_PROFILE_LENGTH 5
2209 
2210 /**
2211  * @brief  Get active profile
2212  * @par Description
2213  * This is a management action handler to get the currently
2214  * active profile for an SLI port.  Although the spec says that
2215  * all SLI platforms support this, only Skyhawk actually has a
2216  * useful implementation.
2217  *
2218  * @param ocs Pointer to the ocs structure.
2219  * @param name Name of the action being performed.
2220  * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
2221  *
2222  * @return none
2223  */
2224 static void
2225 get_active_profile(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
2226 {
2227 	char result_string[MAX_PROFILE_LENGTH];
2228 	ocs_mgmt_get_active_profile_result_t result;
2229 
2230 	ocs_sem_init(&(result.semaphore), 0, "get_active_profile");
2231 
2232 	if(ocs_hw_get_active_profile(&ocs->hw, ocs_mgmt_get_active_profile_cb, &result) == OCS_HW_RTN_SUCCESS) {
2233 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2234 			/* Undefined failure */
2235 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2236 		}
2237 		if (result.status == 0) {
2238 			/* Success. */
2239 			sprintf(result_string, "0x%02x", result.active_profile_id);
2240 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "active_profile", result_string);
2241 		} else {
2242 			ocs_log_test(ocs, "getting active profile status 0x%x\n", result.status);
2243 		}
2244 	}
2245 }
2246 
2247 typedef struct ocs_mgmt_set_active_profile_result {
2248 	ocs_sem_t semaphore;
2249 	int32_t status;
2250 } ocs_mgmt_set_active_profile_result_t;
2251 
2252 static void
2253 ocs_mgmt_set_active_profile_cb(int32_t status, void *ul_arg)
2254 {
2255 	ocs_mgmt_get_profile_list_result_t *result = ul_arg;
2256 
2257 	result->status = status;
2258 
2259 	ocs_sem_v(&(result->semaphore));
2260 }
2261 
2262 /**
2263  * @brief  Set active profile
2264  * @par Description
2265  * This is a management action handler to set the currently
2266  * active profile for an SLI port.  Although the spec says that
2267  * all SLI platforms support this, only Skyhawk actually has a
2268  * useful implementation.
2269  *
2270  * @param ocs Pointer to the ocs structure.
2271  * @param name Name of the action being performed.
2272  * @param value Requested new value of the property.
2273  *
2274  * @return Returns 0 on success, non-zero on failure.
2275  */
2276 static int32_t
2277 set_active_profile(ocs_t *ocs, char *name, char *value)
2278 {
2279 	ocs_mgmt_set_active_profile_result_t result;
2280 	int32_t rc = 0;
2281 	int32_t new_profile;
2282 
2283 	new_profile = ocs_strtoul(value, NULL, 0);
2284 
2285 	ocs_sem_init(&(result.semaphore), 0, "set_active_profile");
2286 
2287 	rc = ocs_hw_set_active_profile(&ocs->hw, ocs_mgmt_set_active_profile_cb, new_profile, &result);
2288 	if (rc == OCS_HW_RTN_SUCCESS) {
2289 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2290 			/* Undefined failure */
2291 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2292 			return -ENXIO;
2293 		}
2294 		if (result.status == 0) {
2295 			/* Success. */
2296 			rc = 0;
2297 		} else {
2298 			rc = -1;
2299 			ocs_log_test(ocs, "setting active profile status 0x%x\n", result.status);
2300 		}
2301 	}
2302 
2303 	return rc;
2304 }
2305 
2306 typedef struct ocs_mgmt_get_nvparms_result {
2307 	ocs_sem_t semaphore;
2308 	int32_t status;
2309 	uint8_t	wwpn[8];
2310 	uint8_t wwnn[8];
2311 	uint8_t hard_alpa;
2312 	uint32_t preferred_d_id;
2313 } ocs_mgmt_get_nvparms_result_t;
2314 
2315 static void
2316 ocs_mgmt_get_nvparms_cb(int32_t status, uint8_t *wwpn, uint8_t *wwnn, uint8_t hard_alpa,
2317 		uint32_t preferred_d_id, void *ul_arg)
2318 {
2319 	ocs_mgmt_get_nvparms_result_t *result = ul_arg;
2320 
2321 	result->status = status;
2322 	ocs_memcpy(result->wwpn, wwpn, sizeof(result->wwpn));
2323 	ocs_memcpy(result->wwnn, wwnn, sizeof(result->wwnn));
2324 	result->hard_alpa = hard_alpa;
2325 	result->preferred_d_id = preferred_d_id;
2326 
2327 	ocs_sem_v(&(result->semaphore));
2328 }
2329 
2330 /**
2331  * @brief  Get wwpn
2332  * @par Description
2333  *
2334  *
2335  * @param ocs Pointer to the ocs structure.
2336  * @param name Name of the action being performed.
2337  * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
2338  *
2339  * @return none
2340  */
2341 static void
2342 get_nv_wwpn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
2343 {
2344 	char result_string[24];
2345 	ocs_mgmt_get_nvparms_result_t result;
2346 
2347 	ocs_sem_init(&(result.semaphore), 0, "get_nv_wwpn");
2348 
2349 	if(ocs_hw_get_nvparms(&ocs->hw, ocs_mgmt_get_nvparms_cb, &result) == OCS_HW_RTN_SUCCESS) {
2350 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2351 			/* Undefined failure */
2352 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2353 			return;
2354 		}
2355 		if (result.status == 0) {
2356 			/* Success.  Copy wwpn from result struct to result string */
2357 			sprintf(result_string, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
2358 					result.wwpn[0], result.wwpn[1], result.wwpn[2],
2359 					result.wwpn[3], result.wwpn[4], result.wwpn[5],
2360 					result.wwpn[6], result.wwpn[7]);
2361 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "nv_wwpn", result_string);
2362 		} else {
2363 			ocs_log_test(ocs, "getting wwpn status 0x%x\n", result.status);
2364 		}
2365 	}
2366 }
2367 
2368 /**
2369  * @brief  Get wwnn
2370  * @par Description
2371  *
2372  *
2373  * @param ocs Pointer to the ocs structure.
2374  * @param name Name of the action being performed.
2375  * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
2376  *
2377  * @return none
2378  */
2379 static void
2380 get_nv_wwnn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
2381 {
2382 	char result_string[24];
2383 	ocs_mgmt_get_nvparms_result_t result;
2384 
2385 	ocs_sem_init(&(result.semaphore), 0, "get_nv_wwnn");
2386 
2387 	if(ocs_hw_get_nvparms(&ocs->hw, ocs_mgmt_get_nvparms_cb, &result) == OCS_HW_RTN_SUCCESS) {
2388 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2389 			/* Undefined failure */
2390 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2391 			return;
2392 		}
2393 		if (result.status == 0) {
2394 			/* Success. Copy wwnn from result struct to result string */
2395 			ocs_snprintf(result_string, sizeof(result_string), "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
2396 					result.wwnn[0], result.wwnn[1], result.wwnn[2],
2397 					result.wwnn[3], result.wwnn[4], result.wwnn[5],
2398 					result.wwnn[6], result.wwnn[7]);
2399 			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "nv_wwnn", result_string);
2400 		} else {
2401 			ocs_log_test(ocs, "getting wwnn status 0x%x\n", result.status);
2402 		}
2403 	}
2404 }
2405 
2406 /**
2407  * @brief Get accumulated node abort counts
2408  * @par Description Get the sum of all nodes abort count.
2409  *
2410  * @param ocs Pointer to the ocs structure.
2411  * @param name Name of the action being performed.
2412  * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
2413  *
2414  * @return None.
2415  */
2416 static void
2417 get_node_abort_cnt(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
2418 {
2419 	uint32_t abort_counts = 0;
2420 	ocs_domain_t *domain;
2421 	ocs_sport_t *sport;
2422 	ocs_node_t *node;
2423 
2424 	if (ocs_device_lock_try(ocs) != TRUE) {
2425 		/* Didn't get the lock */
2426 		return;
2427 	}
2428 
2429 		/* Here the Device lock is held */
2430 		ocs_list_foreach(&ocs->domain_list, domain) {
2431 			if (ocs_domain_lock_try(domain) != TRUE) {
2432 				/* Didn't get the lock */
2433 				ocs_device_unlock(ocs);
2434 				return;
2435 			}
2436 
2437 				/* Here the Domain lock is held */
2438 				ocs_list_foreach(&domain->sport_list, sport) {
2439 					if (ocs_sport_lock_try(sport) != TRUE) {
2440 						/* Didn't get the lock */
2441 						ocs_domain_unlock(domain);
2442 						ocs_device_unlock(ocs);
2443 						return;
2444 					}
2445 
2446 						/* Here the sport lock is held */
2447 						ocs_list_foreach(&sport->node_list, node) {
2448 							abort_counts += node->abort_cnt;
2449 						}
2450 
2451 					ocs_sport_unlock(sport);
2452 				}
2453 
2454 			ocs_domain_unlock(domain);
2455 		}
2456 
2457 	ocs_device_unlock(ocs);
2458 
2459 	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "node_abort_cnt", "%d" , abort_counts);
2460 }
2461 
2462 typedef struct ocs_mgmt_set_nvparms_result {
2463 	ocs_sem_t semaphore;
2464 	int32_t status;
2465 } ocs_mgmt_set_nvparms_result_t;
2466 
2467 static void
2468 ocs_mgmt_set_nvparms_cb(int32_t status, void *ul_arg)
2469 {
2470 	ocs_mgmt_get_profile_list_result_t *result = ul_arg;
2471 
2472 	result->status = status;
2473 
2474 	ocs_sem_v(&(result->semaphore));
2475 }
2476 
2477 /**
2478  * @brief  Set wwn
2479  * @par Description Sets the Non-volatile worldwide names,
2480  * if provided.
2481  *
2482  * @param ocs Pointer to the ocs structure.
2483  * @param name Name of the action being performed.
2484  * @param wwn_p Requested new WWN values.
2485  *
2486  * @return Returns 0 on success, non-zero on failure.
2487  */
2488 static int32_t
2489 set_nv_wwn(ocs_t *ocs, char *name, char *wwn_p)
2490 {
2491 	ocs_mgmt_get_nvparms_result_t result;
2492 	uint8_t new_wwpn[8];
2493 	uint8_t new_wwnn[8];
2494 	char *wwpn_p = NULL;
2495 	char *wwnn_p = NULL;
2496 	int32_t rc = -1;
2497 	int wwpn = 0;
2498 	int wwnn = 0;
2499 	int i;
2500 
2501 	/* This is a read-modify-write operation, so first we have to read
2502 	 * the current values
2503 	 */
2504 	ocs_sem_init(&(result.semaphore), 0, "set_nv_wwn1");
2505 
2506 	rc = ocs_hw_get_nvparms(&ocs->hw, ocs_mgmt_get_nvparms_cb, &result);
2507 
2508 	if (rc == OCS_HW_RTN_SUCCESS) {
2509 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2510 			/* Undefined failure */
2511 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2512 			return -ENXIO;
2513 		}
2514 		if (result.status != 0) {
2515 			ocs_log_test(ocs, "getting nvparms status 0x%x\n", result.status);
2516 			return -1;
2517 		}
2518 	}
2519 
2520 	/* wwn_p contains wwpn_p@wwnn_p values */
2521 	if (wwn_p != NULL) {
2522 		wwpn_p = ocs_strsep(&wwn_p, "@");
2523 		wwnn_p = wwn_p;
2524 	}
2525 
2526 	if (wwpn_p != NULL) {
2527 		wwpn = ocs_strcmp(wwpn_p, "NA");
2528 	}
2529 
2530 	if (wwnn_p != NULL) {
2531 		wwnn = ocs_strcmp(wwnn_p, "NA");
2532 	}
2533 
2534 	/* Parse the new WWPN */
2535 	if ((wwpn_p != NULL) && (wwpn != 0)) {
2536 		if (ocs_sscanf(wwpn_p, "%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx",
2537 				&(new_wwpn[0]), &(new_wwpn[1]), &(new_wwpn[2]),
2538 				&(new_wwpn[3]), &(new_wwpn[4]), &(new_wwpn[5]),
2539 				&(new_wwpn[6]), &(new_wwpn[7])) != 8) {
2540 			ocs_log_test(ocs, "can't parse WWPN %s\n", wwpn_p);
2541 			return -1;
2542 		}
2543 	}
2544 
2545 	/* Parse the new WWNN */
2546 	if ((wwnn_p != NULL) && (wwnn != 0 )) {
2547 		if (ocs_sscanf(wwnn_p, "%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx",
2548 				&(new_wwnn[0]), &(new_wwnn[1]), &(new_wwnn[2]),
2549 				&(new_wwnn[3]), &(new_wwnn[4]), &(new_wwnn[5]),
2550 				&(new_wwnn[6]), &(new_wwnn[7])) != 8) {
2551 			ocs_log_test(ocs, "can't parse WWNN %s\n", wwnn_p);
2552 			return -1;
2553 		}
2554 	}
2555 
2556 	for (i = 0; i < 8; i++) {
2557 		/* Use active wwpn, if new one is not provided */
2558 		if (wwpn == 0) {
2559 			new_wwpn[i] = result.wwpn[i];
2560 		}
2561 
2562 		/* Use active wwnn, if new one is not provided */
2563 		if (wwnn == 0) {
2564 			new_wwnn[i] = result.wwnn[i];
2565 		}
2566 	}
2567 
2568 	/* Modify the nv_wwnn and nv_wwpn, then write it back */
2569 	ocs_sem_init(&(result.semaphore), 0, "set_nv_wwn2");
2570 
2571 	rc = ocs_hw_set_nvparms(&ocs->hw, ocs_mgmt_set_nvparms_cb, new_wwpn,
2572 				 new_wwnn, result.hard_alpa, result.preferred_d_id,
2573 				 &result);
2574 	if (rc == OCS_HW_RTN_SUCCESS) {
2575 		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
2576 			/* Undefined failure */
2577 			ocs_log_err(ocs, "ocs_sem_p failed\n");
2578 			return -ENXIO;
2579 		}
2580 		if (result.status != 0) {
2581 			ocs_log_test(ocs, "setting wwn status 0x%x\n", result.status);
2582 			return -1;
2583 		}
2584 	}
2585 
2586 	return rc;
2587 }
2588 
2589 static int
2590 set_tgt_rscn_delay(ocs_t *ocs, char *name, char *value)
2591 {
2592 	ocs->tgt_rscn_delay_msec = ocs_strtoul(value, NULL, 0) * 1000;
2593 	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
2594 	return 0;
2595 }
2596 
2597 static int
2598 set_tgt_rscn_period(ocs_t *ocs, char *name, char *value)
2599 {
2600 	ocs->tgt_rscn_period_msec = ocs_strtoul(value, NULL, 0) * 1000;
2601 	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
2602 	return 0;
2603 }
2604 
2605 static int
2606 set_inject_drop_cmd(ocs_t *ocs, char *name, char *value)
2607 {
2608 	ocs->err_injection = (ocs_strtoul(value, NULL, 0) == 0 ? NO_ERR_INJECT : INJECT_DROP_CMD);
2609 	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
2610 	return 0;
2611 }
2612 
2613 static int
2614 set_inject_free_drop_cmd(ocs_t *ocs, char *name, char *value)
2615 {
2616 	ocs->err_injection = (ocs_strtoul(value, NULL, 0) == 0 ? NO_ERR_INJECT : INJECT_FREE_DROPPED);
2617 	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
2618 	return 0;
2619 }
2620 
2621 static int
2622 set_inject_drop_data(ocs_t *ocs, char *name, char *value)
2623 {
2624 	ocs->err_injection = (ocs_strtoul(value, NULL, 0) == 0 ? NO_ERR_INJECT : INJECT_DROP_DATA);
2625 	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
2626 	return 0;
2627 }
2628 
2629 static int
2630 set_inject_drop_resp(ocs_t *ocs, char *name, char *value)
2631 {
2632 	ocs->err_injection = (ocs_strtoul(value, NULL, 0) == 0 ? NO_ERR_INJECT : INJECT_DROP_RESP);
2633 	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
2634 	return 0;
2635 }
2636 
2637 static int
2638 set_cmd_err_inject(ocs_t *ocs, char *name, char *value)
2639 {
2640 	ocs->cmd_err_inject = ocs_strtoul(value, NULL, 0);
2641 	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
2642 	return 0;
2643 }
2644 
2645 static int
2646 set_cmd_delay_value(ocs_t *ocs, char *name, char *value)
2647 {
2648 	ocs->delay_value_msec = ocs_strtoul(value, NULL, 0);
2649 	ocs->err_injection = (ocs->delay_value_msec == 0 ? NO_ERR_INJECT : INJECT_DELAY_CMD);
2650 	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
2651 	return 0;
2652 }
2653 
2654 /**
2655  * @brief parse a WWN from a string into a 64-bit value
2656  *
2657  * Given a pointer to a string, parse the string into a 64-bit
2658  * WWN value.  The format of the string must be xx:xx:xx:xx:xx:xx:xx:xx
2659  *
2660  * @param wwn_in pointer to the string to be parsed
2661  * @param wwn_out pointer to uint64_t in which to put the parsed result
2662  *
2663  * @return 0 if successful, non-zero if the WWN is malformed and couldn't be parsed
2664  */
2665 int
2666 parse_wwn(char *wwn_in, uint64_t *wwn_out)
2667 {
2668 	uint8_t byte0;
2669 	uint8_t byte1;
2670 	uint8_t byte2;
2671 	uint8_t byte3;
2672 	uint8_t byte4;
2673 	uint8_t byte5;
2674 	uint8_t byte6;
2675 	uint8_t byte7;
2676 	int rc;
2677 
2678 	rc = ocs_sscanf(wwn_in, "0x%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx",
2679 				&byte0, &byte1, &byte2, &byte3,
2680 				&byte4, &byte5, &byte6, &byte7);
2681 
2682 	if (rc == 8) {
2683 		*wwn_out = ((uint64_t)byte0 << 56) |
2684 				((uint64_t)byte1 << 48) |
2685 				((uint64_t)byte2 << 40) |
2686 				((uint64_t)byte3 << 32) |
2687 				((uint64_t)byte4 << 24) |
2688 				((uint64_t)byte5 << 16) |
2689 				((uint64_t)byte6 <<  8) |
2690 				((uint64_t)byte7);
2691 		return 0;
2692 
2693 	} else {
2694 		return 1;
2695 	}
2696 }
2697 
2698 static char *mode_string(int mode);
2699 
2700 /**
2701  * @ingroup mgmt
2702  * @brief Generate the beginning of a numbered section in a management XML document.
2703  *
2704  * @par Description
2705  * This function begins a section. The XML information is appended to
2706  * the textbuf. This form of the function is used for sections that might have
2707  * multiple instances, such as a node or a SLI Port (sport). The index number
2708  * is appended to the name.
2709  *
2710  * @param textbuf Pointer to the driver dump text buffer.
2711  * @param name Name of the section.
2712  * @param index Index number of this instance of the section.
2713  *
2714  * @return None.
2715  */
2716 
2717 extern void ocs_mgmt_start_section(ocs_textbuf_t *textbuf, const char *name, int index)
2718 {
2719 	ocs_textbuf_printf(textbuf, "<%s instance=\"%d\">\n", name, index);
2720 }
2721 
2722 /**
2723  * @ingroup mgmt
2724  * @brief Generate the beginning of an unnumbered section in a management XML document.
2725  *
2726  * @par Description
2727  * This function begins a section. The XML information is appended to
2728  * the textbuf. This form of the function is used for sections that have
2729  * a single instance only. Therefore, no index number is needed.
2730  *
2731  * @param textbuf Pointer to the driver dump text buffer.
2732  * @param name Name of the section.
2733  *
2734  * @return None.
2735  */
2736 
2737 extern void ocs_mgmt_start_unnumbered_section(ocs_textbuf_t *textbuf, const char *name)
2738 {
2739 	ocs_textbuf_printf(textbuf, "<%s>\n", name);
2740 }
2741 
2742 /**
2743  * @ingroup mgmt
2744  * @brief Generate the end of a section in a management XML document.
2745  *
2746  * @par Description
2747  * This function ends a section. The XML information is appended to
2748  * the textbuf.
2749  *
2750  * @param textbuf Pointer to the driver dump text buffer.
2751  * @param name Name of the section.
2752  *
2753  * @return None.
2754  */
2755 
2756 void ocs_mgmt_end_unnumbered_section(ocs_textbuf_t *textbuf, const char *name)
2757 {
2758 	ocs_textbuf_printf(textbuf, "</%s>\n", name);
2759 }
2760 
2761 /**
2762  * @ingroup mgmt
2763  * @brief Generate the indexed end of a section in a management XML document.
2764  *
2765  * @par Description
2766  * This function ends a section. The XML information is appended to
2767  * the textbuf.
2768  *
2769  * @param textbuf Pointer to the driver dump text buffer.
2770  * @param name Name of the section.
2771  * @param index Index number of this instance of the section.
2772  *
2773  * @return None.
2774  */
2775 
2776 void ocs_mgmt_end_section(ocs_textbuf_t *textbuf, const char *name, int index)
2777 {
2778 
2779 	ocs_textbuf_printf(textbuf, "</%s>\n", name);
2780 
2781 }
2782 
2783 /**
2784  * @ingroup mgmt
2785  * @brief Generate a property, with no value, in a management XML document.
2786  *
2787  * @par Description
2788  * This function generates a property name. The XML information is appended to
2789  * the textbuf. This form of the function is used by the list functions
2790  * when the property name only (and not the current value) is given.
2791  *
2792  * @param textbuf Pointer to the driver dump text buffer.
2793  * @param mode Defines whether the property is read(r)/write(w)/executable(x).
2794  * @param name Name of the property.
2795  *
2796  * @return None.
2797  */
2798 
2799 void ocs_mgmt_emit_property_name(ocs_textbuf_t *textbuf, int mode, const char *name)
2800 {
2801 	ocs_textbuf_printf(textbuf, "<%s mode=\"%s\"/>\n", name, mode_string(mode));
2802 }
2803 
2804 /**
2805  * @ingroup mgmt
2806  * @brief Generate a property with a string value in a management XML document.
2807  *
2808  * @par Description
2809  * This function generates a property name and a string value.
2810  * The XML information is appended to the textbuf.
2811  *
2812  * @param textbuf Pointer to the driver dump text buffer.
2813  * @param mode Defines whether the property is read(r)/write(w)/executable(x).
2814  * @param name Name of the property.
2815  * @param value Value of the property.
2816  *
2817  * @return None.
2818  */
2819 
2820 void ocs_mgmt_emit_string(ocs_textbuf_t *textbuf, int mode, const char *name, const char *value)
2821 {
2822 	ocs_textbuf_printf(textbuf, "<%s mode=\"%s\">%s</%s>\n", name, mode_string(mode), value, name);
2823 }
2824 
2825 /**
2826  * @ingroup mgmt
2827  * @brief Generate a property with an integer value in a management XML document.
2828  *
2829  * @par Description
2830  * This function generates a property name and an integer value.
2831  * The XML information is appended to the textbuf.
2832  *
2833  * @param textbuf Pointer to driver dump text buffer.
2834  * @param mode Defines whether the property is read(r)/write(w)/executable(x).
2835  * @param name Name of the property.
2836  * @param fmt A printf format for formatting the integer value.
2837  *
2838  * @return none
2839  */
2840 
2841 void ocs_mgmt_emit_int(ocs_textbuf_t *textbuf, int mode, const char *name, const char *fmt, ...)
2842 {
2843 	va_list ap;
2844 	char valuebuf[64];
2845 
2846 	va_start(ap, fmt);
2847 	ocs_vsnprintf(valuebuf, sizeof(valuebuf), fmt, ap);
2848 	va_end(ap);
2849 
2850 	ocs_textbuf_printf(textbuf, "<%s mode=\"%s\">%s</%s>\n", name, mode_string(mode), valuebuf, name);
2851 }
2852 
2853 /**
2854  * @ingroup mgmt
2855  * @brief Generate a property with a boolean value in a management XML document.
2856  *
2857  * @par Description
2858  * This function generates a property name and a boolean value.
2859  * The XML information is appended to the textbuf.
2860  *
2861  * @param textbuf Pointer to the driver dump text buffer.
2862  * @param mode Defines whether the property is read(r)/write(w)/executable(x).
2863  * @param name Name of the property.
2864  * @param value Boolean value to be added to the textbuf.
2865  *
2866  * @return None.
2867  */
2868 
2869 void ocs_mgmt_emit_boolean(ocs_textbuf_t *textbuf, int mode, const char *name, int value)
2870 {
2871 	char *valuebuf = value ? "true" : "false";
2872 
2873 	ocs_textbuf_printf(textbuf, "<%s mode=\"%s\">%s</%s>\n", name, mode_string(mode), valuebuf, name);
2874 }
2875 
2876 static char *mode_string(int mode)
2877 {
2878 	static char mode_str[4];
2879 
2880 	mode_str[0] = '\0';
2881 	if (mode & MGMT_MODE_RD) {
2882 		strcat(mode_str, "r");
2883 	}
2884 	if (mode & MGMT_MODE_WR) {
2885 		strcat(mode_str, "w");
2886 	}
2887 	if (mode & MGMT_MODE_EX) {
2888 		strcat(mode_str, "x");
2889 	}
2890 
2891 	return mode_str;
2892 
2893 }
2894