1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
4	* Copyright (c) 2014- QLogic Corporation.
5	* All rights reserved
6	* www.qlogic.com
7	*
8	* Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
9	*/
10
11	#include <linux/uaccess.h>
12	#include "bfad_drv.h"
13	#include "bfad_im.h"
14	#include "bfad_bsg.h"
15
16	BFA_TRC_FILE(LDRV, BSG);
17
18	static int
19	bfad_iocmd_ioc_enable(struct bfad_s *bfad, void *cmd)
20	{
21	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
22	unsigned long flags;
23
24	spin_lock_irqsave(&bfad->bfad_lock, flags);
25	/* If IOC is not in disabled state - return */
26	if (!bfa_ioc_is_disabled(ioc: &bfad->bfa.ioc)) {
27	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
28	iocmd->status = BFA_STATUS_OK;
29	return 0;
30	}
31
32	init_completion(x: &bfad->enable_comp);
33	bfa_iocfc_enable(bfa: &bfad->bfa);
34	iocmd->status = BFA_STATUS_OK;
35	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
36	wait_for_completion(&bfad->enable_comp);
37
38	return 0;
39	}
40
41	static int
42	bfad_iocmd_ioc_disable(struct bfad_s *bfad, void *cmd)
43	{
44	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
45	unsigned long flags;
46
47	spin_lock_irqsave(&bfad->bfad_lock, flags);
48	if (bfa_ioc_is_disabled(ioc: &bfad->bfa.ioc)) {
49	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
50	iocmd->status = BFA_STATUS_OK;
51	return 0;
52	}
53
54	if (bfad->disable_active) {
55	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
56	return -EBUSY;
57	}
58
59	bfad->disable_active = BFA_TRUE;
60	init_completion(x: &bfad->disable_comp);
61	bfa_iocfc_disable(bfa: &bfad->bfa);
62	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
63
64	wait_for_completion(&bfad->disable_comp);
65	bfad->disable_active = BFA_FALSE;
66	iocmd->status = BFA_STATUS_OK;
67
68	return 0;
69	}
70
71	static int
72	bfad_iocmd_ioc_get_info(struct bfad_s *bfad, void *cmd)
73	{
74	int i;
75	struct bfa_bsg_ioc_info_s *iocmd = (struct bfa_bsg_ioc_info_s *)cmd;
76	struct bfad_im_port_s *im_port;
77	struct bfa_port_attr_s pattr;
78	unsigned long flags;
79
80	spin_lock_irqsave(&bfad->bfad_lock, flags);
81	bfa_fcport_get_attr(bfa: &bfad->bfa, attr: &pattr);
82	iocmd->nwwn = pattr.nwwn;
83	iocmd->pwwn = pattr.pwwn;
84	iocmd->ioc_type = bfa_get_type(&bfad->bfa);
85	iocmd->mac = bfa_get_mac(&bfad->bfa);
86	iocmd->factory_mac = bfa_get_mfg_mac(&bfad->bfa);
87	bfa_get_adapter_serial_num(&bfad->bfa, iocmd->serialnum);
88	iocmd->factorynwwn = pattr.factorynwwn;
89	iocmd->factorypwwn = pattr.factorypwwn;
90	iocmd->bfad_num = bfad->inst_no;
91	im_port = bfad->pport.im_port;
92	iocmd->host = im_port->shost->host_no;
93	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
94
95	strcpy(p: iocmd->name, q: bfad->adapter_name);
96	strcpy(p: iocmd->port_name, q: bfad->port_name);
97	strcpy(p: iocmd->hwpath, q: bfad->pci_name);
98
99	/* set adapter hw path */
100	strcpy(p: iocmd->adapter_hwpath, q: bfad->pci_name);
101	for (i = 0; iocmd->adapter_hwpath[i] != ':' && i < BFA_STRING_32; i++)
102	;
103	for (; iocmd->adapter_hwpath[++i] != ':' && i < BFA_STRING_32; )
104	;
105	iocmd->adapter_hwpath[i] = '\0';
106	iocmd->status = BFA_STATUS_OK;
107	return 0;
108	}
109
110	static int
111	bfad_iocmd_ioc_get_attr(struct bfad_s *bfad, void *cmd)
112	{
113	struct bfa_bsg_ioc_attr_s *iocmd = (struct bfa_bsg_ioc_attr_s *)cmd;
114	unsigned long flags;
115
116	spin_lock_irqsave(&bfad->bfad_lock, flags);
117	bfa_ioc_get_attr(ioc: &bfad->bfa.ioc, ioc_attr: &iocmd->ioc_attr);
118	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
119
120	/* fill in driver attr info */
121	strcpy(p: iocmd->ioc_attr.driver_attr.driver, BFAD_DRIVER_NAME);
122	strscpy(iocmd->ioc_attr.driver_attr.driver_ver,
123	BFAD_DRIVER_VERSION, BFA_VERSION_LEN);
124	strcpy(p: iocmd->ioc_attr.driver_attr.fw_ver,
125	q: iocmd->ioc_attr.adapter_attr.fw_ver);
126	strcpy(p: iocmd->ioc_attr.driver_attr.bios_ver,
127	q: iocmd->ioc_attr.adapter_attr.optrom_ver);
128
129	/* copy chip rev info first otherwise it will be overwritten */
130	memcpy(bfad->pci_attr.chip_rev, iocmd->ioc_attr.pci_attr.chip_rev,
131	sizeof(bfad->pci_attr.chip_rev));
132	memcpy(&iocmd->ioc_attr.pci_attr, &bfad->pci_attr,
133	sizeof(struct bfa_ioc_pci_attr_s));
134
135	iocmd->status = BFA_STATUS_OK;
136	return 0;
137	}
138
139	static int
140	bfad_iocmd_ioc_get_stats(struct bfad_s *bfad, void *cmd)
141	{
142	struct bfa_bsg_ioc_stats_s *iocmd = (struct bfa_bsg_ioc_stats_s *)cmd;
143
144	bfa_ioc_get_stats(&bfad->bfa, &iocmd->ioc_stats);
145	iocmd->status = BFA_STATUS_OK;
146	return 0;
147	}
148
149	static int
150	bfad_iocmd_ioc_get_fwstats(struct bfad_s *bfad, void *cmd,
151	unsigned int payload_len)
152	{
153	struct bfa_bsg_ioc_fwstats_s *iocmd =
154	(struct bfa_bsg_ioc_fwstats_s *)cmd;
155	void *iocmd_bufptr;
156	unsigned long flags;
157
158	if (bfad_chk_iocmd_sz(payload_len,
159	sizeof(struct bfa_bsg_ioc_fwstats_s),
160	sizeof(struct bfa_fw_stats_s)) != BFA_STATUS_OK) {
161	iocmd->status = BFA_STATUS_VERSION_FAIL;
162	goto out;
163	}
164
165	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_ioc_fwstats_s);
166	spin_lock_irqsave(&bfad->bfad_lock, flags);
167	iocmd->status = bfa_ioc_fw_stats_get(ioc: &bfad->bfa.ioc, stats: iocmd_bufptr);
168	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
169
170	if (iocmd->status != BFA_STATUS_OK) {
171	bfa_trc(bfad, iocmd->status);
172	goto out;
173	}
174	out:
175	bfa_trc(bfad, 0x6666);
176	return 0;
177	}
178
179	static int
180	bfad_iocmd_ioc_reset_stats(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
181	{
182	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
183	unsigned long flags;
184
185	if (v_cmd == IOCMD_IOC_RESET_STATS) {
186	bfa_ioc_clear_stats(&bfad->bfa);
187	iocmd->status = BFA_STATUS_OK;
188	} else if (v_cmd == IOCMD_IOC_RESET_FWSTATS) {
189	spin_lock_irqsave(&bfad->bfad_lock, flags);
190	iocmd->status = bfa_ioc_fw_stats_clear(ioc: &bfad->bfa.ioc);
191	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
192	}
193
194	return 0;
195	}
196
197	static int
198	bfad_iocmd_ioc_set_name(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
199	{
200	struct bfa_bsg_ioc_name_s *iocmd = (struct bfa_bsg_ioc_name_s *) cmd;
201
202	if (v_cmd == IOCMD_IOC_SET_ADAPTER_NAME)
203	strcpy(p: bfad->adapter_name, q: iocmd->name);
204	else if (v_cmd == IOCMD_IOC_SET_PORT_NAME)
205	strcpy(p: bfad->port_name, q: iocmd->name);
206
207	iocmd->status = BFA_STATUS_OK;
208	return 0;
209	}
210
211	static int
212	bfad_iocmd_iocfc_get_attr(struct bfad_s *bfad, void *cmd)
213	{
214	struct bfa_bsg_iocfc_attr_s *iocmd = (struct bfa_bsg_iocfc_attr_s *)cmd;
215
216	iocmd->status = BFA_STATUS_OK;
217	bfa_iocfc_get_attr(bfa: &bfad->bfa, attr: &iocmd->iocfc_attr);
218
219	return 0;
220	}
221
222	static int
223	bfad_iocmd_ioc_fw_sig_inv(struct bfad_s *bfad, void *cmd)
224	{
225	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
226	unsigned long flags;
227
228	spin_lock_irqsave(&bfad->bfad_lock, flags);
229	iocmd->status = bfa_ioc_fwsig_invalidate(ioc: &bfad->bfa.ioc);
230	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
231	return 0;
232	}
233
234	static int
235	bfad_iocmd_iocfc_set_intr(struct bfad_s *bfad, void *cmd)
236	{
237	struct bfa_bsg_iocfc_intr_s *iocmd = (struct bfa_bsg_iocfc_intr_s *)cmd;
238	unsigned long flags;
239
240	spin_lock_irqsave(&bfad->bfad_lock, flags);
241	iocmd->status = bfa_iocfc_israttr_set(bfa: &bfad->bfa, attr: &iocmd->attr);
242	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
243
244	return 0;
245	}
246
247	static int
248	bfad_iocmd_port_enable(struct bfad_s *bfad, void *cmd)
249	{
250	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
251	struct bfad_hal_comp fcomp;
252	unsigned long flags;
253
254	init_completion(x: &fcomp.comp);
255	spin_lock_irqsave(&bfad->bfad_lock, flags);
256	iocmd->status = bfa_port_enable(port: &bfad->bfa.modules.port,
257	cbfn: bfad_hcb_comp, cbarg: &fcomp);
258	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
259	if (iocmd->status != BFA_STATUS_OK) {
260	bfa_trc(bfad, iocmd->status);
261	return 0;
262	}
263	wait_for_completion(&fcomp.comp);
264	iocmd->status = fcomp.status;
265	return 0;
266	}
267
268	static int
269	bfad_iocmd_port_disable(struct bfad_s *bfad, void *cmd)
270	{
271	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
272	struct bfad_hal_comp fcomp;
273	unsigned long flags;
274
275	init_completion(x: &fcomp.comp);
276	spin_lock_irqsave(&bfad->bfad_lock, flags);
277	iocmd->status = bfa_port_disable(port: &bfad->bfa.modules.port,
278	cbfn: bfad_hcb_comp, cbarg: &fcomp);
279	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
280
281	if (iocmd->status != BFA_STATUS_OK) {
282	bfa_trc(bfad, iocmd->status);
283	return 0;
284	}
285	wait_for_completion(&fcomp.comp);
286	iocmd->status = fcomp.status;
287	return 0;
288	}
289
290	static int
291	bfad_iocmd_port_get_attr(struct bfad_s *bfad, void *cmd)
292	{
293	struct bfa_bsg_port_attr_s *iocmd = (struct bfa_bsg_port_attr_s *)cmd;
294	struct bfa_lport_attr_s port_attr;
295	unsigned long flags;
296
297	spin_lock_irqsave(&bfad->bfad_lock, flags);
298	bfa_fcport_get_attr(bfa: &bfad->bfa, attr: &iocmd->attr);
299	bfa_fcs_lport_get_attr(port: &bfad->bfa_fcs.fabric.bport, port_attr: &port_attr);
300	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
301
302	if (iocmd->attr.topology != BFA_PORT_TOPOLOGY_NONE)
303	iocmd->attr.pid = port_attr.pid;
304	else
305	iocmd->attr.pid = 0;
306
307	iocmd->attr.port_type = port_attr.port_type;
308	iocmd->attr.loopback = port_attr.loopback;
309	iocmd->attr.authfail = port_attr.authfail;
310	strscpy(iocmd->attr.port_symname.symname,
311	port_attr.port_cfg.sym_name.symname,
312	sizeof(iocmd->attr.port_symname.symname));
313
314	iocmd->status = BFA_STATUS_OK;
315	return 0;
316	}
317
318	static int
319	bfad_iocmd_port_get_stats(struct bfad_s *bfad, void *cmd,
320	unsigned int payload_len)
321	{
322	struct bfa_bsg_port_stats_s *iocmd = (struct bfa_bsg_port_stats_s *)cmd;
323	struct bfad_hal_comp fcomp;
324	void *iocmd_bufptr;
325	unsigned long flags;
326
327	if (bfad_chk_iocmd_sz(payload_len,
328	sizeof(struct bfa_bsg_port_stats_s),
329	sizeof(union bfa_port_stats_u)) != BFA_STATUS_OK) {
330	iocmd->status = BFA_STATUS_VERSION_FAIL;
331	return 0;
332	}
333
334	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_port_stats_s);
335
336	init_completion(x: &fcomp.comp);
337	spin_lock_irqsave(&bfad->bfad_lock, flags);
338	iocmd->status = bfa_port_get_stats(port: &bfad->bfa.modules.port,
339	stats: iocmd_bufptr, cbfn: bfad_hcb_comp, cbarg: &fcomp);
340	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
341	if (iocmd->status != BFA_STATUS_OK) {
342	bfa_trc(bfad, iocmd->status);
343	goto out;
344	}
345
346	wait_for_completion(&fcomp.comp);
347	iocmd->status = fcomp.status;
348	out:
349	return 0;
350	}
351
352	static int
353	bfad_iocmd_port_reset_stats(struct bfad_s *bfad, void *cmd)
354	{
355	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
356	struct bfad_hal_comp fcomp;
357	unsigned long flags;
358
359	init_completion(x: &fcomp.comp);
360	spin_lock_irqsave(&bfad->bfad_lock, flags);
361	iocmd->status = bfa_port_clear_stats(port: &bfad->bfa.modules.port,
362	cbfn: bfad_hcb_comp, cbarg: &fcomp);
363	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
364	if (iocmd->status != BFA_STATUS_OK) {
365	bfa_trc(bfad, iocmd->status);
366	return 0;
367	}
368	wait_for_completion(&fcomp.comp);
369	iocmd->status = fcomp.status;
370	return 0;
371	}
372
373	static int
374	bfad_iocmd_set_port_cfg(struct bfad_s *bfad, void *iocmd, unsigned int v_cmd)
375	{
376	struct bfa_bsg_port_cfg_s *cmd = (struct bfa_bsg_port_cfg_s *)iocmd;
377	unsigned long flags;
378
379	spin_lock_irqsave(&bfad->bfad_lock, flags);
380	if (v_cmd == IOCMD_PORT_CFG_TOPO)
381	cmd->status = bfa_fcport_cfg_topology(bfa: &bfad->bfa, topo: cmd->param);
382	else if (v_cmd == IOCMD_PORT_CFG_SPEED)
383	cmd->status = bfa_fcport_cfg_speed(bfa: &bfad->bfa, speed: cmd->param);
384	else if (v_cmd == IOCMD_PORT_CFG_ALPA)
385	cmd->status = bfa_fcport_cfg_hardalpa(bfa: &bfad->bfa, alpa: cmd->param);
386	else if (v_cmd == IOCMD_PORT_CLR_ALPA)
387	cmd->status = bfa_fcport_clr_hardalpa(bfa: &bfad->bfa);
388	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
389
390	return 0;
391	}
392
393	static int
394	bfad_iocmd_port_cfg_maxfrsize(struct bfad_s *bfad, void *cmd)
395	{
396	struct bfa_bsg_port_cfg_maxfrsize_s *iocmd =
397	(struct bfa_bsg_port_cfg_maxfrsize_s *)cmd;
398	unsigned long flags;
399
400	spin_lock_irqsave(&bfad->bfad_lock, flags);
401	iocmd->status = bfa_fcport_cfg_maxfrsize(bfa: &bfad->bfa, maxsize: iocmd->maxfrsize);
402	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
403
404	return 0;
405	}
406
407	static int
408	bfad_iocmd_port_cfg_bbcr(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
409	{
410	struct bfa_bsg_bbcr_enable_s *iocmd =
411	(struct bfa_bsg_bbcr_enable_s *)pcmd;
412	unsigned long flags;
413	int rc;
414
415	spin_lock_irqsave(&bfad->bfad_lock, flags);
416	if (cmd == IOCMD_PORT_BBCR_ENABLE)
417	rc = bfa_fcport_cfg_bbcr(bfa: &bfad->bfa, on_off: BFA_TRUE, bb_scn: iocmd->bb_scn);
418	else if (cmd == IOCMD_PORT_BBCR_DISABLE)
419	rc = bfa_fcport_cfg_bbcr(bfa: &bfad->bfa, on_off: BFA_FALSE, bb_scn: 0);
420	else {
421	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
422	return -EINVAL;
423	}
424	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
425
426	iocmd->status = rc;
427	return 0;
428	}
429
430	static int
431	bfad_iocmd_port_get_bbcr_attr(struct bfad_s *bfad, void *pcmd)
432	{
433	struct bfa_bsg_bbcr_attr_s *iocmd = (struct bfa_bsg_bbcr_attr_s *) pcmd;
434	unsigned long flags;
435
436	spin_lock_irqsave(&bfad->bfad_lock, flags);
437	iocmd->status =
438	bfa_fcport_get_bbcr_attr(bfa: &bfad->bfa, bbcr_attr: &iocmd->attr);
439	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
440
441	return 0;
442	}
443
444
445	static int
446	bfad_iocmd_lport_get_attr(struct bfad_s *bfad, void *cmd)
447	{
448	struct bfa_fcs_lport_s *fcs_port;
449	struct bfa_bsg_lport_attr_s *iocmd = (struct bfa_bsg_lport_attr_s *)cmd;
450	unsigned long flags;
451
452	spin_lock_irqsave(&bfad->bfad_lock, flags);
453	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
454	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
455	if (fcs_port == NULL) {
456	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
457	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
458	goto out;
459	}
460
461	bfa_fcs_lport_get_attr(port: fcs_port, port_attr: &iocmd->port_attr);
462	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
463	iocmd->status = BFA_STATUS_OK;
464	out:
465	return 0;
466	}
467
468	static int
469	bfad_iocmd_lport_get_stats(struct bfad_s *bfad, void *cmd)
470	{
471	struct bfa_fcs_lport_s *fcs_port;
472	struct bfa_bsg_lport_stats_s *iocmd =
473	(struct bfa_bsg_lport_stats_s *)cmd;
474	unsigned long flags;
475
476	spin_lock_irqsave(&bfad->bfad_lock, flags);
477	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
478	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
479	if (fcs_port == NULL) {
480	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
481	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
482	goto out;
483	}
484
485	bfa_fcs_lport_get_stats(fcs_port, port_stats: &iocmd->port_stats);
486	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
487	iocmd->status = BFA_STATUS_OK;
488	out:
489	return 0;
490	}
491
492	static int
493	bfad_iocmd_lport_reset_stats(struct bfad_s *bfad, void *cmd)
494	{
495	struct bfa_fcs_lport_s *fcs_port;
496	struct bfa_bsg_reset_stats_s *iocmd =
497	(struct bfa_bsg_reset_stats_s *)cmd;
498	struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
499	struct list_head *qe, *qen;
500	struct bfa_itnim_s *itnim;
501	unsigned long flags;
502
503	spin_lock_irqsave(&bfad->bfad_lock, flags);
504	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
505	vf_id: iocmd->vf_id, lpwwn: iocmd->vpwwn);
506	if (fcs_port == NULL) {
507	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
508	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
509	goto out;
510	}
511
512	bfa_fcs_lport_clear_stats(fcs_port);
513	/* clear IO stats from all active itnims */
514	list_for_each_safe(qe, qen, &fcpim->itnim_q) {
515	itnim = (struct bfa_itnim_s *) qe;
516	if (itnim->rport->rport_info.lp_tag != fcs_port->lp_tag)
517	continue;
518	bfa_itnim_clear_stats(itnim);
519	}
520	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
521	iocmd->status = BFA_STATUS_OK;
522	out:
523	return 0;
524	}
525
526	static int
527	bfad_iocmd_lport_get_iostats(struct bfad_s *bfad, void *cmd)
528	{
529	struct bfa_fcs_lport_s *fcs_port;
530	struct bfa_bsg_lport_iostats_s *iocmd =
531	(struct bfa_bsg_lport_iostats_s *)cmd;
532	unsigned long flags;
533
534	spin_lock_irqsave(&bfad->bfad_lock, flags);
535	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
536	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
537	if (fcs_port == NULL) {
538	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
539	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
540	goto out;
541	}
542
543	bfa_fcpim_port_iostats(bfa: &bfad->bfa, stats: &iocmd->iostats,
544	lp_tag: fcs_port->lp_tag);
545	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
546	iocmd->status = BFA_STATUS_OK;
547	out:
548	return 0;
549	}
550
551	static int
552	bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
553	unsigned int payload_len)
554	{
555	struct bfa_bsg_lport_get_rports_s *iocmd =
556	(struct bfa_bsg_lport_get_rports_s *)cmd;
557	struct bfa_fcs_lport_s *fcs_port;
558	unsigned long flags;
559	void *iocmd_bufptr;
560
561	if (iocmd->nrports == 0)
562	return -EINVAL;
563
564	if (bfad_chk_iocmd_sz(payload_len,
565	sizeof(struct bfa_bsg_lport_get_rports_s),
566	sizeof(struct bfa_rport_qualifier_s) * iocmd->nrports)
567	!= BFA_STATUS_OK) {
568	iocmd->status = BFA_STATUS_VERSION_FAIL;
569	return 0;
570	}
571
572	iocmd_bufptr = (char *)iocmd +
573	sizeof(struct bfa_bsg_lport_get_rports_s);
574	spin_lock_irqsave(&bfad->bfad_lock, flags);
575	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
576	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
577	if (fcs_port == NULL) {
578	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
579	bfa_trc(bfad, 0);
580	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
581	goto out;
582	}
583
584	bfa_fcs_lport_get_rport_quals(port: fcs_port,
585	rport: (struct bfa_rport_qualifier_s *)iocmd_bufptr,
586	nrports: &iocmd->nrports);
587	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
588	iocmd->status = BFA_STATUS_OK;
589	out:
590	return 0;
591	}
592
593	static int
594	bfad_iocmd_rport_get_attr(struct bfad_s *bfad, void *cmd)
595	{
596	struct bfa_bsg_rport_attr_s *iocmd = (struct bfa_bsg_rport_attr_s *)cmd;
597	struct bfa_fcs_lport_s *fcs_port;
598	struct bfa_fcs_rport_s *fcs_rport;
599	unsigned long flags;
600
601	spin_lock_irqsave(&bfad->bfad_lock, flags);
602	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
603	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
604	if (fcs_port == NULL) {
605	bfa_trc(bfad, 0);
606	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
607	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
608	goto out;
609	}
610
611	if (iocmd->pid)
612	fcs_rport = bfa_fcs_lport_get_rport_by_qualifier(port: fcs_port,
613	pwwn: iocmd->rpwwn, pid: iocmd->pid);
614	else
615	fcs_rport = bfa_fcs_rport_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
616	if (fcs_rport == NULL) {
617	bfa_trc(bfad, 0);
618	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
619	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
620	goto out;
621	}
622
623	bfa_fcs_rport_get_attr(rport: fcs_rport, attr: &iocmd->attr);
624	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
625	iocmd->status = BFA_STATUS_OK;
626	out:
627	return 0;
628	}
629
630	static int
631	bfad_iocmd_rport_get_addr(struct bfad_s *bfad, void *cmd)
632	{
633	struct bfa_bsg_rport_scsi_addr_s *iocmd =
634	(struct bfa_bsg_rport_scsi_addr_s *)cmd;
635	struct bfa_fcs_lport_s *fcs_port;
636	struct bfa_fcs_itnim_s *fcs_itnim;
637	struct bfad_itnim_s *drv_itnim;
638	unsigned long flags;
639
640	spin_lock_irqsave(&bfad->bfad_lock, flags);
641	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
642	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
643	if (fcs_port == NULL) {
644	bfa_trc(bfad, 0);
645	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
646	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
647	goto out;
648	}
649
650	fcs_itnim = bfa_fcs_itnim_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
651	if (fcs_itnim == NULL) {
652	bfa_trc(bfad, 0);
653	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
654	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
655	goto out;
656	}
657
658	drv_itnim = fcs_itnim->itnim_drv;
659
660	if (drv_itnim && drv_itnim->im_port)
661	iocmd->host = drv_itnim->im_port->shost->host_no;
662	else {
663	bfa_trc(bfad, 0);
664	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
665	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
666	goto out;
667	}
668
669	iocmd->target = drv_itnim->scsi_tgt_id;
670	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
671
672	iocmd->bus = 0;
673	iocmd->lun = 0;
674	iocmd->status = BFA_STATUS_OK;
675	out:
676	return 0;
677	}
678
679	static int
680	bfad_iocmd_rport_get_stats(struct bfad_s *bfad, void *cmd)
681	{
682	struct bfa_bsg_rport_stats_s *iocmd =
683	(struct bfa_bsg_rport_stats_s *)cmd;
684	struct bfa_fcs_lport_s *fcs_port;
685	struct bfa_fcs_rport_s *fcs_rport;
686	unsigned long flags;
687
688	spin_lock_irqsave(&bfad->bfad_lock, flags);
689	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
690	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
691	if (fcs_port == NULL) {
692	bfa_trc(bfad, 0);
693	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
694	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
695	goto out;
696	}
697
698	fcs_rport = bfa_fcs_rport_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
699	if (fcs_rport == NULL) {
700	bfa_trc(bfad, 0);
701	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
702	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
703	goto out;
704	}
705
706	memcpy((void *)&iocmd->stats, (void *)&fcs_rport->stats,
707	sizeof(struct bfa_rport_stats_s));
708	if (bfa_fcs_rport_get_halrport(rport: fcs_rport)) {
709	memcpy((void *)&iocmd->stats.hal_stats,
710	(void *)&(bfa_fcs_rport_get_halrport(fcs_rport)->stats),
711	sizeof(struct bfa_rport_hal_stats_s));
712	}
713
714	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
715	iocmd->status = BFA_STATUS_OK;
716	out:
717	return 0;
718	}
719
720	static int
721	bfad_iocmd_rport_clr_stats(struct bfad_s *bfad, void *cmd)
722	{
723	struct bfa_bsg_rport_reset_stats_s *iocmd =
724	(struct bfa_bsg_rport_reset_stats_s *)cmd;
725	struct bfa_fcs_lport_s *fcs_port;
726	struct bfa_fcs_rport_s *fcs_rport;
727	struct bfa_rport_s *rport;
728	unsigned long flags;
729
730	spin_lock_irqsave(&bfad->bfad_lock, flags);
731	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
732	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
733	if (fcs_port == NULL) {
734	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
735	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
736	goto out;
737	}
738
739	fcs_rport = bfa_fcs_rport_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
740	if (fcs_rport == NULL) {
741	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
742	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
743	goto out;
744	}
745
746	memset((char *)&fcs_rport->stats, 0, sizeof(struct bfa_rport_stats_s));
747	rport = bfa_fcs_rport_get_halrport(rport: fcs_rport);
748	if (rport)
749	memset(&rport->stats, 0, sizeof(rport->stats));
750	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
751	iocmd->status = BFA_STATUS_OK;
752	out:
753	return 0;
754	}
755
756	static int
757	bfad_iocmd_rport_set_speed(struct bfad_s *bfad, void *cmd)
758	{
759	struct bfa_bsg_rport_set_speed_s *iocmd =
760	(struct bfa_bsg_rport_set_speed_s *)cmd;
761	struct bfa_fcs_lport_s *fcs_port;
762	struct bfa_fcs_rport_s *fcs_rport;
763	unsigned long flags;
764
765	spin_lock_irqsave(&bfad->bfad_lock, flags);
766	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
767	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
768	if (fcs_port == NULL) {
769	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
770	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
771	goto out;
772	}
773
774	fcs_rport = bfa_fcs_rport_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
775	if (fcs_rport == NULL) {
776	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
777	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
778	goto out;
779	}
780
781	fcs_rport->rpf.assigned_speed = iocmd->speed;
782	/* Set this speed in f/w only if the RPSC speed is not available */
783	if (fcs_rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN)
784	if (fcs_rport->bfa_rport)
785	bfa_rport_speed(rport: fcs_rport->bfa_rport, speed: iocmd->speed);
786	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
787	iocmd->status = BFA_STATUS_OK;
788	out:
789	return 0;
790	}
791
792	static int
793	bfad_iocmd_vport_get_attr(struct bfad_s *bfad, void *cmd)
794	{
795	struct bfa_fcs_vport_s *fcs_vport;
796	struct bfa_bsg_vport_attr_s *iocmd = (struct bfa_bsg_vport_attr_s *)cmd;
797	unsigned long flags;
798
799	spin_lock_irqsave(&bfad->bfad_lock, flags);
800	fcs_vport = bfa_fcs_vport_lookup(fcs: &bfad->bfa_fcs,
801	vf_id: iocmd->vf_id, vpwwn: iocmd->vpwwn);
802	if (fcs_vport == NULL) {
803	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
804	iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
805	goto out;
806	}
807
808	bfa_fcs_vport_get_attr(vport: fcs_vport, vport_attr: &iocmd->vport_attr);
809	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
810	iocmd->status = BFA_STATUS_OK;
811	out:
812	return 0;
813	}
814
815	static int
816	bfad_iocmd_vport_get_stats(struct bfad_s *bfad, void *cmd)
817	{
818	struct bfa_fcs_vport_s *fcs_vport;
819	struct bfa_bsg_vport_stats_s *iocmd =
820	(struct bfa_bsg_vport_stats_s *)cmd;
821	unsigned long flags;
822
823	spin_lock_irqsave(&bfad->bfad_lock, flags);
824	fcs_vport = bfa_fcs_vport_lookup(fcs: &bfad->bfa_fcs,
825	vf_id: iocmd->vf_id, vpwwn: iocmd->vpwwn);
826	if (fcs_vport == NULL) {
827	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
828	iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
829	goto out;
830	}
831
832	memcpy((void *)&iocmd->vport_stats, (void *)&fcs_vport->vport_stats,
833	sizeof(struct bfa_vport_stats_s));
834	memcpy((void *)&iocmd->vport_stats.port_stats,
835	(void *)&fcs_vport->lport.stats,
836	sizeof(struct bfa_lport_stats_s));
837	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
838	iocmd->status = BFA_STATUS_OK;
839	out:
840	return 0;
841	}
842
843	static int
844	bfad_iocmd_vport_clr_stats(struct bfad_s *bfad, void *cmd)
845	{
846	struct bfa_fcs_vport_s *fcs_vport;
847	struct bfa_bsg_reset_stats_s *iocmd =
848	(struct bfa_bsg_reset_stats_s *)cmd;
849	unsigned long flags;
850
851	spin_lock_irqsave(&bfad->bfad_lock, flags);
852	fcs_vport = bfa_fcs_vport_lookup(fcs: &bfad->bfa_fcs,
853	vf_id: iocmd->vf_id, vpwwn: iocmd->vpwwn);
854	if (fcs_vport == NULL) {
855	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
856	iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
857	goto out;
858	}
859
860	memset(&fcs_vport->vport_stats, 0, sizeof(struct bfa_vport_stats_s));
861	memset(&fcs_vport->lport.stats, 0, sizeof(struct bfa_lport_stats_s));
862	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
863	iocmd->status = BFA_STATUS_OK;
864	out:
865	return 0;
866	}
867
868	static int
869	bfad_iocmd_fabric_get_lports(struct bfad_s *bfad, void *cmd,
870	unsigned int payload_len)
871	{
872	struct bfa_bsg_fabric_get_lports_s *iocmd =
873	(struct bfa_bsg_fabric_get_lports_s *)cmd;
874	bfa_fcs_vf_t *fcs_vf;
875	uint32_t nports = iocmd->nports;
876	unsigned long flags;
877	void *iocmd_bufptr;
878
879	if (nports == 0) {
880	iocmd->status = BFA_STATUS_EINVAL;
881	goto out;
882	}
883
884	if (bfad_chk_iocmd_sz(payload_len,
885	sizeof(struct bfa_bsg_fabric_get_lports_s),
886	sizeof(wwn_t) * iocmd->nports) != BFA_STATUS_OK) {
887	iocmd->status = BFA_STATUS_VERSION_FAIL;
888	goto out;
889	}
890
891	iocmd_bufptr = (char *)iocmd +
892	sizeof(struct bfa_bsg_fabric_get_lports_s);
893
894	spin_lock_irqsave(&bfad->bfad_lock, flags);
895	fcs_vf = bfa_fcs_vf_lookup(fcs: &bfad->bfa_fcs, vf_id: iocmd->vf_id);
896	if (fcs_vf == NULL) {
897	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
898	iocmd->status = BFA_STATUS_UNKNOWN_VFID;
899	goto out;
900	}
901	bfa_fcs_vf_get_ports(vf: fcs_vf, vpwwn: (wwn_t *)iocmd_bufptr, nports: &nports);
902	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
903
904	iocmd->nports = nports;
905	iocmd->status = BFA_STATUS_OK;
906	out:
907	return 0;
908	}
909
910	static int
911	bfad_iocmd_qos_set_bw(struct bfad_s *bfad, void *pcmd)
912	{
913	struct bfa_bsg_qos_bw_s *iocmd = (struct bfa_bsg_qos_bw_s *)pcmd;
914	unsigned long flags;
915
916	spin_lock_irqsave(&bfad->bfad_lock, flags);
917	iocmd->status = bfa_fcport_set_qos_bw(bfa: &bfad->bfa, qos_bw: &iocmd->qos_bw);
918	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
919
920	return 0;
921	}
922
923	static int
924	bfad_iocmd_ratelim(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
925	{
926	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
927	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
928	unsigned long flags;
929
930	spin_lock_irqsave(&bfad->bfad_lock, flags);
931
932	if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
933	(fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
934	iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
935	else {
936	if (cmd == IOCMD_RATELIM_ENABLE)
937	fcport->cfg.ratelimit = BFA_TRUE;
938	else if (cmd == IOCMD_RATELIM_DISABLE)
939	fcport->cfg.ratelimit = BFA_FALSE;
940
941	if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)
942	fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;
943
944	iocmd->status = BFA_STATUS_OK;
945	}
946
947	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
948
949	return 0;
950	}
951
952	static int
953	bfad_iocmd_ratelim_speed(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
954	{
955	struct bfa_bsg_trl_speed_s *iocmd = (struct bfa_bsg_trl_speed_s *)pcmd;
956	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
957	unsigned long flags;
958
959	spin_lock_irqsave(&bfad->bfad_lock, flags);
960
961	/* Auto and speeds greater than the supported speed, are invalid */
962	if ((iocmd->speed == BFA_PORT_SPEED_AUTO) ||
963	(iocmd->speed > fcport->speed_sup)) {
964	iocmd->status = BFA_STATUS_UNSUPP_SPEED;
965	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
966	return 0;
967	}
968
969	if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
970	(fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
971	iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
972	else {
973	fcport->cfg.trl_def_speed = iocmd->speed;
974	iocmd->status = BFA_STATUS_OK;
975	}
976	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
977
978	return 0;
979	}
980
981	static int
982	bfad_iocmd_cfg_fcpim(struct bfad_s *bfad, void *cmd)
983	{
984	struct bfa_bsg_fcpim_s *iocmd = (struct bfa_bsg_fcpim_s *)cmd;
985	unsigned long flags;
986
987	spin_lock_irqsave(&bfad->bfad_lock, flags);
988	bfa_fcpim_path_tov_set(bfa: &bfad->bfa, path_tov: iocmd->param);
989	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
990	iocmd->status = BFA_STATUS_OK;
991	return 0;
992	}
993
994	static int
995	bfad_iocmd_fcpim_get_modstats(struct bfad_s *bfad, void *cmd)
996	{
997	struct bfa_bsg_fcpim_modstats_s *iocmd =
998	(struct bfa_bsg_fcpim_modstats_s *)cmd;
999	struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1000	struct list_head *qe, *qen;
1001	struct bfa_itnim_s *itnim;
1002	unsigned long flags;
1003
1004	spin_lock_irqsave(&bfad->bfad_lock, flags);
1005	/* accumulate IO stats from itnim */
1006	memset((void *)&iocmd->modstats, 0, sizeof(struct bfa_itnim_iostats_s));
1007	list_for_each_safe(qe, qen, &fcpim->itnim_q) {
1008	itnim = (struct bfa_itnim_s *) qe;
1009	bfa_fcpim_add_stats(fcpim_stats: &iocmd->modstats, itnim_stats: &(itnim->stats));
1010	}
1011	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1012	iocmd->status = BFA_STATUS_OK;
1013	return 0;
1014	}
1015
1016	static int
1017	bfad_iocmd_fcpim_clr_modstats(struct bfad_s *bfad, void *cmd)
1018	{
1019	struct bfa_bsg_fcpim_modstatsclr_s *iocmd =
1020	(struct bfa_bsg_fcpim_modstatsclr_s *)cmd;
1021	struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1022	struct list_head *qe, *qen;
1023	struct bfa_itnim_s *itnim;
1024	unsigned long flags;
1025
1026	spin_lock_irqsave(&bfad->bfad_lock, flags);
1027	list_for_each_safe(qe, qen, &fcpim->itnim_q) {
1028	itnim = (struct bfa_itnim_s *) qe;
1029	bfa_itnim_clear_stats(itnim);
1030	}
1031	memset(&fcpim->del_itn_stats, 0,
1032	sizeof(struct bfa_fcpim_del_itn_stats_s));
1033	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1034	iocmd->status = BFA_STATUS_OK;
1035	return 0;
1036	}
1037
1038	static int
1039	bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s *bfad, void *cmd)
1040	{
1041	struct bfa_bsg_fcpim_del_itn_stats_s *iocmd =
1042	(struct bfa_bsg_fcpim_del_itn_stats_s *)cmd;
1043	struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1044	unsigned long flags;
1045
1046	spin_lock_irqsave(&bfad->bfad_lock, flags);
1047	memcpy((void *)&iocmd->modstats, (void *)&fcpim->del_itn_stats,
1048	sizeof(struct bfa_fcpim_del_itn_stats_s));
1049	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1050
1051	iocmd->status = BFA_STATUS_OK;
1052	return 0;
1053	}
1054
1055	static int
1056	bfad_iocmd_itnim_get_attr(struct bfad_s *bfad, void *cmd)
1057	{
1058	struct bfa_bsg_itnim_attr_s *iocmd = (struct bfa_bsg_itnim_attr_s *)cmd;
1059	struct bfa_fcs_lport_s *fcs_port;
1060	unsigned long flags;
1061
1062	spin_lock_irqsave(&bfad->bfad_lock, flags);
1063	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
1064	vf_id: iocmd->vf_id, lpwwn: iocmd->lpwwn);
1065	if (!fcs_port)
1066	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1067	else
1068	iocmd->status = bfa_fcs_itnim_attr_get(port: fcs_port,
1069	rpwwn: iocmd->rpwwn, attr: &iocmd->attr);
1070	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1071	return 0;
1072	}
1073
1074	static int
1075	bfad_iocmd_itnim_get_iostats(struct bfad_s *bfad, void *cmd)
1076	{
1077	struct bfa_bsg_itnim_iostats_s *iocmd =
1078	(struct bfa_bsg_itnim_iostats_s *)cmd;
1079	struct bfa_fcs_lport_s *fcs_port;
1080	struct bfa_fcs_itnim_s *itnim;
1081	unsigned long flags;
1082
1083	spin_lock_irqsave(&bfad->bfad_lock, flags);
1084	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
1085	vf_id: iocmd->vf_id, lpwwn: iocmd->lpwwn);
1086	if (!fcs_port) {
1087	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1088	bfa_trc(bfad, 0);
1089	} else {
1090	itnim = bfa_fcs_itnim_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
1091	if (itnim == NULL)
1092	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1093	else {
1094	iocmd->status = BFA_STATUS_OK;
1095	if (bfa_fcs_itnim_get_halitn(itnim))
1096	memcpy((void *)&iocmd->iostats, (void *)
1097	&(bfa_fcs_itnim_get_halitn(itnim)->stats),
1098	sizeof(struct bfa_itnim_iostats_s));
1099	}
1100	}
1101	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1102	return 0;
1103	}
1104
1105	static int
1106	bfad_iocmd_itnim_reset_stats(struct bfad_s *bfad, void *cmd)
1107	{
1108	struct bfa_bsg_rport_reset_stats_s *iocmd =
1109	(struct bfa_bsg_rport_reset_stats_s *)cmd;
1110	struct bfa_fcs_lport_s *fcs_port;
1111	struct bfa_fcs_itnim_s *itnim;
1112	unsigned long flags;
1113
1114	spin_lock_irqsave(&bfad->bfad_lock, flags);
1115	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
1116	vf_id: iocmd->vf_id, lpwwn: iocmd->pwwn);
1117	if (!fcs_port)
1118	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1119	else {
1120	itnim = bfa_fcs_itnim_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
1121	if (itnim == NULL)
1122	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1123	else {
1124	iocmd->status = BFA_STATUS_OK;
1125	bfa_fcs_itnim_stats_clear(port: fcs_port, rpwwn: iocmd->rpwwn);
1126	bfa_itnim_clear_stats(itnim: bfa_fcs_itnim_get_halitn(itnim));
1127	}
1128	}
1129	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1130
1131	return 0;
1132	}
1133
1134	static int
1135	bfad_iocmd_itnim_get_itnstats(struct bfad_s *bfad, void *cmd)
1136	{
1137	struct bfa_bsg_itnim_itnstats_s *iocmd =
1138	(struct bfa_bsg_itnim_itnstats_s *)cmd;
1139	struct bfa_fcs_lport_s *fcs_port;
1140	struct bfa_fcs_itnim_s *itnim;
1141	unsigned long flags;
1142
1143	spin_lock_irqsave(&bfad->bfad_lock, flags);
1144	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
1145	vf_id: iocmd->vf_id, lpwwn: iocmd->lpwwn);
1146	if (!fcs_port) {
1147	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1148	bfa_trc(bfad, 0);
1149	} else {
1150	itnim = bfa_fcs_itnim_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
1151	if (itnim == NULL)
1152	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1153	else {
1154	iocmd->status = BFA_STATUS_OK;
1155	bfa_fcs_itnim_stats_get(port: fcs_port, rpwwn: iocmd->rpwwn,
1156	stats: &iocmd->itnstats);
1157	}
1158	}
1159	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1160	return 0;
1161	}
1162
1163	static int
1164	bfad_iocmd_fcport_enable(struct bfad_s *bfad, void *cmd)
1165	{
1166	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1167	unsigned long flags;
1168
1169	spin_lock_irqsave(&bfad->bfad_lock, flags);
1170	iocmd->status = bfa_fcport_enable(bfa: &bfad->bfa);
1171	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1172
1173	return 0;
1174	}
1175
1176	static int
1177	bfad_iocmd_fcport_disable(struct bfad_s *bfad, void *cmd)
1178	{
1179	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1180	unsigned long flags;
1181
1182	spin_lock_irqsave(&bfad->bfad_lock, flags);
1183	iocmd->status = bfa_fcport_disable(bfa: &bfad->bfa);
1184	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1185
1186	return 0;
1187	}
1188
1189	static int
1190	bfad_iocmd_ioc_get_pcifn_cfg(struct bfad_s *bfad, void *cmd)
1191	{
1192	struct bfa_bsg_pcifn_cfg_s *iocmd = (struct bfa_bsg_pcifn_cfg_s *)cmd;
1193	struct bfad_hal_comp fcomp;
1194	unsigned long flags;
1195
1196	init_completion(x: &fcomp.comp);
1197	spin_lock_irqsave(&bfad->bfad_lock, flags);
1198	iocmd->status = bfa_ablk_query(ablk: &bfad->bfa.modules.ablk,
1199	ablk_cfg: &iocmd->pcifn_cfg,
1200	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1201	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1202	if (iocmd->status != BFA_STATUS_OK)
1203	goto out;
1204
1205	wait_for_completion(&fcomp.comp);
1206	iocmd->status = fcomp.status;
1207	out:
1208	return 0;
1209	}
1210
1211	static int
1212	bfad_iocmd_pcifn_create(struct bfad_s *bfad, void *cmd)
1213	{
1214	struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1215	struct bfad_hal_comp fcomp;
1216	unsigned long flags;
1217
1218	init_completion(x: &fcomp.comp);
1219	spin_lock_irqsave(&bfad->bfad_lock, flags);
1220	iocmd->status = bfa_ablk_pf_create(ablk: &bfad->bfa.modules.ablk,
1221	pcifn: &iocmd->pcifn_id, port: iocmd->port,
1222	personality: iocmd->pcifn_class, bw_min: iocmd->bw_min,
1223	bw_max: iocmd->bw_max, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1224	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1225	if (iocmd->status != BFA_STATUS_OK)
1226	goto out;
1227
1228	wait_for_completion(&fcomp.comp);
1229	iocmd->status = fcomp.status;
1230	out:
1231	return 0;
1232	}
1233
1234	static int
1235	bfad_iocmd_pcifn_delete(struct bfad_s *bfad, void *cmd)
1236	{
1237	struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1238	struct bfad_hal_comp fcomp;
1239	unsigned long flags;
1240
1241	init_completion(x: &fcomp.comp);
1242	spin_lock_irqsave(&bfad->bfad_lock, flags);
1243	iocmd->status = bfa_ablk_pf_delete(ablk: &bfad->bfa.modules.ablk,
1244	pcifn: iocmd->pcifn_id,
1245	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1246	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1247	if (iocmd->status != BFA_STATUS_OK)
1248	goto out;
1249
1250	wait_for_completion(&fcomp.comp);
1251	iocmd->status = fcomp.status;
1252	out:
1253	return 0;
1254	}
1255
1256	static int
1257	bfad_iocmd_pcifn_bw(struct bfad_s *bfad, void *cmd)
1258	{
1259	struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1260	struct bfad_hal_comp fcomp;
1261	unsigned long flags;
1262
1263	init_completion(x: &fcomp.comp);
1264	spin_lock_irqsave(&bfad->bfad_lock, flags);
1265	iocmd->status = bfa_ablk_pf_update(ablk: &bfad->bfa.modules.ablk,
1266	pcifn: iocmd->pcifn_id, bw_min: iocmd->bw_min,
1267	bw_max: iocmd->bw_max, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1268	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1269	bfa_trc(bfad, iocmd->status);
1270	if (iocmd->status != BFA_STATUS_OK)
1271	goto out;
1272
1273	wait_for_completion(&fcomp.comp);
1274	iocmd->status = fcomp.status;
1275	bfa_trc(bfad, iocmd->status);
1276	out:
1277	return 0;
1278	}
1279
1280	static int
1281	bfad_iocmd_adapter_cfg_mode(struct bfad_s *bfad, void *cmd)
1282	{
1283	struct bfa_bsg_adapter_cfg_mode_s *iocmd =
1284	(struct bfa_bsg_adapter_cfg_mode_s *)cmd;
1285	struct bfad_hal_comp fcomp;
1286	unsigned long flags = 0;
1287
1288	init_completion(x: &fcomp.comp);
1289	spin_lock_irqsave(&bfad->bfad_lock, flags);
1290	iocmd->status = bfa_ablk_adapter_config(ablk: &bfad->bfa.modules.ablk,
1291	mode: iocmd->cfg.mode, max_pf: iocmd->cfg.max_pf,
1292	max_vf: iocmd->cfg.max_vf, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1293	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1294	if (iocmd->status != BFA_STATUS_OK)
1295	goto out;
1296
1297	wait_for_completion(&fcomp.comp);
1298	iocmd->status = fcomp.status;
1299	out:
1300	return 0;
1301	}
1302
1303	static int
1304	bfad_iocmd_port_cfg_mode(struct bfad_s *bfad, void *cmd)
1305	{
1306	struct bfa_bsg_port_cfg_mode_s *iocmd =
1307	(struct bfa_bsg_port_cfg_mode_s *)cmd;
1308	struct bfad_hal_comp fcomp;
1309	unsigned long flags = 0;
1310
1311	init_completion(x: &fcomp.comp);
1312	spin_lock_irqsave(&bfad->bfad_lock, flags);
1313	iocmd->status = bfa_ablk_port_config(ablk: &bfad->bfa.modules.ablk,
1314	port: iocmd->instance, mode: iocmd->cfg.mode,
1315	max_pf: iocmd->cfg.max_pf, max_vf: iocmd->cfg.max_vf,
1316	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1317	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1318	if (iocmd->status != BFA_STATUS_OK)
1319	goto out;
1320
1321	wait_for_completion(&fcomp.comp);
1322	iocmd->status = fcomp.status;
1323	out:
1324	return 0;
1325	}
1326
1327	static int
1328	bfad_iocmd_ablk_optrom(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
1329	{
1330	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
1331	struct bfad_hal_comp fcomp;
1332	unsigned long flags;
1333
1334	init_completion(x: &fcomp.comp);
1335	spin_lock_irqsave(&bfad->bfad_lock, flags);
1336	if (cmd == IOCMD_FLASH_ENABLE_OPTROM)
1337	iocmd->status = bfa_ablk_optrom_en(ablk: &bfad->bfa.modules.ablk,
1338	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1339	else
1340	iocmd->status = bfa_ablk_optrom_dis(ablk: &bfad->bfa.modules.ablk,
1341	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1342	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1343
1344	if (iocmd->status != BFA_STATUS_OK)
1345	goto out;
1346
1347	wait_for_completion(&fcomp.comp);
1348	iocmd->status = fcomp.status;
1349	out:
1350	return 0;
1351	}
1352
1353	static int
1354	bfad_iocmd_faa_query(struct bfad_s *bfad, void *cmd)
1355	{
1356	struct bfa_bsg_faa_attr_s *iocmd = (struct bfa_bsg_faa_attr_s *)cmd;
1357	struct bfad_hal_comp fcomp;
1358	unsigned long flags;
1359
1360	init_completion(x: &fcomp.comp);
1361	iocmd->status = BFA_STATUS_OK;
1362	spin_lock_irqsave(&bfad->bfad_lock, flags);
1363	iocmd->status = bfa_faa_query(bfa: &bfad->bfa, attr: &iocmd->faa_attr,
1364	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1365	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1366
1367	if (iocmd->status != BFA_STATUS_OK)
1368	goto out;
1369
1370	wait_for_completion(&fcomp.comp);
1371	iocmd->status = fcomp.status;
1372	out:
1373	return 0;
1374	}
1375
1376	static int
1377	bfad_iocmd_cee_attr(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1378	{
1379	struct bfa_bsg_cee_attr_s *iocmd =
1380	(struct bfa_bsg_cee_attr_s *)cmd;
1381	void *iocmd_bufptr;
1382	struct bfad_hal_comp cee_comp;
1383	unsigned long flags;
1384
1385	if (bfad_chk_iocmd_sz(payload_len,
1386	sizeof(struct bfa_bsg_cee_attr_s),
1387	sizeof(struct bfa_cee_attr_s)) != BFA_STATUS_OK) {
1388	iocmd->status = BFA_STATUS_VERSION_FAIL;
1389	return 0;
1390	}
1391
1392	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_cee_attr_s);
1393
1394	cee_comp.status = 0;
1395	init_completion(x: &cee_comp.comp);
1396	mutex_lock(&bfad_mutex);
1397	spin_lock_irqsave(&bfad->bfad_lock, flags);
1398	iocmd->status = bfa_cee_get_attr(cee: &bfad->bfa.modules.cee, attr: iocmd_bufptr,
1399	cbfn: bfad_hcb_comp, cbarg: &cee_comp);
1400	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1401	if (iocmd->status != BFA_STATUS_OK) {
1402	mutex_unlock(lock: &bfad_mutex);
1403	bfa_trc(bfad, 0x5555);
1404	goto out;
1405	}
1406	wait_for_completion(&cee_comp.comp);
1407	mutex_unlock(lock: &bfad_mutex);
1408	out:
1409	return 0;
1410	}
1411
1412	static int
1413	bfad_iocmd_cee_get_stats(struct bfad_s *bfad, void *cmd,
1414	unsigned int payload_len)
1415	{
1416	struct bfa_bsg_cee_stats_s *iocmd =
1417	(struct bfa_bsg_cee_stats_s *)cmd;
1418	void *iocmd_bufptr;
1419	struct bfad_hal_comp cee_comp;
1420	unsigned long flags;
1421
1422	if (bfad_chk_iocmd_sz(payload_len,
1423	sizeof(struct bfa_bsg_cee_stats_s),
1424	sizeof(struct bfa_cee_stats_s)) != BFA_STATUS_OK) {
1425	iocmd->status = BFA_STATUS_VERSION_FAIL;
1426	return 0;
1427	}
1428
1429	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_cee_stats_s);
1430
1431	cee_comp.status = 0;
1432	init_completion(x: &cee_comp.comp);
1433	mutex_lock(&bfad_mutex);
1434	spin_lock_irqsave(&bfad->bfad_lock, flags);
1435	iocmd->status = bfa_cee_get_stats(cee: &bfad->bfa.modules.cee, stats: iocmd_bufptr,
1436	cbfn: bfad_hcb_comp, cbarg: &cee_comp);
1437	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1438	if (iocmd->status != BFA_STATUS_OK) {
1439	mutex_unlock(lock: &bfad_mutex);
1440	bfa_trc(bfad, 0x5555);
1441	goto out;
1442	}
1443	wait_for_completion(&cee_comp.comp);
1444	mutex_unlock(lock: &bfad_mutex);
1445	out:
1446	return 0;
1447	}
1448
1449	static int
1450	bfad_iocmd_cee_reset_stats(struct bfad_s *bfad, void *cmd)
1451	{
1452	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1453	unsigned long flags;
1454
1455	spin_lock_irqsave(&bfad->bfad_lock, flags);
1456	iocmd->status = bfa_cee_reset_stats(cee: &bfad->bfa.modules.cee, NULL, NULL);
1457	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1458	if (iocmd->status != BFA_STATUS_OK)
1459	bfa_trc(bfad, 0x5555);
1460	return 0;
1461	}
1462
1463	static int
1464	bfad_iocmd_sfp_media(struct bfad_s *bfad, void *cmd)
1465	{
1466	struct bfa_bsg_sfp_media_s *iocmd = (struct bfa_bsg_sfp_media_s *)cmd;
1467	struct bfad_hal_comp fcomp;
1468	unsigned long flags;
1469
1470	init_completion(x: &fcomp.comp);
1471	spin_lock_irqsave(&bfad->bfad_lock, flags);
1472	iocmd->status = bfa_sfp_media(BFA_SFP_MOD(&bfad->bfa), media: &iocmd->media,
1473	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1474	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1475	bfa_trc(bfad, iocmd->status);
1476	if (iocmd->status != BFA_STATUS_SFP_NOT_READY)
1477	goto out;
1478
1479	wait_for_completion(&fcomp.comp);
1480	iocmd->status = fcomp.status;
1481	out:
1482	return 0;
1483	}
1484
1485	static int
1486	bfad_iocmd_sfp_speed(struct bfad_s *bfad, void *cmd)
1487	{
1488	struct bfa_bsg_sfp_speed_s *iocmd = (struct bfa_bsg_sfp_speed_s *)cmd;
1489	struct bfad_hal_comp fcomp;
1490	unsigned long flags;
1491
1492	init_completion(x: &fcomp.comp);
1493	spin_lock_irqsave(&bfad->bfad_lock, flags);
1494	iocmd->status = bfa_sfp_speed(BFA_SFP_MOD(&bfad->bfa), portspeed: iocmd->speed,
1495	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1496	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1497	bfa_trc(bfad, iocmd->status);
1498	if (iocmd->status != BFA_STATUS_SFP_NOT_READY)
1499	goto out;
1500	wait_for_completion(&fcomp.comp);
1501	iocmd->status = fcomp.status;
1502	out:
1503	return 0;
1504	}
1505
1506	static int
1507	bfad_iocmd_flash_get_attr(struct bfad_s *bfad, void *cmd)
1508	{
1509	struct bfa_bsg_flash_attr_s *iocmd =
1510	(struct bfa_bsg_flash_attr_s *)cmd;
1511	struct bfad_hal_comp fcomp;
1512	unsigned long flags;
1513
1514	init_completion(x: &fcomp.comp);
1515	spin_lock_irqsave(&bfad->bfad_lock, flags);
1516	iocmd->status = bfa_flash_get_attr(BFA_FLASH(&bfad->bfa), attr: &iocmd->attr,
1517	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1518	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1519	if (iocmd->status != BFA_STATUS_OK)
1520	goto out;
1521	wait_for_completion(&fcomp.comp);
1522	iocmd->status = fcomp.status;
1523	out:
1524	return 0;
1525	}
1526
1527	static int
1528	bfad_iocmd_flash_erase_part(struct bfad_s *bfad, void *cmd)
1529	{
1530	struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1531	struct bfad_hal_comp fcomp;
1532	unsigned long flags;
1533
1534	init_completion(x: &fcomp.comp);
1535	spin_lock_irqsave(&bfad->bfad_lock, flags);
1536	iocmd->status = bfa_flash_erase_part(BFA_FLASH(&bfad->bfa), type: iocmd->type,
1537	instance: iocmd->instance, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1538	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1539	if (iocmd->status != BFA_STATUS_OK)
1540	goto out;
1541	wait_for_completion(&fcomp.comp);
1542	iocmd->status = fcomp.status;
1543	out:
1544	return 0;
1545	}
1546
1547	static int
1548	bfad_iocmd_flash_update_part(struct bfad_s *bfad, void *cmd,
1549	unsigned int payload_len)
1550	{
1551	struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1552	void *iocmd_bufptr;
1553	struct bfad_hal_comp fcomp;
1554	unsigned long flags;
1555
1556	if (bfad_chk_iocmd_sz(payload_len,
1557	sizeof(struct bfa_bsg_flash_s),
1558	iocmd->bufsz) != BFA_STATUS_OK) {
1559	iocmd->status = BFA_STATUS_VERSION_FAIL;
1560	return 0;
1561	}
1562
1563	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_flash_s);
1564
1565	init_completion(x: &fcomp.comp);
1566	spin_lock_irqsave(&bfad->bfad_lock, flags);
1567	iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
1568	type: iocmd->type, instance: iocmd->instance, buf: iocmd_bufptr,
1569	len: iocmd->bufsz, offset: 0, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1570	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1571	if (iocmd->status != BFA_STATUS_OK)
1572	goto out;
1573	wait_for_completion(&fcomp.comp);
1574	iocmd->status = fcomp.status;
1575	out:
1576	return 0;
1577	}
1578
1579	static int
1580	bfad_iocmd_flash_read_part(struct bfad_s *bfad, void *cmd,
1581	unsigned int payload_len)
1582	{
1583	struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1584	struct bfad_hal_comp fcomp;
1585	void *iocmd_bufptr;
1586	unsigned long flags;
1587
1588	if (bfad_chk_iocmd_sz(payload_len,
1589	sizeof(struct bfa_bsg_flash_s),
1590	iocmd->bufsz) != BFA_STATUS_OK) {
1591	iocmd->status = BFA_STATUS_VERSION_FAIL;
1592	return 0;
1593	}
1594
1595	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_flash_s);
1596
1597	init_completion(x: &fcomp.comp);
1598	spin_lock_irqsave(&bfad->bfad_lock, flags);
1599	iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa), type: iocmd->type,
1600	instance: iocmd->instance, buf: iocmd_bufptr, len: iocmd->bufsz, offset: 0,
1601	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1602	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1603	if (iocmd->status != BFA_STATUS_OK)
1604	goto out;
1605	wait_for_completion(&fcomp.comp);
1606	iocmd->status = fcomp.status;
1607	out:
1608	return 0;
1609	}
1610
1611	static int
1612	bfad_iocmd_diag_temp(struct bfad_s *bfad, void *cmd)
1613	{
1614	struct bfa_bsg_diag_get_temp_s *iocmd =
1615	(struct bfa_bsg_diag_get_temp_s *)cmd;
1616	struct bfad_hal_comp fcomp;
1617	unsigned long flags;
1618
1619	init_completion(x: &fcomp.comp);
1620	spin_lock_irqsave(&bfad->bfad_lock, flags);
1621	iocmd->status = bfa_diag_tsensor_query(BFA_DIAG_MOD(&bfad->bfa),
1622	result: &iocmd->result, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1623	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1624	bfa_trc(bfad, iocmd->status);
1625	if (iocmd->status != BFA_STATUS_OK)
1626	goto out;
1627	wait_for_completion(&fcomp.comp);
1628	iocmd->status = fcomp.status;
1629	out:
1630	return 0;
1631	}
1632
1633	static int
1634	bfad_iocmd_diag_memtest(struct bfad_s *bfad, void *cmd)
1635	{
1636	struct bfa_bsg_diag_memtest_s *iocmd =
1637	(struct bfa_bsg_diag_memtest_s *)cmd;
1638	struct bfad_hal_comp fcomp;
1639	unsigned long flags;
1640
1641	init_completion(x: &fcomp.comp);
1642	spin_lock_irqsave(&bfad->bfad_lock, flags);
1643	iocmd->status = bfa_diag_memtest(BFA_DIAG_MOD(&bfad->bfa),
1644	memtest: &iocmd->memtest, pattern: iocmd->pat,
1645	result: &iocmd->result, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1646	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1647	bfa_trc(bfad, iocmd->status);
1648	if (iocmd->status != BFA_STATUS_OK)
1649	goto out;
1650	wait_for_completion(&fcomp.comp);
1651	iocmd->status = fcomp.status;
1652	out:
1653	return 0;
1654	}
1655
1656	static int
1657	bfad_iocmd_diag_loopback(struct bfad_s *bfad, void *cmd)
1658	{
1659	struct bfa_bsg_diag_loopback_s *iocmd =
1660	(struct bfa_bsg_diag_loopback_s *)cmd;
1661	struct bfad_hal_comp fcomp;
1662	unsigned long flags;
1663
1664	init_completion(x: &fcomp.comp);
1665	spin_lock_irqsave(&bfad->bfad_lock, flags);
1666	iocmd->status = bfa_fcdiag_loopback(bfa: &bfad->bfa, opmode: iocmd->opmode,
1667	speed: iocmd->speed, lpcnt: iocmd->lpcnt, pat: iocmd->pat,
1668	result: &iocmd->result, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1669	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1670	bfa_trc(bfad, iocmd->status);
1671	if (iocmd->status != BFA_STATUS_OK)
1672	goto out;
1673	wait_for_completion(&fcomp.comp);
1674	iocmd->status = fcomp.status;
1675	out:
1676	return 0;
1677	}
1678
1679	static int
1680	bfad_iocmd_diag_fwping(struct bfad_s *bfad, void *cmd)
1681	{
1682	struct bfa_bsg_diag_fwping_s *iocmd =
1683	(struct bfa_bsg_diag_fwping_s *)cmd;
1684	struct bfad_hal_comp fcomp;
1685	unsigned long flags;
1686
1687	init_completion(x: &fcomp.comp);
1688	spin_lock_irqsave(&bfad->bfad_lock, flags);
1689	iocmd->status = bfa_diag_fwping(BFA_DIAG_MOD(&bfad->bfa), cnt: iocmd->cnt,
1690	pattern: iocmd->pattern, result: &iocmd->result,
1691	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1692	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1693	bfa_trc(bfad, iocmd->status);
1694	if (iocmd->status != BFA_STATUS_OK)
1695	goto out;
1696	bfa_trc(bfad, 0x77771);
1697	wait_for_completion(&fcomp.comp);
1698	iocmd->status = fcomp.status;
1699	out:
1700	return 0;
1701	}
1702
1703	static int
1704	bfad_iocmd_diag_queuetest(struct bfad_s *bfad, void *cmd)
1705	{
1706	struct bfa_bsg_diag_qtest_s *iocmd = (struct bfa_bsg_diag_qtest_s *)cmd;
1707	struct bfad_hal_comp fcomp;
1708	unsigned long flags;
1709
1710	init_completion(x: &fcomp.comp);
1711	spin_lock_irqsave(&bfad->bfad_lock, flags);
1712	iocmd->status = bfa_fcdiag_queuetest(bfa: &bfad->bfa, ignore: iocmd->force,
1713	queue: iocmd->queue, result: &iocmd->result,
1714	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1715	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1716	if (iocmd->status != BFA_STATUS_OK)
1717	goto out;
1718	wait_for_completion(&fcomp.comp);
1719	iocmd->status = fcomp.status;
1720	out:
1721	return 0;
1722	}
1723
1724	static int
1725	bfad_iocmd_diag_sfp(struct bfad_s *bfad, void *cmd)
1726	{
1727	struct bfa_bsg_sfp_show_s *iocmd =
1728	(struct bfa_bsg_sfp_show_s *)cmd;
1729	struct bfad_hal_comp fcomp;
1730	unsigned long flags;
1731
1732	init_completion(x: &fcomp.comp);
1733	spin_lock_irqsave(&bfad->bfad_lock, flags);
1734	iocmd->status = bfa_sfp_show(BFA_SFP_MOD(&bfad->bfa), sfpmem: &iocmd->sfp,
1735	cbfn: bfad_hcb_comp, cbarg: &fcomp);
1736	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1737	bfa_trc(bfad, iocmd->status);
1738	if (iocmd->status != BFA_STATUS_OK)
1739	goto out;
1740	wait_for_completion(&fcomp.comp);
1741	iocmd->status = fcomp.status;
1742	bfa_trc(bfad, iocmd->status);
1743	out:
1744	return 0;
1745	}
1746
1747	static int
1748	bfad_iocmd_diag_led(struct bfad_s *bfad, void *cmd)
1749	{
1750	struct bfa_bsg_diag_led_s *iocmd = (struct bfa_bsg_diag_led_s *)cmd;
1751	unsigned long flags;
1752
1753	spin_lock_irqsave(&bfad->bfad_lock, flags);
1754	iocmd->status = bfa_diag_ledtest(BFA_DIAG_MOD(&bfad->bfa),
1755	ledtest: &iocmd->ledtest);
1756	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1757	return 0;
1758	}
1759
1760	static int
1761	bfad_iocmd_diag_beacon_lport(struct bfad_s *bfad, void *cmd)
1762	{
1763	struct bfa_bsg_diag_beacon_s *iocmd =
1764	(struct bfa_bsg_diag_beacon_s *)cmd;
1765	unsigned long flags;
1766
1767	spin_lock_irqsave(&bfad->bfad_lock, flags);
1768	iocmd->status = bfa_diag_beacon_port(BFA_DIAG_MOD(&bfad->bfa),
1769	beacon: iocmd->beacon, link_e2e_beacon: iocmd->link_e2e_beacon,
1770	sec: iocmd->second);
1771	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1772	return 0;
1773	}
1774
1775	static int
1776	bfad_iocmd_diag_lb_stat(struct bfad_s *bfad, void *cmd)
1777	{
1778	struct bfa_bsg_diag_lb_stat_s *iocmd =
1779	(struct bfa_bsg_diag_lb_stat_s *)cmd;
1780	unsigned long flags;
1781
1782	spin_lock_irqsave(&bfad->bfad_lock, flags);
1783	iocmd->status = bfa_fcdiag_lb_is_running(bfa: &bfad->bfa);
1784	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1785	bfa_trc(bfad, iocmd->status);
1786
1787	return 0;
1788	}
1789
1790	static int
1791	bfad_iocmd_diag_dport_enable(struct bfad_s *bfad, void *pcmd)
1792	{
1793	struct bfa_bsg_dport_enable_s *iocmd =
1794	(struct bfa_bsg_dport_enable_s *)pcmd;
1795	unsigned long flags;
1796	struct bfad_hal_comp fcomp;
1797
1798	init_completion(x: &fcomp.comp);
1799	spin_lock_irqsave(&bfad->bfad_lock, flags);
1800	iocmd->status = bfa_dport_enable(bfa: &bfad->bfa, lpcnt: iocmd->lpcnt,
1801	pat: iocmd->pat, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1802	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1803	if (iocmd->status != BFA_STATUS_OK)
1804	bfa_trc(bfad, iocmd->status);
1805	else {
1806	wait_for_completion(&fcomp.comp);
1807	iocmd->status = fcomp.status;
1808	}
1809	return 0;
1810	}
1811
1812	static int
1813	bfad_iocmd_diag_dport_disable(struct bfad_s *bfad, void *pcmd)
1814	{
1815	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
1816	unsigned long flags;
1817	struct bfad_hal_comp fcomp;
1818
1819	init_completion(x: &fcomp.comp);
1820	spin_lock_irqsave(&bfad->bfad_lock, flags);
1821	iocmd->status = bfa_dport_disable(bfa: &bfad->bfa, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1822	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1823	if (iocmd->status != BFA_STATUS_OK)
1824	bfa_trc(bfad, iocmd->status);
1825	else {
1826	wait_for_completion(&fcomp.comp);
1827	iocmd->status = fcomp.status;
1828	}
1829	return 0;
1830	}
1831
1832	static int
1833	bfad_iocmd_diag_dport_start(struct bfad_s *bfad, void *pcmd)
1834	{
1835	struct bfa_bsg_dport_enable_s *iocmd =
1836	(struct bfa_bsg_dport_enable_s *)pcmd;
1837	unsigned long flags;
1838	struct bfad_hal_comp fcomp;
1839
1840	init_completion(x: &fcomp.comp);
1841	spin_lock_irqsave(&bfad->bfad_lock, flags);
1842	iocmd->status = bfa_dport_start(bfa: &bfad->bfa, lpcnt: iocmd->lpcnt,
1843	pat: iocmd->pat, cbfn: bfad_hcb_comp,
1844	cbarg: &fcomp);
1845	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1846
1847	if (iocmd->status != BFA_STATUS_OK) {
1848	bfa_trc(bfad, iocmd->status);
1849	} else {
1850	wait_for_completion(&fcomp.comp);
1851	iocmd->status = fcomp.status;
1852	}
1853
1854	return 0;
1855	}
1856
1857	static int
1858	bfad_iocmd_diag_dport_show(struct bfad_s *bfad, void *pcmd)
1859	{
1860	struct bfa_bsg_diag_dport_show_s *iocmd =
1861	(struct bfa_bsg_diag_dport_show_s *)pcmd;
1862	unsigned long flags;
1863
1864	spin_lock_irqsave(&bfad->bfad_lock, flags);
1865	iocmd->status = bfa_dport_show(bfa: &bfad->bfa, result: &iocmd->result);
1866	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1867
1868	return 0;
1869	}
1870
1871
1872	static int
1873	bfad_iocmd_phy_get_attr(struct bfad_s *bfad, void *cmd)
1874	{
1875	struct bfa_bsg_phy_attr_s *iocmd =
1876	(struct bfa_bsg_phy_attr_s *)cmd;
1877	struct bfad_hal_comp fcomp;
1878	unsigned long flags;
1879
1880	init_completion(x: &fcomp.comp);
1881	spin_lock_irqsave(&bfad->bfad_lock, flags);
1882	iocmd->status = bfa_phy_get_attr(BFA_PHY(&bfad->bfa), instance: iocmd->instance,
1883	attr: &iocmd->attr, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1884	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1885	if (iocmd->status != BFA_STATUS_OK)
1886	goto out;
1887	wait_for_completion(&fcomp.comp);
1888	iocmd->status = fcomp.status;
1889	out:
1890	return 0;
1891	}
1892
1893	static int
1894	bfad_iocmd_phy_get_stats(struct bfad_s *bfad, void *cmd)
1895	{
1896	struct bfa_bsg_phy_stats_s *iocmd =
1897	(struct bfa_bsg_phy_stats_s *)cmd;
1898	struct bfad_hal_comp fcomp;
1899	unsigned long flags;
1900
1901	init_completion(x: &fcomp.comp);
1902	spin_lock_irqsave(&bfad->bfad_lock, flags);
1903	iocmd->status = bfa_phy_get_stats(BFA_PHY(&bfad->bfa), instance: iocmd->instance,
1904	stats: &iocmd->stats, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1905	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1906	if (iocmd->status != BFA_STATUS_OK)
1907	goto out;
1908	wait_for_completion(&fcomp.comp);
1909	iocmd->status = fcomp.status;
1910	out:
1911	return 0;
1912	}
1913
1914	static int
1915	bfad_iocmd_phy_read(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1916	{
1917	struct bfa_bsg_phy_s *iocmd = (struct bfa_bsg_phy_s *)cmd;
1918	struct bfad_hal_comp fcomp;
1919	void *iocmd_bufptr;
1920	unsigned long flags;
1921
1922	if (bfad_chk_iocmd_sz(payload_len,
1923	sizeof(struct bfa_bsg_phy_s),
1924	iocmd->bufsz) != BFA_STATUS_OK) {
1925	iocmd->status = BFA_STATUS_VERSION_FAIL;
1926	return 0;
1927	}
1928
1929	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_phy_s);
1930	init_completion(x: &fcomp.comp);
1931	spin_lock_irqsave(&bfad->bfad_lock, flags);
1932	iocmd->status = bfa_phy_read(BFA_PHY(&bfad->bfa),
1933	instance: iocmd->instance, buf: iocmd_bufptr, len: iocmd->bufsz,
1934	offset: 0, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1935	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1936	if (iocmd->status != BFA_STATUS_OK)
1937	goto out;
1938	wait_for_completion(&fcomp.comp);
1939	iocmd->status = fcomp.status;
1940	if (iocmd->status != BFA_STATUS_OK)
1941	goto out;
1942	out:
1943	return 0;
1944	}
1945
1946	static int
1947	bfad_iocmd_vhba_query(struct bfad_s *bfad, void *cmd)
1948	{
1949	struct bfa_bsg_vhba_attr_s *iocmd =
1950	(struct bfa_bsg_vhba_attr_s *)cmd;
1951	struct bfa_vhba_attr_s *attr = &iocmd->attr;
1952	unsigned long flags;
1953
1954	spin_lock_irqsave(&bfad->bfad_lock, flags);
1955	attr->pwwn = bfad->bfa.ioc.attr->pwwn;
1956	attr->nwwn = bfad->bfa.ioc.attr->nwwn;
1957	attr->plog_enabled = (bfa_boolean_t)bfad->bfa.plog->plog_enabled;
1958	attr->io_profile = bfa_fcpim_get_io_profile(&bfad->bfa);
1959	attr->path_tov = bfa_fcpim_path_tov_get(bfa: &bfad->bfa);
1960	iocmd->status = BFA_STATUS_OK;
1961	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1962	return 0;
1963	}
1964
1965	static int
1966	bfad_iocmd_phy_update(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1967	{
1968	struct bfa_bsg_phy_s *iocmd = (struct bfa_bsg_phy_s *)cmd;
1969	void *iocmd_bufptr;
1970	struct bfad_hal_comp fcomp;
1971	unsigned long flags;
1972
1973	if (bfad_chk_iocmd_sz(payload_len,
1974	sizeof(struct bfa_bsg_phy_s),
1975	iocmd->bufsz) != BFA_STATUS_OK) {
1976	iocmd->status = BFA_STATUS_VERSION_FAIL;
1977	return 0;
1978	}
1979
1980	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_phy_s);
1981	init_completion(x: &fcomp.comp);
1982	spin_lock_irqsave(&bfad->bfad_lock, flags);
1983	iocmd->status = bfa_phy_update(BFA_PHY(&bfad->bfa),
1984	instance: iocmd->instance, buf: iocmd_bufptr, len: iocmd->bufsz,
1985	offset: 0, cbfn: bfad_hcb_comp, cbarg: &fcomp);
1986	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
1987	if (iocmd->status != BFA_STATUS_OK)
1988	goto out;
1989	wait_for_completion(&fcomp.comp);
1990	iocmd->status = fcomp.status;
1991	out:
1992	return 0;
1993	}
1994
1995	static int
1996	bfad_iocmd_porglog_get(struct bfad_s *bfad, void *cmd)
1997	{
1998	struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;
1999	void *iocmd_bufptr;
2000
2001	if (iocmd->bufsz < sizeof(struct bfa_plog_s)) {
2002	bfa_trc(bfad, sizeof(struct bfa_plog_s));
2003	iocmd->status = BFA_STATUS_EINVAL;
2004	goto out;
2005	}
2006
2007	iocmd->status = BFA_STATUS_OK;
2008	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);
2009	memcpy(iocmd_bufptr, (u8 *) &bfad->plog_buf, sizeof(struct bfa_plog_s));
2010	out:
2011	return 0;
2012	}
2013
2014	#define BFA_DEBUG_FW_CORE_CHUNK_SZ 0x4000U /* 16K chunks for FW dump */
2015	static int
2016	bfad_iocmd_debug_fw_core(struct bfad_s *bfad, void *cmd,
2017	unsigned int payload_len)
2018	{
2019	struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;
2020	void *iocmd_bufptr;
2021	unsigned long flags;
2022	u32 offset;
2023
2024	if (bfad_chk_iocmd_sz(payload_len, sizeof(struct bfa_bsg_debug_s),
2025	BFA_DEBUG_FW_CORE_CHUNK_SZ) != BFA_STATUS_OK) {
2026	iocmd->status = BFA_STATUS_VERSION_FAIL;
2027	return 0;
2028	}
2029
2030	if (iocmd->bufsz < BFA_DEBUG_FW_CORE_CHUNK_SZ ||
2031	!IS_ALIGNED(iocmd->bufsz, sizeof(u16)) ||
2032	!IS_ALIGNED(iocmd->offset, sizeof(u32))) {
2033	bfa_trc(bfad, BFA_DEBUG_FW_CORE_CHUNK_SZ);
2034	iocmd->status = BFA_STATUS_EINVAL;
2035	goto out;
2036	}
2037
2038	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);
2039	spin_lock_irqsave(&bfad->bfad_lock, flags);
2040	offset = iocmd->offset;
2041	iocmd->status = bfa_ioc_debug_fwcore(ioc: &bfad->bfa.ioc, buf: iocmd_bufptr,
2042	offset: &offset, buflen: &iocmd->bufsz);
2043	iocmd->offset = offset;
2044	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2045	out:
2046	return 0;
2047	}
2048
2049	static int
2050	bfad_iocmd_debug_ctl(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2051	{
2052	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2053	unsigned long flags;
2054
2055	if (v_cmd == IOCMD_DEBUG_FW_STATE_CLR) {
2056	spin_lock_irqsave(&bfad->bfad_lock, flags);
2057	bfad->bfa.ioc.dbg_fwsave_once = BFA_TRUE;
2058	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2059	} else if (v_cmd == IOCMD_DEBUG_PORTLOG_CLR)
2060	bfad->plog_buf.head = bfad->plog_buf.tail = 0;
2061	else if (v_cmd == IOCMD_DEBUG_START_DTRC)
2062	bfa_trc_init(trcm: bfad->trcmod);
2063	else if (v_cmd == IOCMD_DEBUG_STOP_DTRC)
2064	bfa_trc_stop(trcm: bfad->trcmod);
2065
2066	iocmd->status = BFA_STATUS_OK;
2067	return 0;
2068	}
2069
2070	static int
2071	bfad_iocmd_porglog_ctl(struct bfad_s *bfad, void *cmd)
2072	{
2073	struct bfa_bsg_portlogctl_s *iocmd = (struct bfa_bsg_portlogctl_s *)cmd;
2074
2075	if (iocmd->ctl == BFA_TRUE)
2076	bfad->plog_buf.plog_enabled = 1;
2077	else
2078	bfad->plog_buf.plog_enabled = 0;
2079
2080	iocmd->status = BFA_STATUS_OK;
2081	return 0;
2082	}
2083
2084	static int
2085	bfad_iocmd_fcpim_cfg_profile(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2086	{
2087	struct bfa_bsg_fcpim_profile_s *iocmd =
2088	(struct bfa_bsg_fcpim_profile_s *)cmd;
2089	unsigned long flags;
2090
2091	spin_lock_irqsave(&bfad->bfad_lock, flags);
2092	if (v_cmd == IOCMD_FCPIM_PROFILE_ON)
2093	iocmd->status = bfa_fcpim_profile_on(bfa: &bfad->bfa, time: ktime_get_real_seconds());
2094	else if (v_cmd == IOCMD_FCPIM_PROFILE_OFF)
2095	iocmd->status = bfa_fcpim_profile_off(bfa: &bfad->bfa);
2096	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2097
2098	return 0;
2099	}
2100
2101	static int
2102	bfad_iocmd_itnim_get_ioprofile(struct bfad_s *bfad, void *cmd)
2103	{
2104	struct bfa_bsg_itnim_ioprofile_s *iocmd =
2105	(struct bfa_bsg_itnim_ioprofile_s *)cmd;
2106	struct bfa_fcs_lport_s *fcs_port;
2107	struct bfa_fcs_itnim_s *itnim;
2108	unsigned long flags;
2109
2110	spin_lock_irqsave(&bfad->bfad_lock, flags);
2111	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs,
2112	vf_id: iocmd->vf_id, lpwwn: iocmd->lpwwn);
2113	if (!fcs_port)
2114	iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
2115	else {
2116	itnim = bfa_fcs_itnim_lookup(port: fcs_port, rpwwn: iocmd->rpwwn);
2117	if (itnim == NULL)
2118	iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
2119	else
2120	iocmd->status = bfa_itnim_get_ioprofile(
2121	itnim: bfa_fcs_itnim_get_halitn(itnim),
2122	ioprofile: &iocmd->ioprofile);
2123	}
2124	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2125	return 0;
2126	}
2127
2128	static int
2129	bfad_iocmd_fcport_get_stats(struct bfad_s *bfad, void *cmd)
2130	{
2131	struct bfa_bsg_fcport_stats_s *iocmd =
2132	(struct bfa_bsg_fcport_stats_s *)cmd;
2133	struct bfad_hal_comp fcomp;
2134	unsigned long flags;
2135	struct bfa_cb_pending_q_s cb_qe;
2136
2137	init_completion(x: &fcomp.comp);
2138	bfa_pending_q_init_status(&cb_qe, bfad_hcb_comp, &fcomp, &iocmd->stats);
2139	spin_lock_irqsave(&bfad->bfad_lock, flags);
2140	iocmd->status = bfa_fcport_get_stats(bfa: &bfad->bfa, cb: &cb_qe);
2141	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2142	if (iocmd->status != BFA_STATUS_OK) {
2143	bfa_trc(bfad, iocmd->status);
2144	goto out;
2145	}
2146	wait_for_completion(&fcomp.comp);
2147	iocmd->status = fcomp.status;
2148	out:
2149	return 0;
2150	}
2151
2152	static int
2153	bfad_iocmd_fcport_reset_stats(struct bfad_s *bfad, void *cmd)
2154	{
2155	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2156	struct bfad_hal_comp fcomp;
2157	unsigned long flags;
2158	struct bfa_cb_pending_q_s cb_qe;
2159
2160	init_completion(x: &fcomp.comp);
2161	bfa_pending_q_init_status(&cb_qe, bfad_hcb_comp, &fcomp, NULL);
2162
2163	spin_lock_irqsave(&bfad->bfad_lock, flags);
2164	iocmd->status = bfa_fcport_clear_stats(bfa: &bfad->bfa, cb: &cb_qe);
2165	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2166	if (iocmd->status != BFA_STATUS_OK) {
2167	bfa_trc(bfad, iocmd->status);
2168	goto out;
2169	}
2170	wait_for_completion(&fcomp.comp);
2171	iocmd->status = fcomp.status;
2172	out:
2173	return 0;
2174	}
2175
2176	static int
2177	bfad_iocmd_boot_cfg(struct bfad_s *bfad, void *cmd)
2178	{
2179	struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
2180	struct bfad_hal_comp fcomp;
2181	unsigned long flags;
2182
2183	init_completion(x: &fcomp.comp);
2184	spin_lock_irqsave(&bfad->bfad_lock, flags);
2185	iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2186	type: BFA_FLASH_PART_BOOT, instance: bfad->bfa.ioc.port_id,
2187	buf: &iocmd->cfg, len: sizeof(struct bfa_boot_cfg_s), offset: 0,
2188	cbfn: bfad_hcb_comp, cbarg: &fcomp);
2189	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2190	if (iocmd->status != BFA_STATUS_OK)
2191	goto out;
2192	wait_for_completion(&fcomp.comp);
2193	iocmd->status = fcomp.status;
2194	out:
2195	return 0;
2196	}
2197
2198	static int
2199	bfad_iocmd_boot_query(struct bfad_s *bfad, void *cmd)
2200	{
2201	struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
2202	struct bfad_hal_comp fcomp;
2203	unsigned long flags;
2204
2205	init_completion(x: &fcomp.comp);
2206	spin_lock_irqsave(&bfad->bfad_lock, flags);
2207	iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2208	type: BFA_FLASH_PART_BOOT, instance: bfad->bfa.ioc.port_id,
2209	buf: &iocmd->cfg, len: sizeof(struct bfa_boot_cfg_s), offset: 0,
2210	cbfn: bfad_hcb_comp, cbarg: &fcomp);
2211	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2212	if (iocmd->status != BFA_STATUS_OK)
2213	goto out;
2214	wait_for_completion(&fcomp.comp);
2215	iocmd->status = fcomp.status;
2216	out:
2217	return 0;
2218	}
2219
2220	static int
2221	bfad_iocmd_preboot_query(struct bfad_s *bfad, void *cmd)
2222	{
2223	struct bfa_bsg_preboot_s *iocmd = (struct bfa_bsg_preboot_s *)cmd;
2224	struct bfi_iocfc_cfgrsp_s *cfgrsp = bfad->bfa.iocfc.cfgrsp;
2225	struct bfa_boot_pbc_s *pbcfg = &iocmd->cfg;
2226	unsigned long flags;
2227
2228	spin_lock_irqsave(&bfad->bfad_lock, flags);
2229	pbcfg->enable = cfgrsp->pbc_cfg.boot_enabled;
2230	pbcfg->nbluns = cfgrsp->pbc_cfg.nbluns;
2231	pbcfg->speed = cfgrsp->pbc_cfg.port_speed;
2232	memcpy(pbcfg->pblun, cfgrsp->pbc_cfg.blun, sizeof(pbcfg->pblun));
2233	iocmd->status = BFA_STATUS_OK;
2234	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2235
2236	return 0;
2237	}
2238
2239	static int
2240	bfad_iocmd_ethboot_cfg(struct bfad_s *bfad, void *cmd)
2241	{
2242	struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
2243	struct bfad_hal_comp fcomp;
2244	unsigned long flags;
2245
2246	init_completion(x: &fcomp.comp);
2247	spin_lock_irqsave(&bfad->bfad_lock, flags);
2248	iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2249	type: BFA_FLASH_PART_PXECFG,
2250	instance: bfad->bfa.ioc.port_id, buf: &iocmd->cfg,
2251	len: sizeof(struct bfa_ethboot_cfg_s), offset: 0,
2252	cbfn: bfad_hcb_comp, cbarg: &fcomp);
2253	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2254	if (iocmd->status != BFA_STATUS_OK)
2255	goto out;
2256	wait_for_completion(&fcomp.comp);
2257	iocmd->status = fcomp.status;
2258	out:
2259	return 0;
2260	}
2261
2262	static int
2263	bfad_iocmd_ethboot_query(struct bfad_s *bfad, void *cmd)
2264	{
2265	struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
2266	struct bfad_hal_comp fcomp;
2267	unsigned long flags;
2268
2269	init_completion(x: &fcomp.comp);
2270	spin_lock_irqsave(&bfad->bfad_lock, flags);
2271	iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2272	type: BFA_FLASH_PART_PXECFG,
2273	instance: bfad->bfa.ioc.port_id, buf: &iocmd->cfg,
2274	len: sizeof(struct bfa_ethboot_cfg_s), offset: 0,
2275	cbfn: bfad_hcb_comp, cbarg: &fcomp);
2276	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2277	if (iocmd->status != BFA_STATUS_OK)
2278	goto out;
2279	wait_for_completion(&fcomp.comp);
2280	iocmd->status = fcomp.status;
2281	out:
2282	return 0;
2283	}
2284
2285	static int
2286	bfad_iocmd_cfg_trunk(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2287	{
2288	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2289	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2290	struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2291	unsigned long flags;
2292
2293	spin_lock_irqsave(&bfad->bfad_lock, flags);
2294
2295	if (bfa_fcport_is_dport(bfa: &bfad->bfa)) {
2296	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2297	return BFA_STATUS_DPORT_ERR;
2298	}
2299
2300	if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) ||
2301	(fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2302	iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2303	else {
2304	if (v_cmd == IOCMD_TRUNK_ENABLE) {
2305	trunk->attr.state = BFA_TRUNK_OFFLINE;
2306	bfa_fcport_disable(bfa: &bfad->bfa);
2307	fcport->cfg.trunked = BFA_TRUE;
2308	} else if (v_cmd == IOCMD_TRUNK_DISABLE) {
2309	trunk->attr.state = BFA_TRUNK_DISABLED;
2310	bfa_fcport_disable(bfa: &bfad->bfa);
2311	fcport->cfg.trunked = BFA_FALSE;
2312	}
2313
2314	if (!bfa_fcport_is_disabled(bfa: &bfad->bfa))
2315	bfa_fcport_enable(bfa: &bfad->bfa);
2316
2317	iocmd->status = BFA_STATUS_OK;
2318	}
2319
2320	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2321
2322	return 0;
2323	}
2324
2325	static int
2326	bfad_iocmd_trunk_get_attr(struct bfad_s *bfad, void *cmd)
2327	{
2328	struct bfa_bsg_trunk_attr_s *iocmd = (struct bfa_bsg_trunk_attr_s *)cmd;
2329	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2330	struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2331	unsigned long flags;
2332
2333	spin_lock_irqsave(&bfad->bfad_lock, flags);
2334	if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) ||
2335	(fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2336	iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2337	else {
2338	memcpy((void *)&iocmd->attr, (void *)&trunk->attr,
2339	sizeof(struct bfa_trunk_attr_s));
2340	iocmd->attr.port_id = bfa_lps_get_base_pid(bfa: &bfad->bfa);
2341	iocmd->status = BFA_STATUS_OK;
2342	}
2343	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2344
2345	return 0;
2346	}
2347
2348	static int
2349	bfad_iocmd_qos(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2350	{
2351	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2352	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2353	unsigned long flags;
2354
2355	spin_lock_irqsave(&bfad->bfad_lock, flags);
2356	if (bfa_ioc_get_type(ioc: &bfad->bfa.ioc) == BFA_IOC_TYPE_FC) {
2357	if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2358	(fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2359	iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2360	else {
2361	if (v_cmd == IOCMD_QOS_ENABLE)
2362	fcport->cfg.qos_enabled = BFA_TRUE;
2363	else if (v_cmd == IOCMD_QOS_DISABLE) {
2364	fcport->cfg.qos_enabled = BFA_FALSE;
2365	fcport->cfg.qos_bw.high = BFA_QOS_BW_HIGH;
2366	fcport->cfg.qos_bw.med = BFA_QOS_BW_MED;
2367	fcport->cfg.qos_bw.low = BFA_QOS_BW_LOW;
2368	}
2369	}
2370	}
2371	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2372
2373	return 0;
2374	}
2375
2376	static int
2377	bfad_iocmd_qos_get_attr(struct bfad_s *bfad, void *cmd)
2378	{
2379	struct bfa_bsg_qos_attr_s *iocmd = (struct bfa_bsg_qos_attr_s *)cmd;
2380	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2381	unsigned long flags;
2382
2383	spin_lock_irqsave(&bfad->bfad_lock, flags);
2384	if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2385	(fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2386	iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2387	else {
2388	iocmd->attr.state = fcport->qos_attr.state;
2389	iocmd->attr.total_bb_cr =
2390	be32_to_cpu(fcport->qos_attr.total_bb_cr);
2391	iocmd->attr.qos_bw.high = fcport->cfg.qos_bw.high;
2392	iocmd->attr.qos_bw.med = fcport->cfg.qos_bw.med;
2393	iocmd->attr.qos_bw.low = fcport->cfg.qos_bw.low;
2394	iocmd->attr.qos_bw_op = fcport->qos_attr.qos_bw_op;
2395	iocmd->status = BFA_STATUS_OK;
2396	}
2397	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2398
2399	return 0;
2400	}
2401
2402	static int
2403	bfad_iocmd_qos_get_vc_attr(struct bfad_s *bfad, void *cmd)
2404	{
2405	struct bfa_bsg_qos_vc_attr_s *iocmd =
2406	(struct bfa_bsg_qos_vc_attr_s *)cmd;
2407	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2408	struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
2409	unsigned long flags;
2410	u32 i = 0;
2411
2412	spin_lock_irqsave(&bfad->bfad_lock, flags);
2413	iocmd->attr.total_vc_count = be16_to_cpu(bfa_vc_attr->total_vc_count);
2414	iocmd->attr.shared_credit = be16_to_cpu(bfa_vc_attr->shared_credit);
2415	iocmd->attr.elp_opmode_flags =
2416	be32_to_cpu(bfa_vc_attr->elp_opmode_flags);
2417
2418	/* Individual VC info */
2419	while (i < iocmd->attr.total_vc_count) {
2420	iocmd->attr.vc_info[i].vc_credit =
2421	bfa_vc_attr->vc_info[i].vc_credit;
2422	iocmd->attr.vc_info[i].borrow_credit =
2423	bfa_vc_attr->vc_info[i].borrow_credit;
2424	iocmd->attr.vc_info[i].priority =
2425	bfa_vc_attr->vc_info[i].priority;
2426	i++;
2427	}
2428	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2429
2430	iocmd->status = BFA_STATUS_OK;
2431	return 0;
2432	}
2433
2434	static int
2435	bfad_iocmd_qos_get_stats(struct bfad_s *bfad, void *cmd)
2436	{
2437	struct bfa_bsg_fcport_stats_s *iocmd =
2438	(struct bfa_bsg_fcport_stats_s *)cmd;
2439	struct bfad_hal_comp fcomp;
2440	unsigned long flags;
2441	struct bfa_cb_pending_q_s cb_qe;
2442	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2443
2444	init_completion(x: &fcomp.comp);
2445	bfa_pending_q_init_status(&cb_qe, bfad_hcb_comp, &fcomp, &iocmd->stats);
2446
2447	spin_lock_irqsave(&bfad->bfad_lock, flags);
2448	WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2449	if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2450	(fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2451	iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2452	else
2453	iocmd->status = bfa_fcport_get_stats(bfa: &bfad->bfa, cb: &cb_qe);
2454	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2455	if (iocmd->status != BFA_STATUS_OK) {
2456	bfa_trc(bfad, iocmd->status);
2457	goto out;
2458	}
2459	wait_for_completion(&fcomp.comp);
2460	iocmd->status = fcomp.status;
2461	out:
2462	return 0;
2463	}
2464
2465	static int
2466	bfad_iocmd_qos_reset_stats(struct bfad_s *bfad, void *cmd)
2467	{
2468	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2469	struct bfad_hal_comp fcomp;
2470	unsigned long flags;
2471	struct bfa_cb_pending_q_s cb_qe;
2472	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2473
2474	init_completion(x: &fcomp.comp);
2475	bfa_pending_q_init_status(&cb_qe, bfad_hcb_comp, &fcomp, NULL);
2476
2477	spin_lock_irqsave(&bfad->bfad_lock, flags);
2478	WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2479	if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2480	(fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2481	iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2482	else
2483	iocmd->status = bfa_fcport_clear_stats(bfa: &bfad->bfa, cb: &cb_qe);
2484	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2485	if (iocmd->status != BFA_STATUS_OK) {
2486	bfa_trc(bfad, iocmd->status);
2487	goto out;
2488	}
2489	wait_for_completion(&fcomp.comp);
2490	iocmd->status = fcomp.status;
2491	out:
2492	return 0;
2493	}
2494
2495	static int
2496	bfad_iocmd_vf_get_stats(struct bfad_s *bfad, void *cmd)
2497	{
2498	struct bfa_bsg_vf_stats_s *iocmd =
2499	(struct bfa_bsg_vf_stats_s *)cmd;
2500	struct bfa_fcs_fabric_s *fcs_vf;
2501	unsigned long flags;
2502
2503	spin_lock_irqsave(&bfad->bfad_lock, flags);
2504	fcs_vf = bfa_fcs_vf_lookup(fcs: &bfad->bfa_fcs, vf_id: iocmd->vf_id);
2505	if (fcs_vf == NULL) {
2506	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2507	iocmd->status = BFA_STATUS_UNKNOWN_VFID;
2508	goto out;
2509	}
2510	memcpy((void *)&iocmd->stats, (void *)&fcs_vf->stats,
2511	sizeof(struct bfa_vf_stats_s));
2512	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2513	iocmd->status = BFA_STATUS_OK;
2514	out:
2515	return 0;
2516	}
2517
2518	static int
2519	bfad_iocmd_vf_clr_stats(struct bfad_s *bfad, void *cmd)
2520	{
2521	struct bfa_bsg_vf_reset_stats_s *iocmd =
2522	(struct bfa_bsg_vf_reset_stats_s *)cmd;
2523	struct bfa_fcs_fabric_s *fcs_vf;
2524	unsigned long flags;
2525
2526	spin_lock_irqsave(&bfad->bfad_lock, flags);
2527	fcs_vf = bfa_fcs_vf_lookup(fcs: &bfad->bfa_fcs, vf_id: iocmd->vf_id);
2528	if (fcs_vf == NULL) {
2529	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2530	iocmd->status = BFA_STATUS_UNKNOWN_VFID;
2531	goto out;
2532	}
2533	memset((void *)&fcs_vf->stats, 0, sizeof(struct bfa_vf_stats_s));
2534	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2535	iocmd->status = BFA_STATUS_OK;
2536	out:
2537	return 0;
2538	}
2539
2540	/*
2541	* Set the SCSI device sdev_bflags - sdev_bflags are used by the
2542	* SCSI mid-layer to choose LUN Scanning mode REPORT_LUNS vs. Sequential Scan
2543	*
2544	* Internally iterates over all the ITNIM's part of the im_port & sets the
2545	* sdev_bflags for the scsi_device associated with LUN #0.
2546	*/
2547	static void bfad_reset_sdev_bflags(struct bfad_im_port_s *im_port,
2548	int lunmask_cfg)
2549	{
2550	const blist_flags_t scan_flags = BLIST_NOREPORTLUN | BLIST_SPARSELUN;
2551	struct bfad_itnim_s *itnim;
2552	struct scsi_device *sdev;
2553	unsigned long flags;
2554
2555	spin_lock_irqsave(im_port->shost->host_lock, flags);
2556	list_for_each_entry(itnim, &im_port->itnim_mapped_list, list_entry) {
2557	sdev = __scsi_device_lookup(im_port->shost, itnim->channel,
2558	itnim->scsi_tgt_id, 0);
2559	if (sdev) {
2560	if (lunmask_cfg == BFA_TRUE)
2561	sdev->sdev_bflags |= scan_flags;
2562	else
2563	sdev->sdev_bflags &= ~scan_flags;
2564	}
2565	}
2566	spin_unlock_irqrestore(lock: im_port->shost->host_lock, flags);
2567	}
2568
2569	/* Function to reset the LUN SCAN mode */
2570	static void
2571	bfad_iocmd_lunmask_reset_lunscan_mode(struct bfad_s *bfad, int lunmask_cfg)
2572	{
2573	struct bfad_im_port_s *pport_im = bfad->pport.im_port;
2574	struct bfad_vport_s *vport = NULL;
2575
2576	/* Set the scsi device LUN SCAN flags for base port */
2577	bfad_reset_sdev_bflags(im_port: pport_im, lunmask_cfg);
2578
2579	/* Set the scsi device LUN SCAN flags for the vports */
2580	list_for_each_entry(vport, &bfad->vport_list, list_entry)
2581	bfad_reset_sdev_bflags(im_port: vport->drv_port.im_port, lunmask_cfg);
2582	}
2583
2584	static int
2585	bfad_iocmd_lunmask(struct bfad_s *bfad, void *pcmd, unsigned int v_cmd)
2586	{
2587	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
2588	unsigned long flags;
2589
2590	spin_lock_irqsave(&bfad->bfad_lock, flags);
2591	if (v_cmd == IOCMD_FCPIM_LUNMASK_ENABLE) {
2592	iocmd->status = bfa_fcpim_lunmask_update(bfa: &bfad->bfa, on_off: BFA_TRUE);
2593	/* Set the LUN Scanning mode to be Sequential scan */
2594	if (iocmd->status == BFA_STATUS_OK)
2595	bfad_iocmd_lunmask_reset_lunscan_mode(bfad, lunmask_cfg: BFA_TRUE);
2596	} else if (v_cmd == IOCMD_FCPIM_LUNMASK_DISABLE) {
2597	iocmd->status = bfa_fcpim_lunmask_update(bfa: &bfad->bfa, on_off: BFA_FALSE);
2598	/* Set the LUN Scanning mode to default REPORT_LUNS scan */
2599	if (iocmd->status == BFA_STATUS_OK)
2600	bfad_iocmd_lunmask_reset_lunscan_mode(bfad, lunmask_cfg: BFA_FALSE);
2601	} else if (v_cmd == IOCMD_FCPIM_LUNMASK_CLEAR)
2602	iocmd->status = bfa_fcpim_lunmask_clear(bfa: &bfad->bfa);
2603	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2604	return 0;
2605	}
2606
2607	static int
2608	bfad_iocmd_fcpim_lunmask_query(struct bfad_s *bfad, void *cmd)
2609	{
2610	struct bfa_bsg_fcpim_lunmask_query_s *iocmd =
2611	(struct bfa_bsg_fcpim_lunmask_query_s *)cmd;
2612	struct bfa_lunmask_cfg_s *lun_mask = &iocmd->lun_mask;
2613	unsigned long flags;
2614
2615	spin_lock_irqsave(&bfad->bfad_lock, flags);
2616	iocmd->status = bfa_fcpim_lunmask_query(bfa: &bfad->bfa, buf: lun_mask);
2617	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2618	return 0;
2619	}
2620
2621	static int
2622	bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2623	{
2624	struct bfa_bsg_fcpim_lunmask_s *iocmd =
2625	(struct bfa_bsg_fcpim_lunmask_s *)cmd;
2626	unsigned long flags;
2627
2628	spin_lock_irqsave(&bfad->bfad_lock, flags);
2629	if (v_cmd == IOCMD_FCPIM_LUNMASK_ADD)
2630	iocmd->status = bfa_fcpim_lunmask_add(bfa: &bfad->bfa, vf_id: iocmd->vf_id,
2631	pwwn: &iocmd->pwwn, rpwwn: iocmd->rpwwn, lun: iocmd->lun);
2632	else if (v_cmd == IOCMD_FCPIM_LUNMASK_DELETE)
2633	iocmd->status = bfa_fcpim_lunmask_delete(bfa: &bfad->bfa,
2634	vf_id: iocmd->vf_id, pwwn: &iocmd->pwwn,
2635	rpwwn: iocmd->rpwwn, lun: iocmd->lun);
2636	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2637	return 0;
2638	}
2639
2640	static int
2641	bfad_iocmd_fcpim_throttle_query(struct bfad_s *bfad, void *cmd)
2642	{
2643	struct bfa_bsg_fcpim_throttle_s *iocmd =
2644	(struct bfa_bsg_fcpim_throttle_s *)cmd;
2645	unsigned long flags;
2646
2647	spin_lock_irqsave(&bfad->bfad_lock, flags);
2648	iocmd->status = bfa_fcpim_throttle_get(bfa: &bfad->bfa,
2649	buf: (void *)&iocmd->throttle);
2650	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2651
2652	return 0;
2653	}
2654
2655	static int
2656	bfad_iocmd_fcpim_throttle_set(struct bfad_s *bfad, void *cmd)
2657	{
2658	struct bfa_bsg_fcpim_throttle_s *iocmd =
2659	(struct bfa_bsg_fcpim_throttle_s *)cmd;
2660	unsigned long flags;
2661
2662	spin_lock_irqsave(&bfad->bfad_lock, flags);
2663	iocmd->status = bfa_fcpim_throttle_set(bfa: &bfad->bfa,
2664	value: iocmd->throttle.cfg_value);
2665	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2666
2667	return 0;
2668	}
2669
2670	static int
2671	bfad_iocmd_tfru_read(struct bfad_s *bfad, void *cmd)
2672	{
2673	struct bfa_bsg_tfru_s *iocmd =
2674	(struct bfa_bsg_tfru_s *)cmd;
2675	struct bfad_hal_comp fcomp;
2676	unsigned long flags = 0;
2677
2678	init_completion(x: &fcomp.comp);
2679	spin_lock_irqsave(&bfad->bfad_lock, flags);
2680	iocmd->status = bfa_tfru_read(BFA_FRU(&bfad->bfa),
2681	buf: &iocmd->data, len: iocmd->len, offset: iocmd->offset,
2682	cbfn: bfad_hcb_comp, cbarg: &fcomp);
2683	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2684	if (iocmd->status == BFA_STATUS_OK) {
2685	wait_for_completion(&fcomp.comp);
2686	iocmd->status = fcomp.status;
2687	}
2688
2689	return 0;
2690	}
2691
2692	static int
2693	bfad_iocmd_tfru_write(struct bfad_s *bfad, void *cmd)
2694	{
2695	struct bfa_bsg_tfru_s *iocmd =
2696	(struct bfa_bsg_tfru_s *)cmd;
2697	struct bfad_hal_comp fcomp;
2698	unsigned long flags = 0;
2699
2700	init_completion(x: &fcomp.comp);
2701	spin_lock_irqsave(&bfad->bfad_lock, flags);
2702	iocmd->status = bfa_tfru_write(BFA_FRU(&bfad->bfa),
2703	buf: &iocmd->data, len: iocmd->len, offset: iocmd->offset,
2704	cbfn: bfad_hcb_comp, cbarg: &fcomp);
2705	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2706	if (iocmd->status == BFA_STATUS_OK) {
2707	wait_for_completion(&fcomp.comp);
2708	iocmd->status = fcomp.status;
2709	}
2710
2711	return 0;
2712	}
2713
2714	static int
2715	bfad_iocmd_fruvpd_read(struct bfad_s *bfad, void *cmd)
2716	{
2717	struct bfa_bsg_fruvpd_s *iocmd =
2718	(struct bfa_bsg_fruvpd_s *)cmd;
2719	struct bfad_hal_comp fcomp;
2720	unsigned long flags = 0;
2721
2722	init_completion(x: &fcomp.comp);
2723	spin_lock_irqsave(&bfad->bfad_lock, flags);
2724	iocmd->status = bfa_fruvpd_read(BFA_FRU(&bfad->bfa),
2725	buf: &iocmd->data, len: iocmd->len, offset: iocmd->offset,
2726	cbfn: bfad_hcb_comp, cbarg: &fcomp);
2727	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2728	if (iocmd->status == BFA_STATUS_OK) {
2729	wait_for_completion(&fcomp.comp);
2730	iocmd->status = fcomp.status;
2731	}
2732
2733	return 0;
2734	}
2735
2736	static int
2737	bfad_iocmd_fruvpd_update(struct bfad_s *bfad, void *cmd)
2738	{
2739	struct bfa_bsg_fruvpd_s *iocmd =
2740	(struct bfa_bsg_fruvpd_s *)cmd;
2741	struct bfad_hal_comp fcomp;
2742	unsigned long flags = 0;
2743
2744	init_completion(x: &fcomp.comp);
2745	spin_lock_irqsave(&bfad->bfad_lock, flags);
2746	iocmd->status = bfa_fruvpd_update(BFA_FRU(&bfad->bfa),
2747	buf: &iocmd->data, len: iocmd->len, offset: iocmd->offset,
2748	cbfn: bfad_hcb_comp, cbarg: &fcomp, trfr_cmpl: iocmd->trfr_cmpl);
2749	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2750	if (iocmd->status == BFA_STATUS_OK) {
2751	wait_for_completion(&fcomp.comp);
2752	iocmd->status = fcomp.status;
2753	}
2754
2755	return 0;
2756	}
2757
2758	static int
2759	bfad_iocmd_fruvpd_get_max_size(struct bfad_s *bfad, void *cmd)
2760	{
2761	struct bfa_bsg_fruvpd_max_size_s *iocmd =
2762	(struct bfa_bsg_fruvpd_max_size_s *)cmd;
2763	unsigned long flags = 0;
2764
2765	spin_lock_irqsave(&bfad->bfad_lock, flags);
2766	iocmd->status = bfa_fruvpd_get_max_size(BFA_FRU(&bfad->bfa),
2767	max_size: &iocmd->max_size);
2768	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
2769
2770	return 0;
2771	}
2772
2773	static int
2774	bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
2775	unsigned int payload_len)
2776	{
2777	int rc = -EINVAL;
2778
2779	switch (cmd) {
2780	case IOCMD_IOC_ENABLE:
2781	rc = bfad_iocmd_ioc_enable(bfad, cmd: iocmd);
2782	break;
2783	case IOCMD_IOC_DISABLE:
2784	rc = bfad_iocmd_ioc_disable(bfad, cmd: iocmd);
2785	break;
2786	case IOCMD_IOC_GET_INFO:
2787	rc = bfad_iocmd_ioc_get_info(bfad, cmd: iocmd);
2788	break;
2789	case IOCMD_IOC_GET_ATTR:
2790	rc = bfad_iocmd_ioc_get_attr(bfad, cmd: iocmd);
2791	break;
2792	case IOCMD_IOC_GET_STATS:
2793	rc = bfad_iocmd_ioc_get_stats(bfad, cmd: iocmd);
2794	break;
2795	case IOCMD_IOC_GET_FWSTATS:
2796	rc = bfad_iocmd_ioc_get_fwstats(bfad, cmd: iocmd, payload_len);
2797	break;
2798	case IOCMD_IOC_RESET_STATS:
2799	case IOCMD_IOC_RESET_FWSTATS:
2800	rc = bfad_iocmd_ioc_reset_stats(bfad, cmd: iocmd, v_cmd: cmd);
2801	break;
2802	case IOCMD_IOC_SET_ADAPTER_NAME:
2803	case IOCMD_IOC_SET_PORT_NAME:
2804	rc = bfad_iocmd_ioc_set_name(bfad, cmd: iocmd, v_cmd: cmd);
2805	break;
2806	case IOCMD_IOCFC_GET_ATTR:
2807	rc = bfad_iocmd_iocfc_get_attr(bfad, cmd: iocmd);
2808	break;
2809	case IOCMD_IOCFC_SET_INTR:
2810	rc = bfad_iocmd_iocfc_set_intr(bfad, cmd: iocmd);
2811	break;
2812	case IOCMD_PORT_ENABLE:
2813	rc = bfad_iocmd_port_enable(bfad, cmd: iocmd);
2814	break;
2815	case IOCMD_PORT_DISABLE:
2816	rc = bfad_iocmd_port_disable(bfad, cmd: iocmd);
2817	break;
2818	case IOCMD_PORT_GET_ATTR:
2819	rc = bfad_iocmd_port_get_attr(bfad, cmd: iocmd);
2820	break;
2821	case IOCMD_PORT_GET_STATS:
2822	rc = bfad_iocmd_port_get_stats(bfad, cmd: iocmd, payload_len);
2823	break;
2824	case IOCMD_PORT_RESET_STATS:
2825	rc = bfad_iocmd_port_reset_stats(bfad, cmd: iocmd);
2826	break;
2827	case IOCMD_PORT_CFG_TOPO:
2828	case IOCMD_PORT_CFG_SPEED:
2829	case IOCMD_PORT_CFG_ALPA:
2830	case IOCMD_PORT_CLR_ALPA:
2831	rc = bfad_iocmd_set_port_cfg(bfad, iocmd, v_cmd: cmd);
2832	break;
2833	case IOCMD_PORT_CFG_MAXFRSZ:
2834	rc = bfad_iocmd_port_cfg_maxfrsize(bfad, cmd: iocmd);
2835	break;
2836	case IOCMD_PORT_BBCR_ENABLE:
2837	case IOCMD_PORT_BBCR_DISABLE:
2838	rc = bfad_iocmd_port_cfg_bbcr(bfad, cmd, pcmd: iocmd);
2839	break;
2840	case IOCMD_PORT_BBCR_GET_ATTR:
2841	rc = bfad_iocmd_port_get_bbcr_attr(bfad, pcmd: iocmd);
2842	break;
2843	case IOCMD_LPORT_GET_ATTR:
2844	rc = bfad_iocmd_lport_get_attr(bfad, cmd: iocmd);
2845	break;
2846	case IOCMD_LPORT_GET_STATS:
2847	rc = bfad_iocmd_lport_get_stats(bfad, cmd: iocmd);
2848	break;
2849	case IOCMD_LPORT_RESET_STATS:
2850	rc = bfad_iocmd_lport_reset_stats(bfad, cmd: iocmd);
2851	break;
2852	case IOCMD_LPORT_GET_IOSTATS:
2853	rc = bfad_iocmd_lport_get_iostats(bfad, cmd: iocmd);
2854	break;
2855	case IOCMD_LPORT_GET_RPORTS:
2856	rc = bfad_iocmd_lport_get_rports(bfad, cmd: iocmd, payload_len);
2857	break;
2858	case IOCMD_RPORT_GET_ATTR:
2859	rc = bfad_iocmd_rport_get_attr(bfad, cmd: iocmd);
2860	break;
2861	case IOCMD_RPORT_GET_ADDR:
2862	rc = bfad_iocmd_rport_get_addr(bfad, cmd: iocmd);
2863	break;
2864	case IOCMD_RPORT_GET_STATS:
2865	rc = bfad_iocmd_rport_get_stats(bfad, cmd: iocmd);
2866	break;
2867	case IOCMD_RPORT_RESET_STATS:
2868	rc = bfad_iocmd_rport_clr_stats(bfad, cmd: iocmd);
2869	break;
2870	case IOCMD_RPORT_SET_SPEED:
2871	rc = bfad_iocmd_rport_set_speed(bfad, cmd: iocmd);
2872	break;
2873	case IOCMD_VPORT_GET_ATTR:
2874	rc = bfad_iocmd_vport_get_attr(bfad, cmd: iocmd);
2875	break;
2876	case IOCMD_VPORT_GET_STATS:
2877	rc = bfad_iocmd_vport_get_stats(bfad, cmd: iocmd);
2878	break;
2879	case IOCMD_VPORT_RESET_STATS:
2880	rc = bfad_iocmd_vport_clr_stats(bfad, cmd: iocmd);
2881	break;
2882	case IOCMD_FABRIC_GET_LPORTS:
2883	rc = bfad_iocmd_fabric_get_lports(bfad, cmd: iocmd, payload_len);
2884	break;
2885	case IOCMD_RATELIM_ENABLE:
2886	case IOCMD_RATELIM_DISABLE:
2887	rc = bfad_iocmd_ratelim(bfad, cmd, pcmd: iocmd);
2888	break;
2889	case IOCMD_RATELIM_DEF_SPEED:
2890	rc = bfad_iocmd_ratelim_speed(bfad, cmd, pcmd: iocmd);
2891	break;
2892	case IOCMD_FCPIM_FAILOVER:
2893	rc = bfad_iocmd_cfg_fcpim(bfad, cmd: iocmd);
2894	break;
2895	case IOCMD_FCPIM_MODSTATS:
2896	rc = bfad_iocmd_fcpim_get_modstats(bfad, cmd: iocmd);
2897	break;
2898	case IOCMD_FCPIM_MODSTATSCLR:
2899	rc = bfad_iocmd_fcpim_clr_modstats(bfad, cmd: iocmd);
2900	break;
2901	case IOCMD_FCPIM_DEL_ITN_STATS:
2902	rc = bfad_iocmd_fcpim_get_del_itn_stats(bfad, cmd: iocmd);
2903	break;
2904	case IOCMD_ITNIM_GET_ATTR:
2905	rc = bfad_iocmd_itnim_get_attr(bfad, cmd: iocmd);
2906	break;
2907	case IOCMD_ITNIM_GET_IOSTATS:
2908	rc = bfad_iocmd_itnim_get_iostats(bfad, cmd: iocmd);
2909	break;
2910	case IOCMD_ITNIM_RESET_STATS:
2911	rc = bfad_iocmd_itnim_reset_stats(bfad, cmd: iocmd);
2912	break;
2913	case IOCMD_ITNIM_GET_ITNSTATS:
2914	rc = bfad_iocmd_itnim_get_itnstats(bfad, cmd: iocmd);
2915	break;
2916	case IOCMD_FCPORT_ENABLE:
2917	rc = bfad_iocmd_fcport_enable(bfad, cmd: iocmd);
2918	break;
2919	case IOCMD_FCPORT_DISABLE:
2920	rc = bfad_iocmd_fcport_disable(bfad, cmd: iocmd);
2921	break;
2922	case IOCMD_IOC_PCIFN_CFG:
2923	rc = bfad_iocmd_ioc_get_pcifn_cfg(bfad, cmd: iocmd);
2924	break;
2925	case IOCMD_IOC_FW_SIG_INV:
2926	rc = bfad_iocmd_ioc_fw_sig_inv(bfad, cmd: iocmd);
2927	break;
2928	case IOCMD_PCIFN_CREATE:
2929	rc = bfad_iocmd_pcifn_create(bfad, cmd: iocmd);
2930	break;
2931	case IOCMD_PCIFN_DELETE:
2932	rc = bfad_iocmd_pcifn_delete(bfad, cmd: iocmd);
2933	break;
2934	case IOCMD_PCIFN_BW:
2935	rc = bfad_iocmd_pcifn_bw(bfad, cmd: iocmd);
2936	break;
2937	case IOCMD_ADAPTER_CFG_MODE:
2938	rc = bfad_iocmd_adapter_cfg_mode(bfad, cmd: iocmd);
2939	break;
2940	case IOCMD_PORT_CFG_MODE:
2941	rc = bfad_iocmd_port_cfg_mode(bfad, cmd: iocmd);
2942	break;
2943	case IOCMD_FLASH_ENABLE_OPTROM:
2944	case IOCMD_FLASH_DISABLE_OPTROM:
2945	rc = bfad_iocmd_ablk_optrom(bfad, cmd, pcmd: iocmd);
2946	break;
2947	case IOCMD_FAA_QUERY:
2948	rc = bfad_iocmd_faa_query(bfad, cmd: iocmd);
2949	break;
2950	case IOCMD_CEE_GET_ATTR:
2951	rc = bfad_iocmd_cee_attr(bfad, cmd: iocmd, payload_len);
2952	break;
2953	case IOCMD_CEE_GET_STATS:
2954	rc = bfad_iocmd_cee_get_stats(bfad, cmd: iocmd, payload_len);
2955	break;
2956	case IOCMD_CEE_RESET_STATS:
2957	rc = bfad_iocmd_cee_reset_stats(bfad, cmd: iocmd);
2958	break;
2959	case IOCMD_SFP_MEDIA:
2960	rc = bfad_iocmd_sfp_media(bfad, cmd: iocmd);
2961	break;
2962	case IOCMD_SFP_SPEED:
2963	rc = bfad_iocmd_sfp_speed(bfad, cmd: iocmd);
2964	break;
2965	case IOCMD_FLASH_GET_ATTR:
2966	rc = bfad_iocmd_flash_get_attr(bfad, cmd: iocmd);
2967	break;
2968	case IOCMD_FLASH_ERASE_PART:
2969	rc = bfad_iocmd_flash_erase_part(bfad, cmd: iocmd);
2970	break;
2971	case IOCMD_FLASH_UPDATE_PART:
2972	rc = bfad_iocmd_flash_update_part(bfad, cmd: iocmd, payload_len);
2973	break;
2974	case IOCMD_FLASH_READ_PART:
2975	rc = bfad_iocmd_flash_read_part(bfad, cmd: iocmd, payload_len);
2976	break;
2977	case IOCMD_DIAG_TEMP:
2978	rc = bfad_iocmd_diag_temp(bfad, cmd: iocmd);
2979	break;
2980	case IOCMD_DIAG_MEMTEST:
2981	rc = bfad_iocmd_diag_memtest(bfad, cmd: iocmd);
2982	break;
2983	case IOCMD_DIAG_LOOPBACK:
2984	rc = bfad_iocmd_diag_loopback(bfad, cmd: iocmd);
2985	break;
2986	case IOCMD_DIAG_FWPING:
2987	rc = bfad_iocmd_diag_fwping(bfad, cmd: iocmd);
2988	break;
2989	case IOCMD_DIAG_QUEUETEST:
2990	rc = bfad_iocmd_diag_queuetest(bfad, cmd: iocmd);
2991	break;
2992	case IOCMD_DIAG_SFP:
2993	rc = bfad_iocmd_diag_sfp(bfad, cmd: iocmd);
2994	break;
2995	case IOCMD_DIAG_LED:
2996	rc = bfad_iocmd_diag_led(bfad, cmd: iocmd);
2997	break;
2998	case IOCMD_DIAG_BEACON_LPORT:
2999	rc = bfad_iocmd_diag_beacon_lport(bfad, cmd: iocmd);
3000	break;
3001	case IOCMD_DIAG_LB_STAT:
3002	rc = bfad_iocmd_diag_lb_stat(bfad, cmd: iocmd);
3003	break;
3004	case IOCMD_DIAG_DPORT_ENABLE:
3005	rc = bfad_iocmd_diag_dport_enable(bfad, pcmd: iocmd);
3006	break;
3007	case IOCMD_DIAG_DPORT_DISABLE:
3008	rc = bfad_iocmd_diag_dport_disable(bfad, pcmd: iocmd);
3009	break;
3010	case IOCMD_DIAG_DPORT_SHOW:
3011	rc = bfad_iocmd_diag_dport_show(bfad, pcmd: iocmd);
3012	break;
3013	case IOCMD_DIAG_DPORT_START:
3014	rc = bfad_iocmd_diag_dport_start(bfad, pcmd: iocmd);
3015	break;
3016	case IOCMD_PHY_GET_ATTR:
3017	rc = bfad_iocmd_phy_get_attr(bfad, cmd: iocmd);
3018	break;
3019	case IOCMD_PHY_GET_STATS:
3020	rc = bfad_iocmd_phy_get_stats(bfad, cmd: iocmd);
3021	break;
3022	case IOCMD_PHY_UPDATE_FW:
3023	rc = bfad_iocmd_phy_update(bfad, cmd: iocmd, payload_len);
3024	break;
3025	case IOCMD_PHY_READ_FW:
3026	rc = bfad_iocmd_phy_read(bfad, cmd: iocmd, payload_len);
3027	break;
3028	case IOCMD_VHBA_QUERY:
3029	rc = bfad_iocmd_vhba_query(bfad, cmd: iocmd);
3030	break;
3031	case IOCMD_DEBUG_PORTLOG:
3032	rc = bfad_iocmd_porglog_get(bfad, cmd: iocmd);
3033	break;
3034	case IOCMD_DEBUG_FW_CORE:
3035	rc = bfad_iocmd_debug_fw_core(bfad, cmd: iocmd, payload_len);
3036	break;
3037	case IOCMD_DEBUG_FW_STATE_CLR:
3038	case IOCMD_DEBUG_PORTLOG_CLR:
3039	case IOCMD_DEBUG_START_DTRC:
3040	case IOCMD_DEBUG_STOP_DTRC:
3041	rc = bfad_iocmd_debug_ctl(bfad, cmd: iocmd, v_cmd: cmd);
3042	break;
3043	case IOCMD_DEBUG_PORTLOG_CTL:
3044	rc = bfad_iocmd_porglog_ctl(bfad, cmd: iocmd);
3045	break;
3046	case IOCMD_FCPIM_PROFILE_ON:
3047	case IOCMD_FCPIM_PROFILE_OFF:
3048	rc = bfad_iocmd_fcpim_cfg_profile(bfad, cmd: iocmd, v_cmd: cmd);
3049	break;
3050	case IOCMD_ITNIM_GET_IOPROFILE:
3051	rc = bfad_iocmd_itnim_get_ioprofile(bfad, cmd: iocmd);
3052	break;
3053	case IOCMD_FCPORT_GET_STATS:
3054	rc = bfad_iocmd_fcport_get_stats(bfad, cmd: iocmd);
3055	break;
3056	case IOCMD_FCPORT_RESET_STATS:
3057	rc = bfad_iocmd_fcport_reset_stats(bfad, cmd: iocmd);
3058	break;
3059	case IOCMD_BOOT_CFG:
3060	rc = bfad_iocmd_boot_cfg(bfad, cmd: iocmd);
3061	break;
3062	case IOCMD_BOOT_QUERY:
3063	rc = bfad_iocmd_boot_query(bfad, cmd: iocmd);
3064	break;
3065	case IOCMD_PREBOOT_QUERY:
3066	rc = bfad_iocmd_preboot_query(bfad, cmd: iocmd);
3067	break;
3068	case IOCMD_ETHBOOT_CFG:
3069	rc = bfad_iocmd_ethboot_cfg(bfad, cmd: iocmd);
3070	break;
3071	case IOCMD_ETHBOOT_QUERY:
3072	rc = bfad_iocmd_ethboot_query(bfad, cmd: iocmd);
3073	break;
3074	case IOCMD_TRUNK_ENABLE:
3075	case IOCMD_TRUNK_DISABLE:
3076	rc = bfad_iocmd_cfg_trunk(bfad, cmd: iocmd, v_cmd: cmd);
3077	break;
3078	case IOCMD_TRUNK_GET_ATTR:
3079	rc = bfad_iocmd_trunk_get_attr(bfad, cmd: iocmd);
3080	break;
3081	case IOCMD_QOS_ENABLE:
3082	case IOCMD_QOS_DISABLE:
3083	rc = bfad_iocmd_qos(bfad, cmd: iocmd, v_cmd: cmd);
3084	break;
3085	case IOCMD_QOS_GET_ATTR:
3086	rc = bfad_iocmd_qos_get_attr(bfad, cmd: iocmd);
3087	break;
3088	case IOCMD_QOS_GET_VC_ATTR:
3089	rc = bfad_iocmd_qos_get_vc_attr(bfad, cmd: iocmd);
3090	break;
3091	case IOCMD_QOS_GET_STATS:
3092	rc = bfad_iocmd_qos_get_stats(bfad, cmd: iocmd);
3093	break;
3094	case IOCMD_QOS_RESET_STATS:
3095	rc = bfad_iocmd_qos_reset_stats(bfad, cmd: iocmd);
3096	break;
3097	case IOCMD_QOS_SET_BW:
3098	rc = bfad_iocmd_qos_set_bw(bfad, pcmd: iocmd);
3099	break;
3100	case IOCMD_VF_GET_STATS:
3101	rc = bfad_iocmd_vf_get_stats(bfad, cmd: iocmd);
3102	break;
3103	case IOCMD_VF_RESET_STATS:
3104	rc = bfad_iocmd_vf_clr_stats(bfad, cmd: iocmd);
3105	break;
3106	case IOCMD_FCPIM_LUNMASK_ENABLE:
3107	case IOCMD_FCPIM_LUNMASK_DISABLE:
3108	case IOCMD_FCPIM_LUNMASK_CLEAR:
3109	rc = bfad_iocmd_lunmask(bfad, pcmd: iocmd, v_cmd: cmd);
3110	break;
3111	case IOCMD_FCPIM_LUNMASK_QUERY:
3112	rc = bfad_iocmd_fcpim_lunmask_query(bfad, cmd: iocmd);
3113	break;
3114	case IOCMD_FCPIM_LUNMASK_ADD:
3115	case IOCMD_FCPIM_LUNMASK_DELETE:
3116	rc = bfad_iocmd_fcpim_cfg_lunmask(bfad, cmd: iocmd, v_cmd: cmd);
3117	break;
3118	case IOCMD_FCPIM_THROTTLE_QUERY:
3119	rc = bfad_iocmd_fcpim_throttle_query(bfad, cmd: iocmd);
3120	break;
3121	case IOCMD_FCPIM_THROTTLE_SET:
3122	rc = bfad_iocmd_fcpim_throttle_set(bfad, cmd: iocmd);
3123	break;
3124	/* TFRU */
3125	case IOCMD_TFRU_READ:
3126	rc = bfad_iocmd_tfru_read(bfad, cmd: iocmd);
3127	break;
3128	case IOCMD_TFRU_WRITE:
3129	rc = bfad_iocmd_tfru_write(bfad, cmd: iocmd);
3130	break;
3131	/* FRU */
3132	case IOCMD_FRUVPD_READ:
3133	rc = bfad_iocmd_fruvpd_read(bfad, cmd: iocmd);
3134	break;
3135	case IOCMD_FRUVPD_UPDATE:
3136	rc = bfad_iocmd_fruvpd_update(bfad, cmd: iocmd);
3137	break;
3138	case IOCMD_FRUVPD_GET_MAX_SIZE:
3139	rc = bfad_iocmd_fruvpd_get_max_size(bfad, cmd: iocmd);
3140	break;
3141	default:
3142	rc = -EINVAL;
3143	break;
3144	}
3145	return rc;
3146	}
3147
3148	static int
3149	bfad_im_bsg_vendor_request(struct bsg_job *job)
3150	{
3151	struct fc_bsg_request *bsg_request = job->request;
3152	struct fc_bsg_reply *bsg_reply = job->reply;
3153	uint32_t vendor_cmd = bsg_request->rqst_data.h_vendor.vendor_cmd[0];
3154	struct Scsi_Host *shost = fc_bsg_to_shost(job);
3155	struct bfad_im_port_s *im_port = bfad_get_im_port(host: shost);
3156	struct bfad_s *bfad = im_port->bfad;
3157	void *payload_kbuf;
3158	int rc = -EINVAL;
3159
3160	/* Allocate a temp buffer to hold the passed in user space command */
3161	payload_kbuf = kzalloc(size: job->request_payload.payload_len, GFP_KERNEL);
3162	if (!payload_kbuf) {
3163	rc = -ENOMEM;
3164	goto out;
3165	}
3166
3167	/* Copy the sg_list passed in to a linear buffer: holds the cmnd data */
3168	sg_copy_to_buffer(sgl: job->request_payload.sg_list,
3169	nents: job->request_payload.sg_cnt, buf: payload_kbuf,
3170	buflen: job->request_payload.payload_len);
3171
3172	/* Invoke IOCMD handler - to handle all the vendor command requests */
3173	rc = bfad_iocmd_handler(bfad, cmd: vendor_cmd, iocmd: payload_kbuf,
3174	payload_len: job->request_payload.payload_len);
3175	if (rc != BFA_STATUS_OK)
3176	goto error;
3177
3178	/* Copy the response data to the job->reply_payload sg_list */
3179	sg_copy_from_buffer(sgl: job->reply_payload.sg_list,
3180	nents: job->reply_payload.sg_cnt,
3181	buf: payload_kbuf,
3182	buflen: job->reply_payload.payload_len);
3183
3184	/* free the command buffer */
3185	kfree(objp: payload_kbuf);
3186
3187	/* Fill the BSG job reply data */
3188	job->reply_len = job->reply_payload.payload_len;
3189	bsg_reply->reply_payload_rcv_len = job->reply_payload.payload_len;
3190	bsg_reply->result = rc;
3191
3192	bsg_job_done(job, result: bsg_reply->result,
3193	reply_payload_rcv_len: bsg_reply->reply_payload_rcv_len);
3194	return rc;
3195	error:
3196	/* free the command buffer */
3197	kfree(objp: payload_kbuf);
3198	out:
3199	bsg_reply->result = rc;
3200	job->reply_len = sizeof(uint32_t);
3201	bsg_reply->reply_payload_rcv_len = 0;
3202	return rc;
3203	}
3204
3205	/* FC passthru call backs */
3206	static u64
3207	bfad_fcxp_get_req_sgaddr_cb(void *bfad_fcxp, int sgeid)
3208	{
3209	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3210	struct bfa_sge_s *sge;
3211	u64 addr;
3212
3213	sge = drv_fcxp->req_sge + sgeid;
3214	addr = (u64)(size_t) sge->sg_addr;
3215	return addr;
3216	}
3217
3218	static u32
3219	bfad_fcxp_get_req_sglen_cb(void *bfad_fcxp, int sgeid)
3220	{
3221	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3222	struct bfa_sge_s *sge;
3223
3224	sge = drv_fcxp->req_sge + sgeid;
3225	return sge->sg_len;
3226	}
3227
3228	static u64
3229	bfad_fcxp_get_rsp_sgaddr_cb(void *bfad_fcxp, int sgeid)
3230	{
3231	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3232	struct bfa_sge_s *sge;
3233	u64 addr;
3234
3235	sge = drv_fcxp->rsp_sge + sgeid;
3236	addr = (u64)(size_t) sge->sg_addr;
3237	return addr;
3238	}
3239
3240	static u32
3241	bfad_fcxp_get_rsp_sglen_cb(void *bfad_fcxp, int sgeid)
3242	{
3243	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3244	struct bfa_sge_s *sge;
3245
3246	sge = drv_fcxp->rsp_sge + sgeid;
3247	return sge->sg_len;
3248	}
3249
3250	static void
3251	bfad_send_fcpt_cb(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
3252	bfa_status_t req_status, u32 rsp_len, u32 resid_len,
3253	struct fchs_s *rsp_fchs)
3254	{
3255	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3256
3257	drv_fcxp->req_status = req_status;
3258	drv_fcxp->rsp_len = rsp_len;
3259
3260	/* bfa_fcxp will be automatically freed by BFA */
3261	drv_fcxp->bfa_fcxp = NULL;
3262	complete(&drv_fcxp->comp);
3263	}
3264
3265	static struct bfad_buf_info *
3266	bfad_fcxp_map_sg(struct bfad_s *bfad, void *payload_kbuf,
3267	uint32_t payload_len, uint32_t *num_sgles)
3268	{
3269	struct bfad_buf_info *buf_base, *buf_info;
3270	struct bfa_sge_s *sg_table;
3271	int sge_num = 1;
3272
3273	buf_base = kcalloc(n: sizeof(struct bfad_buf_info) +
3274	sizeof(struct bfa_sge_s),
3275	size: sge_num, GFP_KERNEL);
3276	if (!buf_base)
3277	return NULL;
3278
3279	sg_table = (struct bfa_sge_s *) (((uint8_t *)buf_base) +
3280	(sizeof(struct bfad_buf_info) * sge_num));
3281
3282	/* Allocate dma coherent memory */
3283	buf_info = buf_base;
3284	buf_info->size = payload_len;
3285	buf_info->virt = dma_alloc_coherent(dev: &bfad->pcidev->dev,
3286	size: buf_info->size, dma_handle: &buf_info->phys,
3287	GFP_KERNEL);
3288	if (!buf_info->virt)
3289	goto out_free_mem;
3290
3291	/* copy the linear bsg buffer to buf_info */
3292	memcpy(buf_info->virt, payload_kbuf, buf_info->size);
3293
3294	/*
3295	* Setup SG table
3296	*/
3297	sg_table->sg_len = buf_info->size;
3298	sg_table->sg_addr = (void *)(size_t) buf_info->phys;
3299
3300	*num_sgles = sge_num;
3301
3302	return buf_base;
3303
3304	out_free_mem:
3305	kfree(objp: buf_base);
3306	return NULL;
3307	}
3308
3309	static void
3310	bfad_fcxp_free_mem(struct bfad_s *bfad, struct bfad_buf_info *buf_base,
3311	uint32_t num_sgles)
3312	{
3313	int i;
3314	struct bfad_buf_info *buf_info = buf_base;
3315
3316	if (buf_base) {
3317	for (i = 0; i < num_sgles; buf_info++, i++) {
3318	if (buf_info->virt != NULL)
3319	dma_free_coherent(dev: &bfad->pcidev->dev,
3320	size: buf_info->size, cpu_addr: buf_info->virt,
3321	dma_handle: buf_info->phys);
3322	}
3323	kfree(objp: buf_base);
3324	}
3325	}
3326
3327	static int
3328	bfad_fcxp_bsg_send(struct bsg_job *job, struct bfad_fcxp *drv_fcxp,
3329	bfa_bsg_fcpt_t *bsg_fcpt)
3330	{
3331	struct bfa_fcxp_s *hal_fcxp;
3332	struct bfad_s *bfad = drv_fcxp->port->bfad;
3333	unsigned long flags;
3334	uint8_t lp_tag;
3335
3336	spin_lock_irqsave(&bfad->bfad_lock, flags);
3337
3338	/* Allocate bfa_fcxp structure */
3339	hal_fcxp = bfa_fcxp_req_rsp_alloc(bfad_fcxp: drv_fcxp, bfa: &bfad->bfa,
3340	nreq_sgles: drv_fcxp->num_req_sgles,
3341	nrsp_sgles: drv_fcxp->num_rsp_sgles,
3342	get_req_sga: bfad_fcxp_get_req_sgaddr_cb,
3343	get_req_sglen: bfad_fcxp_get_req_sglen_cb,
3344	get_rsp_sga: bfad_fcxp_get_rsp_sgaddr_cb,
3345	get_rsp_sglen: bfad_fcxp_get_rsp_sglen_cb, req: BFA_TRUE);
3346	if (!hal_fcxp) {
3347	bfa_trc(bfad, 0);
3348	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
3349	return BFA_STATUS_ENOMEM;
3350	}
3351
3352	drv_fcxp->bfa_fcxp = hal_fcxp;
3353
3354	lp_tag = bfa_lps_get_tag_from_pid(bfa: &bfad->bfa, pid: bsg_fcpt->fchs.s_id);
3355
3356	bfa_fcxp_send(fcxp: hal_fcxp, rport: drv_fcxp->bfa_rport, vf_id: bsg_fcpt->vf_id, lp_tag,
3357	cts: bsg_fcpt->cts, cos: bsg_fcpt->cos,
3358	reqlen: job->request_payload.payload_len,
3359	fchs: &bsg_fcpt->fchs, cbfn: bfad_send_fcpt_cb, cbarg: bfad,
3360	rsp_maxlen: job->reply_payload.payload_len, rsp_timeout: bsg_fcpt->tsecs);
3361
3362	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
3363
3364	return BFA_STATUS_OK;
3365	}
3366
3367	static int
3368	bfad_im_bsg_els_ct_request(struct bsg_job *job)
3369	{
3370	struct bfa_bsg_data *bsg_data;
3371	struct Scsi_Host *shost = fc_bsg_to_shost(job);
3372	struct bfad_im_port_s *im_port = bfad_get_im_port(host: shost);
3373	struct bfad_s *bfad = im_port->bfad;
3374	bfa_bsg_fcpt_t *bsg_fcpt;
3375	struct bfad_fcxp *drv_fcxp;
3376	struct bfa_fcs_lport_s *fcs_port;
3377	struct bfa_fcs_rport_s *fcs_rport;
3378	struct fc_bsg_request *bsg_request = job->request;
3379	struct fc_bsg_reply *bsg_reply = job->reply;
3380	uint32_t command_type = bsg_request->msgcode;
3381	unsigned long flags;
3382	struct bfad_buf_info *rsp_buf_info;
3383	void *req_kbuf = NULL, *rsp_kbuf = NULL;
3384	int rc = -EINVAL;
3385
3386	job->reply_len = sizeof(uint32_t); /* Atleast uint32_t reply_len */
3387	bsg_reply->reply_payload_rcv_len = 0;
3388
3389	/* Get the payload passed in from userspace */
3390	bsg_data = (struct bfa_bsg_data *) (((char *)bsg_request) +
3391	sizeof(struct fc_bsg_request));
3392	if (bsg_data == NULL)
3393	goto out;
3394
3395	/*
3396	* Allocate buffer for bsg_fcpt and do a copy_from_user op for payload
3397	* buffer of size bsg_data->payload_len
3398	*/
3399	bsg_fcpt = kzalloc(size: bsg_data->payload_len, GFP_KERNEL);
3400	if (!bsg_fcpt) {
3401	rc = -ENOMEM;
3402	goto out;
3403	}
3404
3405	if (copy_from_user(to: (uint8_t *)bsg_fcpt,
3406	from: (void *)(unsigned long)bsg_data->payload,
3407	n: bsg_data->payload_len)) {
3408	kfree(objp: bsg_fcpt);
3409	rc = -EIO;
3410	goto out;
3411	}
3412
3413	drv_fcxp = kzalloc(size: sizeof(struct bfad_fcxp), GFP_KERNEL);
3414	if (drv_fcxp == NULL) {
3415	kfree(objp: bsg_fcpt);
3416	rc = -ENOMEM;
3417	goto out;
3418	}
3419
3420	spin_lock_irqsave(&bfad->bfad_lock, flags);
3421	fcs_port = bfa_fcs_lookup_port(fcs: &bfad->bfa_fcs, vf_id: bsg_fcpt->vf_id,
3422	lpwwn: bsg_fcpt->lpwwn);
3423	if (fcs_port == NULL) {
3424	bsg_fcpt->status = BFA_STATUS_UNKNOWN_LWWN;
3425	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
3426	goto out_free_mem;
3427	}
3428
3429	/* Check if the port is online before sending FC Passthru cmd */
3430	if (!bfa_fcs_lport_is_online(port: fcs_port)) {
3431	bsg_fcpt->status = BFA_STATUS_PORT_OFFLINE;
3432	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
3433	goto out_free_mem;
3434	}
3435
3436	drv_fcxp->port = fcs_port->bfad_port;
3437
3438	if (!drv_fcxp->port->bfad)
3439	drv_fcxp->port->bfad = bfad;
3440
3441	/* Fetch the bfa_rport - if nexus needed */
3442	if (command_type == FC_BSG_HST_ELS_NOLOGIN ||
3443	command_type == FC_BSG_HST_CT) {
3444	/* BSG HST commands: no nexus needed */
3445	drv_fcxp->bfa_rport = NULL;
3446
3447	} else if (command_type == FC_BSG_RPT_ELS ||
3448	command_type == FC_BSG_RPT_CT) {
3449	/* BSG RPT commands: nexus needed */
3450	fcs_rport = bfa_fcs_lport_get_rport_by_pwwn(port: fcs_port,
3451	pwwn: bsg_fcpt->dpwwn);
3452	if (fcs_rport == NULL) {
3453	bsg_fcpt->status = BFA_STATUS_UNKNOWN_RWWN;
3454	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
3455	goto out_free_mem;
3456	}
3457
3458	drv_fcxp->bfa_rport = fcs_rport->bfa_rport;
3459
3460	} else { /* Unknown BSG msgcode; return -EINVAL */
3461	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
3462	goto out_free_mem;
3463	}
3464
3465	spin_unlock_irqrestore(lock: &bfad->bfad_lock, flags);
3466
3467	/* allocate memory for req / rsp buffers */
3468	req_kbuf = kzalloc(size: job->request_payload.payload_len, GFP_KERNEL);
3469	if (!req_kbuf) {
3470	printk(KERN_INFO "bfa %s: fcpt request buffer alloc failed\n",
3471	bfad->pci_name);
3472	rc = -ENOMEM;
3473	goto out_free_mem;
3474	}
3475
3476	rsp_kbuf = kzalloc(size: job->reply_payload.payload_len, GFP_KERNEL);
3477	if (!rsp_kbuf) {
3478	printk(KERN_INFO "bfa %s: fcpt response buffer alloc failed\n",
3479	bfad->pci_name);
3480	rc = -ENOMEM;
3481	goto out_free_mem;
3482	}
3483
3484	/* map req sg - copy the sg_list passed in to the linear buffer */
3485	sg_copy_to_buffer(sgl: job->request_payload.sg_list,
3486	nents: job->request_payload.sg_cnt, buf: req_kbuf,
3487	buflen: job->request_payload.payload_len);
3488
3489	drv_fcxp->reqbuf_info = bfad_fcxp_map_sg(bfad, payload_kbuf: req_kbuf,
3490	payload_len: job->request_payload.payload_len,
3491	num_sgles: &drv_fcxp->num_req_sgles);
3492	if (!drv_fcxp->reqbuf_info) {
3493	printk(KERN_INFO "bfa %s: fcpt request fcxp_map_sg failed\n",
3494	bfad->pci_name);
3495	rc = -ENOMEM;
3496	goto out_free_mem;
3497	}
3498
3499	drv_fcxp->req_sge = (struct bfa_sge_s *)
3500	(((uint8_t *)drv_fcxp->reqbuf_info) +
3501	(sizeof(struct bfad_buf_info) *
3502	drv_fcxp->num_req_sgles));
3503
3504	/* map rsp sg */
3505	drv_fcxp->rspbuf_info = bfad_fcxp_map_sg(bfad, payload_kbuf: rsp_kbuf,
3506	payload_len: job->reply_payload.payload_len,
3507	num_sgles: &drv_fcxp->num_rsp_sgles);
3508	if (!drv_fcxp->rspbuf_info) {
3509	printk(KERN_INFO "bfa %s: fcpt response fcxp_map_sg failed\n",
3510	bfad->pci_name);
3511	rc = -ENOMEM;
3512	goto out_free_mem;
3513	}
3514
3515	rsp_buf_info = (struct bfad_buf_info *)drv_fcxp->rspbuf_info;
3516	drv_fcxp->rsp_sge = (struct bfa_sge_s *)
3517	(((uint8_t *)drv_fcxp->rspbuf_info) +
3518	(sizeof(struct bfad_buf_info) *
3519	drv_fcxp->num_rsp_sgles));
3520
3521	/* fcxp send */
3522	init_completion(x: &drv_fcxp->comp);
3523	rc = bfad_fcxp_bsg_send(job, drv_fcxp, bsg_fcpt);
3524	if (rc == BFA_STATUS_OK) {
3525	wait_for_completion(&drv_fcxp->comp);
3526	bsg_fcpt->status = drv_fcxp->req_status;
3527	} else {
3528	bsg_fcpt->status = rc;
3529	goto out_free_mem;
3530	}
3531
3532	/* fill the job->reply data */
3533	if (drv_fcxp->req_status == BFA_STATUS_OK) {
3534	job->reply_len = drv_fcxp->rsp_len;
3535	bsg_reply->reply_payload_rcv_len = drv_fcxp->rsp_len;
3536	bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
3537	} else {
3538	bsg_reply->reply_payload_rcv_len =
3539	sizeof(struct fc_bsg_ctels_reply);
3540	job->reply_len = sizeof(uint32_t);
3541	bsg_reply->reply_data.ctels_reply.status =
3542	FC_CTELS_STATUS_REJECT;
3543	}
3544
3545	/* Copy the response data to the reply_payload sg list */
3546	sg_copy_from_buffer(sgl: job->reply_payload.sg_list,
3547	nents: job->reply_payload.sg_cnt,
3548	buf: (uint8_t *)rsp_buf_info->virt,
3549	buflen: job->reply_payload.payload_len);
3550
3551	out_free_mem:
3552	bfad_fcxp_free_mem(bfad, buf_base: drv_fcxp->rspbuf_info,
3553	num_sgles: drv_fcxp->num_rsp_sgles);
3554	bfad_fcxp_free_mem(bfad, buf_base: drv_fcxp->reqbuf_info,
3555	num_sgles: drv_fcxp->num_req_sgles);
3556	kfree(objp: req_kbuf);
3557	kfree(objp: rsp_kbuf);
3558
3559	/* Need a copy to user op */
3560	if (copy_to_user(to: (void *)(unsigned long)bsg_data->payload,
3561	from: (void *)bsg_fcpt, n: bsg_data->payload_len))
3562	rc = -EIO;
3563
3564	kfree(objp: bsg_fcpt);
3565	kfree(objp: drv_fcxp);
3566	out:
3567	bsg_reply->result = rc;
3568
3569	if (rc == BFA_STATUS_OK)
3570	bsg_job_done(job, result: bsg_reply->result,
3571	reply_payload_rcv_len: bsg_reply->reply_payload_rcv_len);
3572
3573	return rc;
3574	}
3575
3576	int
3577	bfad_im_bsg_request(struct bsg_job *job)
3578	{
3579	struct fc_bsg_request *bsg_request = job->request;
3580	struct fc_bsg_reply *bsg_reply = job->reply;
3581	uint32_t rc = BFA_STATUS_OK;
3582
3583	switch (bsg_request->msgcode) {
3584	case FC_BSG_HST_VENDOR:
3585	/* Process BSG HST Vendor requests */
3586	rc = bfad_im_bsg_vendor_request(job);
3587	break;
3588	case FC_BSG_HST_ELS_NOLOGIN:
3589	case FC_BSG_RPT_ELS:
3590	case FC_BSG_HST_CT:
3591	case FC_BSG_RPT_CT:
3592	/* Process BSG ELS/CT commands */
3593	rc = bfad_im_bsg_els_ct_request(job);
3594	break;
3595	default:
3596	bsg_reply->result = rc = -EINVAL;
3597	bsg_reply->reply_payload_rcv_len = 0;
3598	break;
3599	}
3600
3601	return rc;
3602	}
3603
3604	int
3605	bfad_im_bsg_timeout(struct bsg_job *job)
3606	{
3607	/* Don't complete the BSG job request - return -EAGAIN
3608	* to reset bsg job timeout : for ELS/CT pass thru we
3609	* already have timer to track the request.
3610	*/
3611	return -EAGAIN;
3612	}
3613