2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
18 #include <linux/uaccess.h>
23 BFA_TRC_FILE(LDRV
, BSG
);
26 bfad_iocmd_ioc_enable(struct bfad_s
*bfad
, void *cmd
)
28 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
32 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
33 /* If IOC is not in disabled state - return */
34 if (!bfa_ioc_is_disabled(&bfad
->bfa
.ioc
)) {
35 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
36 iocmd
->status
= BFA_STATUS_OK
;
40 init_completion(&bfad
->enable_comp
);
41 bfa_iocfc_enable(&bfad
->bfa
);
42 iocmd
->status
= BFA_STATUS_OK
;
43 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
44 wait_for_completion(&bfad
->enable_comp
);
50 bfad_iocmd_ioc_disable(struct bfad_s
*bfad
, void *cmd
)
52 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
56 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
57 if (bfa_ioc_is_disabled(&bfad
->bfa
.ioc
)) {
58 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
59 iocmd
->status
= BFA_STATUS_OK
;
63 if (bfad
->disable_active
) {
64 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
68 bfad
->disable_active
= BFA_TRUE
;
69 init_completion(&bfad
->disable_comp
);
70 bfa_iocfc_disable(&bfad
->bfa
);
71 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
73 wait_for_completion(&bfad
->disable_comp
);
74 bfad
->disable_active
= BFA_FALSE
;
75 iocmd
->status
= BFA_STATUS_OK
;
81 bfad_iocmd_ioc_get_info(struct bfad_s
*bfad
, void *cmd
)
84 struct bfa_bsg_ioc_info_s
*iocmd
= (struct bfa_bsg_ioc_info_s
*)cmd
;
85 struct bfad_im_port_s
*im_port
;
86 struct bfa_port_attr_s pattr
;
89 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
90 bfa_fcport_get_attr(&bfad
->bfa
, &pattr
);
91 iocmd
->nwwn
= pattr
.nwwn
;
92 iocmd
->pwwn
= pattr
.pwwn
;
93 iocmd
->ioc_type
= bfa_get_type(&bfad
->bfa
);
94 iocmd
->mac
= bfa_get_mac(&bfad
->bfa
);
95 iocmd
->factory_mac
= bfa_get_mfg_mac(&bfad
->bfa
);
96 bfa_get_adapter_serial_num(&bfad
->bfa
, iocmd
->serialnum
);
97 iocmd
->factorynwwn
= pattr
.factorynwwn
;
98 iocmd
->factorypwwn
= pattr
.factorypwwn
;
99 iocmd
->bfad_num
= bfad
->inst_no
;
100 im_port
= bfad
->pport
.im_port
;
101 iocmd
->host
= im_port
->shost
->host_no
;
102 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
104 strcpy(iocmd
->name
, bfad
->adapter_name
);
105 strcpy(iocmd
->port_name
, bfad
->port_name
);
106 strcpy(iocmd
->hwpath
, bfad
->pci_name
);
108 /* set adapter hw path */
109 strcpy(iocmd
->adapter_hwpath
, bfad
->pci_name
);
110 for (i
= 0; iocmd
->adapter_hwpath
[i
] != ':' && i
< BFA_STRING_32
; i
++)
112 for (; iocmd
->adapter_hwpath
[++i
] != ':' && i
< BFA_STRING_32
; )
114 iocmd
->adapter_hwpath
[i
] = '\0';
115 iocmd
->status
= BFA_STATUS_OK
;
120 bfad_iocmd_ioc_get_attr(struct bfad_s
*bfad
, void *cmd
)
122 struct bfa_bsg_ioc_attr_s
*iocmd
= (struct bfa_bsg_ioc_attr_s
*)cmd
;
125 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
126 bfa_ioc_get_attr(&bfad
->bfa
.ioc
, &iocmd
->ioc_attr
);
127 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
129 /* fill in driver attr info */
130 strcpy(iocmd
->ioc_attr
.driver_attr
.driver
, BFAD_DRIVER_NAME
);
131 strncpy(iocmd
->ioc_attr
.driver_attr
.driver_ver
,
132 BFAD_DRIVER_VERSION
, BFA_VERSION_LEN
);
133 strcpy(iocmd
->ioc_attr
.driver_attr
.fw_ver
,
134 iocmd
->ioc_attr
.adapter_attr
.fw_ver
);
135 strcpy(iocmd
->ioc_attr
.driver_attr
.bios_ver
,
136 iocmd
->ioc_attr
.adapter_attr
.optrom_ver
);
138 /* copy chip rev info first otherwise it will be overwritten */
139 memcpy(bfad
->pci_attr
.chip_rev
, iocmd
->ioc_attr
.pci_attr
.chip_rev
,
140 sizeof(bfad
->pci_attr
.chip_rev
));
141 memcpy(&iocmd
->ioc_attr
.pci_attr
, &bfad
->pci_attr
,
142 sizeof(struct bfa_ioc_pci_attr_s
));
144 iocmd
->status
= BFA_STATUS_OK
;
149 bfad_iocmd_ioc_get_stats(struct bfad_s
*bfad
, void *cmd
)
151 struct bfa_bsg_ioc_stats_s
*iocmd
= (struct bfa_bsg_ioc_stats_s
*)cmd
;
153 bfa_ioc_get_stats(&bfad
->bfa
, &iocmd
->ioc_stats
);
154 iocmd
->status
= BFA_STATUS_OK
;
159 bfad_iocmd_ioc_get_fwstats(struct bfad_s
*bfad
, void *cmd
,
160 unsigned int payload_len
)
162 struct bfa_bsg_ioc_fwstats_s
*iocmd
=
163 (struct bfa_bsg_ioc_fwstats_s
*)cmd
;
167 if (bfad_chk_iocmd_sz(payload_len
,
168 sizeof(struct bfa_bsg_ioc_fwstats_s
),
169 sizeof(struct bfa_fw_stats_s
)) != BFA_STATUS_OK
) {
170 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
174 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_ioc_fwstats_s
);
175 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
176 iocmd
->status
= bfa_ioc_fw_stats_get(&bfad
->bfa
.ioc
, iocmd_bufptr
);
177 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
179 if (iocmd
->status
!= BFA_STATUS_OK
) {
180 bfa_trc(bfad
, iocmd
->status
);
184 bfa_trc(bfad
, 0x6666);
189 bfad_iocmd_ioc_reset_stats(struct bfad_s
*bfad
, void *cmd
, unsigned int v_cmd
)
191 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
194 if (v_cmd
== IOCMD_IOC_RESET_STATS
) {
195 bfa_ioc_clear_stats(&bfad
->bfa
);
196 iocmd
->status
= BFA_STATUS_OK
;
197 } else if (v_cmd
== IOCMD_IOC_RESET_FWSTATS
) {
198 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
199 iocmd
->status
= bfa_ioc_fw_stats_clear(&bfad
->bfa
.ioc
);
200 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
207 bfad_iocmd_ioc_set_name(struct bfad_s
*bfad
, void *cmd
, unsigned int v_cmd
)
209 struct bfa_bsg_ioc_name_s
*iocmd
= (struct bfa_bsg_ioc_name_s
*) cmd
;
211 if (v_cmd
== IOCMD_IOC_SET_ADAPTER_NAME
)
212 strcpy(bfad
->adapter_name
, iocmd
->name
);
213 else if (v_cmd
== IOCMD_IOC_SET_PORT_NAME
)
214 strcpy(bfad
->port_name
, iocmd
->name
);
216 iocmd
->status
= BFA_STATUS_OK
;
221 bfad_iocmd_iocfc_get_attr(struct bfad_s
*bfad
, void *cmd
)
223 struct bfa_bsg_iocfc_attr_s
*iocmd
= (struct bfa_bsg_iocfc_attr_s
*)cmd
;
225 iocmd
->status
= BFA_STATUS_OK
;
226 bfa_iocfc_get_attr(&bfad
->bfa
, &iocmd
->iocfc_attr
);
232 bfad_iocmd_iocfc_set_intr(struct bfad_s
*bfad
, void *cmd
)
234 struct bfa_bsg_iocfc_intr_s
*iocmd
= (struct bfa_bsg_iocfc_intr_s
*)cmd
;
237 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
238 iocmd
->status
= bfa_iocfc_israttr_set(&bfad
->bfa
, &iocmd
->attr
);
239 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
245 bfad_iocmd_port_enable(struct bfad_s
*bfad
, void *cmd
)
247 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
248 struct bfad_hal_comp fcomp
;
251 init_completion(&fcomp
.comp
);
252 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
253 iocmd
->status
= bfa_port_enable(&bfad
->bfa
.modules
.port
,
254 bfad_hcb_comp
, &fcomp
);
255 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
256 if (iocmd
->status
!= BFA_STATUS_OK
) {
257 bfa_trc(bfad
, iocmd
->status
);
260 wait_for_completion(&fcomp
.comp
);
261 iocmd
->status
= fcomp
.status
;
266 bfad_iocmd_port_disable(struct bfad_s
*bfad
, void *cmd
)
268 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
269 struct bfad_hal_comp fcomp
;
272 init_completion(&fcomp
.comp
);
273 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
274 iocmd
->status
= bfa_port_disable(&bfad
->bfa
.modules
.port
,
275 bfad_hcb_comp
, &fcomp
);
276 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
278 if (iocmd
->status
!= BFA_STATUS_OK
) {
279 bfa_trc(bfad
, iocmd
->status
);
282 wait_for_completion(&fcomp
.comp
);
283 iocmd
->status
= fcomp
.status
;
288 bfad_iocmd_port_get_attr(struct bfad_s
*bfad
, void *cmd
)
290 struct bfa_bsg_port_attr_s
*iocmd
= (struct bfa_bsg_port_attr_s
*)cmd
;
291 struct bfa_lport_attr_s port_attr
;
294 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
295 bfa_fcport_get_attr(&bfad
->bfa
, &iocmd
->attr
);
296 bfa_fcs_lport_get_attr(&bfad
->bfa_fcs
.fabric
.bport
, &port_attr
);
297 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
299 if (iocmd
->attr
.topology
!= BFA_PORT_TOPOLOGY_NONE
)
300 iocmd
->attr
.pid
= port_attr
.pid
;
304 iocmd
->attr
.port_type
= port_attr
.port_type
;
305 iocmd
->attr
.loopback
= port_attr
.loopback
;
306 iocmd
->attr
.authfail
= port_attr
.authfail
;
307 strncpy(iocmd
->attr
.port_symname
.symname
,
308 port_attr
.port_cfg
.sym_name
.symname
,
309 sizeof(port_attr
.port_cfg
.sym_name
.symname
));
311 iocmd
->status
= BFA_STATUS_OK
;
316 bfad_iocmd_port_get_stats(struct bfad_s
*bfad
, void *cmd
,
317 unsigned int payload_len
)
319 struct bfa_bsg_port_stats_s
*iocmd
= (struct bfa_bsg_port_stats_s
*)cmd
;
320 struct bfad_hal_comp fcomp
;
324 if (bfad_chk_iocmd_sz(payload_len
,
325 sizeof(struct bfa_bsg_port_stats_s
),
326 sizeof(union bfa_port_stats_u
)) != BFA_STATUS_OK
) {
327 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
331 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_port_stats_s
);
333 init_completion(&fcomp
.comp
);
334 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
335 iocmd
->status
= bfa_port_get_stats(&bfad
->bfa
.modules
.port
,
336 iocmd_bufptr
, bfad_hcb_comp
, &fcomp
);
337 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
338 if (iocmd
->status
!= BFA_STATUS_OK
) {
339 bfa_trc(bfad
, iocmd
->status
);
343 wait_for_completion(&fcomp
.comp
);
344 iocmd
->status
= fcomp
.status
;
350 bfad_iocmd_port_reset_stats(struct bfad_s
*bfad
, void *cmd
)
352 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
353 struct bfad_hal_comp fcomp
;
356 init_completion(&fcomp
.comp
);
357 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
358 iocmd
->status
= bfa_port_clear_stats(&bfad
->bfa
.modules
.port
,
359 bfad_hcb_comp
, &fcomp
);
360 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
361 if (iocmd
->status
!= BFA_STATUS_OK
) {
362 bfa_trc(bfad
, iocmd
->status
);
365 wait_for_completion(&fcomp
.comp
);
366 iocmd
->status
= fcomp
.status
;
371 bfad_iocmd_set_port_cfg(struct bfad_s
*bfad
, void *iocmd
, unsigned int v_cmd
)
373 struct bfa_bsg_port_cfg_s
*cmd
= (struct bfa_bsg_port_cfg_s
*)iocmd
;
376 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
377 if (v_cmd
== IOCMD_PORT_CFG_TOPO
)
378 cmd
->status
= bfa_fcport_cfg_topology(&bfad
->bfa
, cmd
->param
);
379 else if (v_cmd
== IOCMD_PORT_CFG_SPEED
)
380 cmd
->status
= bfa_fcport_cfg_speed(&bfad
->bfa
, cmd
->param
);
381 else if (v_cmd
== IOCMD_PORT_CFG_ALPA
)
382 cmd
->status
= bfa_fcport_cfg_hardalpa(&bfad
->bfa
, cmd
->param
);
383 else if (v_cmd
== IOCMD_PORT_CLR_ALPA
)
384 cmd
->status
= bfa_fcport_clr_hardalpa(&bfad
->bfa
);
385 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
391 bfad_iocmd_port_cfg_maxfrsize(struct bfad_s
*bfad
, void *cmd
)
393 struct bfa_bsg_port_cfg_maxfrsize_s
*iocmd
=
394 (struct bfa_bsg_port_cfg_maxfrsize_s
*)cmd
;
397 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
398 iocmd
->status
= bfa_fcport_cfg_maxfrsize(&bfad
->bfa
, iocmd
->maxfrsize
);
399 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
405 bfad_iocmd_port_cfg_bbsc(struct bfad_s
*bfad
, void *cmd
, unsigned int v_cmd
)
407 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
408 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
411 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
412 if (bfa_ioc_get_type(&bfad
->bfa
.ioc
) == BFA_IOC_TYPE_FC
) {
413 if (v_cmd
== IOCMD_PORT_BBSC_ENABLE
)
414 fcport
->cfg
.bb_scn_state
= BFA_TRUE
;
415 else if (v_cmd
== IOCMD_PORT_BBSC_DISABLE
)
416 fcport
->cfg
.bb_scn_state
= BFA_FALSE
;
418 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
420 iocmd
->status
= BFA_STATUS_OK
;
425 bfad_iocmd_lport_get_attr(struct bfad_s
*bfad
, void *cmd
)
427 struct bfa_fcs_lport_s
*fcs_port
;
428 struct bfa_bsg_lport_attr_s
*iocmd
= (struct bfa_bsg_lport_attr_s
*)cmd
;
431 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
432 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
433 iocmd
->vf_id
, iocmd
->pwwn
);
434 if (fcs_port
== NULL
) {
435 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
436 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
440 bfa_fcs_lport_get_attr(fcs_port
, &iocmd
->port_attr
);
441 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
442 iocmd
->status
= BFA_STATUS_OK
;
448 bfad_iocmd_lport_get_stats(struct bfad_s
*bfad
, void *cmd
)
450 struct bfa_fcs_lport_s
*fcs_port
;
451 struct bfa_bsg_lport_stats_s
*iocmd
=
452 (struct bfa_bsg_lport_stats_s
*)cmd
;
455 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
456 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
457 iocmd
->vf_id
, iocmd
->pwwn
);
458 if (fcs_port
== NULL
) {
459 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
460 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
464 bfa_fcs_lport_get_stats(fcs_port
, &iocmd
->port_stats
);
465 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
466 iocmd
->status
= BFA_STATUS_OK
;
472 bfad_iocmd_lport_reset_stats(struct bfad_s
*bfad
, void *cmd
)
474 struct bfa_fcs_lport_s
*fcs_port
;
475 struct bfa_bsg_reset_stats_s
*iocmd
=
476 (struct bfa_bsg_reset_stats_s
*)cmd
;
477 struct bfa_fcpim_s
*fcpim
= BFA_FCPIM(&bfad
->bfa
);
478 struct list_head
*qe
, *qen
;
479 struct bfa_itnim_s
*itnim
;
482 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
483 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
484 iocmd
->vf_id
, iocmd
->vpwwn
);
485 if (fcs_port
== NULL
) {
486 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
487 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
491 bfa_fcs_lport_clear_stats(fcs_port
);
492 /* clear IO stats from all active itnims */
493 list_for_each_safe(qe
, qen
, &fcpim
->itnim_q
) {
494 itnim
= (struct bfa_itnim_s
*) qe
;
495 if (itnim
->rport
->rport_info
.lp_tag
!= fcs_port
->lp_tag
)
497 bfa_itnim_clear_stats(itnim
);
499 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
500 iocmd
->status
= BFA_STATUS_OK
;
506 bfad_iocmd_lport_get_iostats(struct bfad_s
*bfad
, void *cmd
)
508 struct bfa_fcs_lport_s
*fcs_port
;
509 struct bfa_bsg_lport_iostats_s
*iocmd
=
510 (struct bfa_bsg_lport_iostats_s
*)cmd
;
513 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
514 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
515 iocmd
->vf_id
, iocmd
->pwwn
);
516 if (fcs_port
== NULL
) {
517 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
518 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
522 bfa_fcpim_port_iostats(&bfad
->bfa
, &iocmd
->iostats
,
524 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
525 iocmd
->status
= BFA_STATUS_OK
;
531 bfad_iocmd_lport_get_rports(struct bfad_s
*bfad
, void *cmd
,
532 unsigned int payload_len
)
534 struct bfa_bsg_lport_get_rports_s
*iocmd
=
535 (struct bfa_bsg_lport_get_rports_s
*)cmd
;
536 struct bfa_fcs_lport_s
*fcs_port
;
540 if (iocmd
->nrports
== 0)
543 if (bfad_chk_iocmd_sz(payload_len
,
544 sizeof(struct bfa_bsg_lport_get_rports_s
),
545 sizeof(struct bfa_rport_qualifier_s
) * iocmd
->nrports
)
547 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
551 iocmd_bufptr
= (char *)iocmd
+
552 sizeof(struct bfa_bsg_lport_get_rports_s
);
553 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
554 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
555 iocmd
->vf_id
, iocmd
->pwwn
);
556 if (fcs_port
== NULL
) {
557 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
559 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
563 bfa_fcs_lport_get_rport_quals(fcs_port
,
564 (struct bfa_rport_qualifier_s
*)iocmd_bufptr
,
566 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
567 iocmd
->status
= BFA_STATUS_OK
;
573 bfad_iocmd_rport_get_attr(struct bfad_s
*bfad
, void *cmd
)
575 struct bfa_bsg_rport_attr_s
*iocmd
= (struct bfa_bsg_rport_attr_s
*)cmd
;
576 struct bfa_fcs_lport_s
*fcs_port
;
577 struct bfa_fcs_rport_s
*fcs_rport
;
580 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
581 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
582 iocmd
->vf_id
, iocmd
->pwwn
);
583 if (fcs_port
== NULL
) {
585 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
586 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
591 fcs_rport
= bfa_fcs_lport_get_rport_by_qualifier(fcs_port
,
592 iocmd
->rpwwn
, iocmd
->pid
);
594 fcs_rport
= bfa_fcs_rport_lookup(fcs_port
, iocmd
->rpwwn
);
595 if (fcs_rport
== NULL
) {
597 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
598 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
602 bfa_fcs_rport_get_attr(fcs_rport
, &iocmd
->attr
);
603 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
604 iocmd
->status
= BFA_STATUS_OK
;
610 bfad_iocmd_rport_get_addr(struct bfad_s
*bfad
, void *cmd
)
612 struct bfa_bsg_rport_scsi_addr_s
*iocmd
=
613 (struct bfa_bsg_rport_scsi_addr_s
*)cmd
;
614 struct bfa_fcs_lport_s
*fcs_port
;
615 struct bfa_fcs_itnim_s
*fcs_itnim
;
616 struct bfad_itnim_s
*drv_itnim
;
619 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
620 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
621 iocmd
->vf_id
, iocmd
->pwwn
);
622 if (fcs_port
== NULL
) {
624 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
625 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
629 fcs_itnim
= bfa_fcs_itnim_lookup(fcs_port
, iocmd
->rpwwn
);
630 if (fcs_itnim
== NULL
) {
632 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
633 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
637 drv_itnim
= fcs_itnim
->itnim_drv
;
639 if (drv_itnim
&& drv_itnim
->im_port
)
640 iocmd
->host
= drv_itnim
->im_port
->shost
->host_no
;
643 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
644 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
648 iocmd
->target
= drv_itnim
->scsi_tgt_id
;
649 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
653 iocmd
->status
= BFA_STATUS_OK
;
659 bfad_iocmd_rport_get_stats(struct bfad_s
*bfad
, void *cmd
)
661 struct bfa_bsg_rport_stats_s
*iocmd
=
662 (struct bfa_bsg_rport_stats_s
*)cmd
;
663 struct bfa_fcs_lport_s
*fcs_port
;
664 struct bfa_fcs_rport_s
*fcs_rport
;
667 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
668 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
669 iocmd
->vf_id
, iocmd
->pwwn
);
670 if (fcs_port
== NULL
) {
672 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
673 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
677 fcs_rport
= bfa_fcs_rport_lookup(fcs_port
, iocmd
->rpwwn
);
678 if (fcs_rport
== NULL
) {
680 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
681 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
685 memcpy((void *)&iocmd
->stats
, (void *)&fcs_rport
->stats
,
686 sizeof(struct bfa_rport_stats_s
));
687 if (bfa_fcs_rport_get_halrport(fcs_rport
)) {
688 memcpy((void *)&iocmd
->stats
.hal_stats
,
689 (void *)&(bfa_fcs_rport_get_halrport(fcs_rport
)->stats
),
690 sizeof(struct bfa_rport_hal_stats_s
));
693 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
694 iocmd
->status
= BFA_STATUS_OK
;
700 bfad_iocmd_rport_clr_stats(struct bfad_s
*bfad
, void *cmd
)
702 struct bfa_bsg_rport_reset_stats_s
*iocmd
=
703 (struct bfa_bsg_rport_reset_stats_s
*)cmd
;
704 struct bfa_fcs_lport_s
*fcs_port
;
705 struct bfa_fcs_rport_s
*fcs_rport
;
706 struct bfa_rport_s
*rport
;
709 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
710 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
711 iocmd
->vf_id
, iocmd
->pwwn
);
712 if (fcs_port
== NULL
) {
713 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
714 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
718 fcs_rport
= bfa_fcs_rport_lookup(fcs_port
, iocmd
->rpwwn
);
719 if (fcs_rport
== NULL
) {
720 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
721 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
725 memset((char *)&fcs_rport
->stats
, 0, sizeof(struct bfa_rport_stats_s
));
726 rport
= bfa_fcs_rport_get_halrport(fcs_rport
);
728 memset(&rport
->stats
, 0, sizeof(rport
->stats
));
729 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
730 iocmd
->status
= BFA_STATUS_OK
;
736 bfad_iocmd_rport_set_speed(struct bfad_s
*bfad
, void *cmd
)
738 struct bfa_bsg_rport_set_speed_s
*iocmd
=
739 (struct bfa_bsg_rport_set_speed_s
*)cmd
;
740 struct bfa_fcs_lport_s
*fcs_port
;
741 struct bfa_fcs_rport_s
*fcs_rport
;
744 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
745 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
746 iocmd
->vf_id
, iocmd
->pwwn
);
747 if (fcs_port
== NULL
) {
748 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
749 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
753 fcs_rport
= bfa_fcs_rport_lookup(fcs_port
, iocmd
->rpwwn
);
754 if (fcs_rport
== NULL
) {
755 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
756 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
760 fcs_rport
->rpf
.assigned_speed
= iocmd
->speed
;
761 /* Set this speed in f/w only if the RPSC speed is not available */
762 if (fcs_rport
->rpf
.rpsc_speed
== BFA_PORT_SPEED_UNKNOWN
)
763 if (fcs_rport
->bfa_rport
)
764 bfa_rport_speed(fcs_rport
->bfa_rport
, iocmd
->speed
);
765 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
766 iocmd
->status
= BFA_STATUS_OK
;
772 bfad_iocmd_vport_get_attr(struct bfad_s
*bfad
, void *cmd
)
774 struct bfa_fcs_vport_s
*fcs_vport
;
775 struct bfa_bsg_vport_attr_s
*iocmd
= (struct bfa_bsg_vport_attr_s
*)cmd
;
778 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
779 fcs_vport
= bfa_fcs_vport_lookup(&bfad
->bfa_fcs
,
780 iocmd
->vf_id
, iocmd
->vpwwn
);
781 if (fcs_vport
== NULL
) {
782 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
783 iocmd
->status
= BFA_STATUS_UNKNOWN_VWWN
;
787 bfa_fcs_vport_get_attr(fcs_vport
, &iocmd
->vport_attr
);
788 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
789 iocmd
->status
= BFA_STATUS_OK
;
795 bfad_iocmd_vport_get_stats(struct bfad_s
*bfad
, void *cmd
)
797 struct bfa_fcs_vport_s
*fcs_vport
;
798 struct bfa_bsg_vport_stats_s
*iocmd
=
799 (struct bfa_bsg_vport_stats_s
*)cmd
;
802 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
803 fcs_vport
= bfa_fcs_vport_lookup(&bfad
->bfa_fcs
,
804 iocmd
->vf_id
, iocmd
->vpwwn
);
805 if (fcs_vport
== NULL
) {
806 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
807 iocmd
->status
= BFA_STATUS_UNKNOWN_VWWN
;
811 memcpy((void *)&iocmd
->vport_stats
, (void *)&fcs_vport
->vport_stats
,
812 sizeof(struct bfa_vport_stats_s
));
813 memcpy((void *)&iocmd
->vport_stats
.port_stats
,
814 (void *)&fcs_vport
->lport
.stats
,
815 sizeof(struct bfa_lport_stats_s
));
816 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
817 iocmd
->status
= BFA_STATUS_OK
;
823 bfad_iocmd_vport_clr_stats(struct bfad_s
*bfad
, void *cmd
)
825 struct bfa_fcs_vport_s
*fcs_vport
;
826 struct bfa_bsg_reset_stats_s
*iocmd
=
827 (struct bfa_bsg_reset_stats_s
*)cmd
;
830 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
831 fcs_vport
= bfa_fcs_vport_lookup(&bfad
->bfa_fcs
,
832 iocmd
->vf_id
, iocmd
->vpwwn
);
833 if (fcs_vport
== NULL
) {
834 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
835 iocmd
->status
= BFA_STATUS_UNKNOWN_VWWN
;
839 memset(&fcs_vport
->vport_stats
, 0, sizeof(struct bfa_vport_stats_s
));
840 memset(&fcs_vport
->lport
.stats
, 0, sizeof(struct bfa_lport_stats_s
));
841 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
842 iocmd
->status
= BFA_STATUS_OK
;
848 bfad_iocmd_fabric_get_lports(struct bfad_s
*bfad
, void *cmd
,
849 unsigned int payload_len
)
851 struct bfa_bsg_fabric_get_lports_s
*iocmd
=
852 (struct bfa_bsg_fabric_get_lports_s
*)cmd
;
853 bfa_fcs_vf_t
*fcs_vf
;
854 uint32_t nports
= iocmd
->nports
;
859 iocmd
->status
= BFA_STATUS_EINVAL
;
863 if (bfad_chk_iocmd_sz(payload_len
,
864 sizeof(struct bfa_bsg_fabric_get_lports_s
),
865 sizeof(wwn_t
[iocmd
->nports
])) != BFA_STATUS_OK
) {
866 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
870 iocmd_bufptr
= (char *)iocmd
+
871 sizeof(struct bfa_bsg_fabric_get_lports_s
);
873 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
874 fcs_vf
= bfa_fcs_vf_lookup(&bfad
->bfa_fcs
, iocmd
->vf_id
);
875 if (fcs_vf
== NULL
) {
876 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
877 iocmd
->status
= BFA_STATUS_UNKNOWN_VFID
;
880 bfa_fcs_vf_get_ports(fcs_vf
, (wwn_t
*)iocmd_bufptr
, &nports
);
881 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
883 iocmd
->nports
= nports
;
884 iocmd
->status
= BFA_STATUS_OK
;
890 bfad_iocmd_qos_set_bw(struct bfad_s
*bfad
, void *pcmd
)
892 struct bfa_bsg_qos_bw_s
*iocmd
= (struct bfa_bsg_qos_bw_s
*)pcmd
;
895 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
896 iocmd
->status
= bfa_fcport_set_qos_bw(&bfad
->bfa
, &iocmd
->qos_bw
);
897 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
903 bfad_iocmd_ratelim(struct bfad_s
*bfad
, unsigned int cmd
, void *pcmd
)
905 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)pcmd
;
906 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
909 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
911 if ((fcport
->cfg
.topology
== BFA_PORT_TOPOLOGY_LOOP
) &&
912 (fcport
->topology
== BFA_PORT_TOPOLOGY_LOOP
))
913 iocmd
->status
= BFA_STATUS_TOPOLOGY_LOOP
;
915 if (cmd
== IOCMD_RATELIM_ENABLE
)
916 fcport
->cfg
.ratelimit
= BFA_TRUE
;
917 else if (cmd
== IOCMD_RATELIM_DISABLE
)
918 fcport
->cfg
.ratelimit
= BFA_FALSE
;
920 if (fcport
->cfg
.trl_def_speed
== BFA_PORT_SPEED_UNKNOWN
)
921 fcport
->cfg
.trl_def_speed
= BFA_PORT_SPEED_1GBPS
;
923 iocmd
->status
= BFA_STATUS_OK
;
926 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
932 bfad_iocmd_ratelim_speed(struct bfad_s
*bfad
, unsigned int cmd
, void *pcmd
)
934 struct bfa_bsg_trl_speed_s
*iocmd
= (struct bfa_bsg_trl_speed_s
*)pcmd
;
935 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
938 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
940 /* Auto and speeds greater than the supported speed, are invalid */
941 if ((iocmd
->speed
== BFA_PORT_SPEED_AUTO
) ||
942 (iocmd
->speed
> fcport
->speed_sup
)) {
943 iocmd
->status
= BFA_STATUS_UNSUPP_SPEED
;
944 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
948 if ((fcport
->cfg
.topology
== BFA_PORT_TOPOLOGY_LOOP
) &&
949 (fcport
->topology
== BFA_PORT_TOPOLOGY_LOOP
))
950 iocmd
->status
= BFA_STATUS_TOPOLOGY_LOOP
;
952 fcport
->cfg
.trl_def_speed
= iocmd
->speed
;
953 iocmd
->status
= BFA_STATUS_OK
;
955 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
961 bfad_iocmd_cfg_fcpim(struct bfad_s
*bfad
, void *cmd
)
963 struct bfa_bsg_fcpim_s
*iocmd
= (struct bfa_bsg_fcpim_s
*)cmd
;
966 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
967 bfa_fcpim_path_tov_set(&bfad
->bfa
, iocmd
->param
);
968 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
969 iocmd
->status
= BFA_STATUS_OK
;
974 bfad_iocmd_fcpim_get_modstats(struct bfad_s
*bfad
, void *cmd
)
976 struct bfa_bsg_fcpim_modstats_s
*iocmd
=
977 (struct bfa_bsg_fcpim_modstats_s
*)cmd
;
978 struct bfa_fcpim_s
*fcpim
= BFA_FCPIM(&bfad
->bfa
);
979 struct list_head
*qe
, *qen
;
980 struct bfa_itnim_s
*itnim
;
983 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
984 /* accumulate IO stats from itnim */
985 memset((void *)&iocmd
->modstats
, 0, sizeof(struct bfa_itnim_iostats_s
));
986 list_for_each_safe(qe
, qen
, &fcpim
->itnim_q
) {
987 itnim
= (struct bfa_itnim_s
*) qe
;
988 bfa_fcpim_add_stats(&iocmd
->modstats
, &(itnim
->stats
));
990 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
991 iocmd
->status
= BFA_STATUS_OK
;
996 bfad_iocmd_fcpim_clr_modstats(struct bfad_s
*bfad
, void *cmd
)
998 struct bfa_bsg_fcpim_modstatsclr_s
*iocmd
=
999 (struct bfa_bsg_fcpim_modstatsclr_s
*)cmd
;
1000 struct bfa_fcpim_s
*fcpim
= BFA_FCPIM(&bfad
->bfa
);
1001 struct list_head
*qe
, *qen
;
1002 struct bfa_itnim_s
*itnim
;
1003 unsigned long flags
;
1005 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1006 list_for_each_safe(qe
, qen
, &fcpim
->itnim_q
) {
1007 itnim
= (struct bfa_itnim_s
*) qe
;
1008 bfa_itnim_clear_stats(itnim
);
1010 memset(&fcpim
->del_itn_stats
, 0,
1011 sizeof(struct bfa_fcpim_del_itn_stats_s
));
1012 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1013 iocmd
->status
= BFA_STATUS_OK
;
1018 bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s
*bfad
, void *cmd
)
1020 struct bfa_bsg_fcpim_del_itn_stats_s
*iocmd
=
1021 (struct bfa_bsg_fcpim_del_itn_stats_s
*)cmd
;
1022 struct bfa_fcpim_s
*fcpim
= BFA_FCPIM(&bfad
->bfa
);
1023 unsigned long flags
;
1025 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1026 memcpy((void *)&iocmd
->modstats
, (void *)&fcpim
->del_itn_stats
,
1027 sizeof(struct bfa_fcpim_del_itn_stats_s
));
1028 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1030 iocmd
->status
= BFA_STATUS_OK
;
1035 bfad_iocmd_itnim_get_attr(struct bfad_s
*bfad
, void *cmd
)
1037 struct bfa_bsg_itnim_attr_s
*iocmd
= (struct bfa_bsg_itnim_attr_s
*)cmd
;
1038 struct bfa_fcs_lport_s
*fcs_port
;
1039 unsigned long flags
;
1041 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1042 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
1043 iocmd
->vf_id
, iocmd
->lpwwn
);
1045 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
1047 iocmd
->status
= bfa_fcs_itnim_attr_get(fcs_port
,
1048 iocmd
->rpwwn
, &iocmd
->attr
);
1049 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1054 bfad_iocmd_itnim_get_iostats(struct bfad_s
*bfad
, void *cmd
)
1056 struct bfa_bsg_itnim_iostats_s
*iocmd
=
1057 (struct bfa_bsg_itnim_iostats_s
*)cmd
;
1058 struct bfa_fcs_lport_s
*fcs_port
;
1059 struct bfa_fcs_itnim_s
*itnim
;
1060 unsigned long flags
;
1062 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1063 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
1064 iocmd
->vf_id
, iocmd
->lpwwn
);
1066 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
1069 itnim
= bfa_fcs_itnim_lookup(fcs_port
, iocmd
->rpwwn
);
1071 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
1073 iocmd
->status
= BFA_STATUS_OK
;
1074 if (bfa_fcs_itnim_get_halitn(itnim
))
1075 memcpy((void *)&iocmd
->iostats
, (void *)
1076 &(bfa_fcs_itnim_get_halitn(itnim
)->stats
),
1077 sizeof(struct bfa_itnim_iostats_s
));
1080 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1085 bfad_iocmd_itnim_reset_stats(struct bfad_s
*bfad
, void *cmd
)
1087 struct bfa_bsg_rport_reset_stats_s
*iocmd
=
1088 (struct bfa_bsg_rport_reset_stats_s
*)cmd
;
1089 struct bfa_fcs_lport_s
*fcs_port
;
1090 struct bfa_fcs_itnim_s
*itnim
;
1091 unsigned long flags
;
1093 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1094 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
1095 iocmd
->vf_id
, iocmd
->pwwn
);
1097 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
1099 itnim
= bfa_fcs_itnim_lookup(fcs_port
, iocmd
->rpwwn
);
1101 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
1103 iocmd
->status
= BFA_STATUS_OK
;
1104 bfa_fcs_itnim_stats_clear(fcs_port
, iocmd
->rpwwn
);
1105 bfa_itnim_clear_stats(bfa_fcs_itnim_get_halitn(itnim
));
1108 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1114 bfad_iocmd_itnim_get_itnstats(struct bfad_s
*bfad
, void *cmd
)
1116 struct bfa_bsg_itnim_itnstats_s
*iocmd
=
1117 (struct bfa_bsg_itnim_itnstats_s
*)cmd
;
1118 struct bfa_fcs_lport_s
*fcs_port
;
1119 struct bfa_fcs_itnim_s
*itnim
;
1120 unsigned long flags
;
1122 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1123 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
1124 iocmd
->vf_id
, iocmd
->lpwwn
);
1126 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
1129 itnim
= bfa_fcs_itnim_lookup(fcs_port
, iocmd
->rpwwn
);
1131 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
1133 iocmd
->status
= BFA_STATUS_OK
;
1134 bfa_fcs_itnim_stats_get(fcs_port
, iocmd
->rpwwn
,
1138 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1143 bfad_iocmd_fcport_enable(struct bfad_s
*bfad
, void *cmd
)
1145 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
1146 unsigned long flags
;
1148 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1149 iocmd
->status
= bfa_fcport_enable(&bfad
->bfa
);
1150 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1156 bfad_iocmd_fcport_disable(struct bfad_s
*bfad
, void *cmd
)
1158 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
1159 unsigned long flags
;
1161 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1162 iocmd
->status
= bfa_fcport_disable(&bfad
->bfa
);
1163 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1169 bfad_iocmd_ioc_get_pcifn_cfg(struct bfad_s
*bfad
, void *cmd
)
1171 struct bfa_bsg_pcifn_cfg_s
*iocmd
= (struct bfa_bsg_pcifn_cfg_s
*)cmd
;
1172 struct bfad_hal_comp fcomp
;
1173 unsigned long flags
;
1175 init_completion(&fcomp
.comp
);
1176 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1177 iocmd
->status
= bfa_ablk_query(&bfad
->bfa
.modules
.ablk
,
1179 bfad_hcb_comp
, &fcomp
);
1180 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1181 if (iocmd
->status
!= BFA_STATUS_OK
)
1184 wait_for_completion(&fcomp
.comp
);
1185 iocmd
->status
= fcomp
.status
;
1191 bfad_iocmd_pcifn_create(struct bfad_s
*bfad
, void *cmd
)
1193 struct bfa_bsg_pcifn_s
*iocmd
= (struct bfa_bsg_pcifn_s
*)cmd
;
1194 struct bfad_hal_comp fcomp
;
1195 unsigned long flags
;
1197 init_completion(&fcomp
.comp
);
1198 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1199 iocmd
->status
= bfa_ablk_pf_create(&bfad
->bfa
.modules
.ablk
,
1200 &iocmd
->pcifn_id
, iocmd
->port
,
1201 iocmd
->pcifn_class
, iocmd
->bw_min
,
1202 iocmd
->bw_max
, bfad_hcb_comp
, &fcomp
);
1203 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1204 if (iocmd
->status
!= BFA_STATUS_OK
)
1207 wait_for_completion(&fcomp
.comp
);
1208 iocmd
->status
= fcomp
.status
;
1214 bfad_iocmd_pcifn_delete(struct bfad_s
*bfad
, void *cmd
)
1216 struct bfa_bsg_pcifn_s
*iocmd
= (struct bfa_bsg_pcifn_s
*)cmd
;
1217 struct bfad_hal_comp fcomp
;
1218 unsigned long flags
;
1220 init_completion(&fcomp
.comp
);
1221 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1222 iocmd
->status
= bfa_ablk_pf_delete(&bfad
->bfa
.modules
.ablk
,
1224 bfad_hcb_comp
, &fcomp
);
1225 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1226 if (iocmd
->status
!= BFA_STATUS_OK
)
1229 wait_for_completion(&fcomp
.comp
);
1230 iocmd
->status
= fcomp
.status
;
1236 bfad_iocmd_pcifn_bw(struct bfad_s
*bfad
, void *cmd
)
1238 struct bfa_bsg_pcifn_s
*iocmd
= (struct bfa_bsg_pcifn_s
*)cmd
;
1239 struct bfad_hal_comp fcomp
;
1240 unsigned long flags
;
1242 init_completion(&fcomp
.comp
);
1243 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1244 iocmd
->status
= bfa_ablk_pf_update(&bfad
->bfa
.modules
.ablk
,
1245 iocmd
->pcifn_id
, iocmd
->bw_min
,
1246 iocmd
->bw_max
, bfad_hcb_comp
, &fcomp
);
1247 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1248 bfa_trc(bfad
, iocmd
->status
);
1249 if (iocmd
->status
!= BFA_STATUS_OK
)
1252 wait_for_completion(&fcomp
.comp
);
1253 iocmd
->status
= fcomp
.status
;
1254 bfa_trc(bfad
, iocmd
->status
);
1260 bfad_iocmd_adapter_cfg_mode(struct bfad_s
*bfad
, void *cmd
)
1262 struct bfa_bsg_adapter_cfg_mode_s
*iocmd
=
1263 (struct bfa_bsg_adapter_cfg_mode_s
*)cmd
;
1264 struct bfad_hal_comp fcomp
;
1265 unsigned long flags
= 0;
1267 init_completion(&fcomp
.comp
);
1268 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1269 iocmd
->status
= bfa_ablk_adapter_config(&bfad
->bfa
.modules
.ablk
,
1270 iocmd
->cfg
.mode
, iocmd
->cfg
.max_pf
,
1271 iocmd
->cfg
.max_vf
, bfad_hcb_comp
, &fcomp
);
1272 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1273 if (iocmd
->status
!= BFA_STATUS_OK
)
1276 wait_for_completion(&fcomp
.comp
);
1277 iocmd
->status
= fcomp
.status
;
1283 bfad_iocmd_port_cfg_mode(struct bfad_s
*bfad
, void *cmd
)
1285 struct bfa_bsg_port_cfg_mode_s
*iocmd
=
1286 (struct bfa_bsg_port_cfg_mode_s
*)cmd
;
1287 struct bfad_hal_comp fcomp
;
1288 unsigned long flags
= 0;
1290 init_completion(&fcomp
.comp
);
1291 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1292 iocmd
->status
= bfa_ablk_port_config(&bfad
->bfa
.modules
.ablk
,
1293 iocmd
->instance
, iocmd
->cfg
.mode
,
1294 iocmd
->cfg
.max_pf
, iocmd
->cfg
.max_vf
,
1295 bfad_hcb_comp
, &fcomp
);
1296 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1297 if (iocmd
->status
!= BFA_STATUS_OK
)
1300 wait_for_completion(&fcomp
.comp
);
1301 iocmd
->status
= fcomp
.status
;
1307 bfad_iocmd_ablk_optrom(struct bfad_s
*bfad
, unsigned int cmd
, void *pcmd
)
1309 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)pcmd
;
1310 struct bfad_hal_comp fcomp
;
1311 unsigned long flags
;
1313 init_completion(&fcomp
.comp
);
1314 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1315 if (cmd
== IOCMD_FLASH_ENABLE_OPTROM
)
1316 iocmd
->status
= bfa_ablk_optrom_en(&bfad
->bfa
.modules
.ablk
,
1317 bfad_hcb_comp
, &fcomp
);
1319 iocmd
->status
= bfa_ablk_optrom_dis(&bfad
->bfa
.modules
.ablk
,
1320 bfad_hcb_comp
, &fcomp
);
1321 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1323 if (iocmd
->status
!= BFA_STATUS_OK
)
1326 wait_for_completion(&fcomp
.comp
);
1327 iocmd
->status
= fcomp
.status
;
1333 bfad_iocmd_faa_query(struct bfad_s
*bfad
, void *cmd
)
1335 struct bfa_bsg_faa_attr_s
*iocmd
= (struct bfa_bsg_faa_attr_s
*)cmd
;
1336 struct bfad_hal_comp fcomp
;
1337 unsigned long flags
;
1339 init_completion(&fcomp
.comp
);
1340 iocmd
->status
= BFA_STATUS_OK
;
1341 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1342 iocmd
->status
= bfa_faa_query(&bfad
->bfa
, &iocmd
->faa_attr
,
1343 bfad_hcb_comp
, &fcomp
);
1344 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1346 if (iocmd
->status
!= BFA_STATUS_OK
)
1349 wait_for_completion(&fcomp
.comp
);
1350 iocmd
->status
= fcomp
.status
;
1356 bfad_iocmd_cee_attr(struct bfad_s
*bfad
, void *cmd
, unsigned int payload_len
)
1358 struct bfa_bsg_cee_attr_s
*iocmd
=
1359 (struct bfa_bsg_cee_attr_s
*)cmd
;
1361 struct bfad_hal_comp cee_comp
;
1362 unsigned long flags
;
1364 if (bfad_chk_iocmd_sz(payload_len
,
1365 sizeof(struct bfa_bsg_cee_attr_s
),
1366 sizeof(struct bfa_cee_attr_s
)) != BFA_STATUS_OK
) {
1367 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
1371 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_cee_attr_s
);
1373 cee_comp
.status
= 0;
1374 init_completion(&cee_comp
.comp
);
1375 mutex_lock(&bfad_mutex
);
1376 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1377 iocmd
->status
= bfa_cee_get_attr(&bfad
->bfa
.modules
.cee
, iocmd_bufptr
,
1378 bfad_hcb_comp
, &cee_comp
);
1379 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1380 if (iocmd
->status
!= BFA_STATUS_OK
) {
1381 mutex_unlock(&bfad_mutex
);
1382 bfa_trc(bfad
, 0x5555);
1385 wait_for_completion(&cee_comp
.comp
);
1386 mutex_unlock(&bfad_mutex
);
1392 bfad_iocmd_cee_get_stats(struct bfad_s
*bfad
, void *cmd
,
1393 unsigned int payload_len
)
1395 struct bfa_bsg_cee_stats_s
*iocmd
=
1396 (struct bfa_bsg_cee_stats_s
*)cmd
;
1398 struct bfad_hal_comp cee_comp
;
1399 unsigned long flags
;
1401 if (bfad_chk_iocmd_sz(payload_len
,
1402 sizeof(struct bfa_bsg_cee_stats_s
),
1403 sizeof(struct bfa_cee_stats_s
)) != BFA_STATUS_OK
) {
1404 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
1408 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_cee_stats_s
);
1410 cee_comp
.status
= 0;
1411 init_completion(&cee_comp
.comp
);
1412 mutex_lock(&bfad_mutex
);
1413 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1414 iocmd
->status
= bfa_cee_get_stats(&bfad
->bfa
.modules
.cee
, iocmd_bufptr
,
1415 bfad_hcb_comp
, &cee_comp
);
1416 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1417 if (iocmd
->status
!= BFA_STATUS_OK
) {
1418 mutex_unlock(&bfad_mutex
);
1419 bfa_trc(bfad
, 0x5555);
1422 wait_for_completion(&cee_comp
.comp
);
1423 mutex_unlock(&bfad_mutex
);
1429 bfad_iocmd_cee_reset_stats(struct bfad_s
*bfad
, void *cmd
)
1431 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
1432 unsigned long flags
;
1434 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1435 iocmd
->status
= bfa_cee_reset_stats(&bfad
->bfa
.modules
.cee
, NULL
, NULL
);
1436 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1437 if (iocmd
->status
!= BFA_STATUS_OK
)
1438 bfa_trc(bfad
, 0x5555);
1443 bfad_iocmd_sfp_media(struct bfad_s
*bfad
, void *cmd
)
1445 struct bfa_bsg_sfp_media_s
*iocmd
= (struct bfa_bsg_sfp_media_s
*)cmd
;
1446 struct bfad_hal_comp fcomp
;
1447 unsigned long flags
;
1449 init_completion(&fcomp
.comp
);
1450 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1451 iocmd
->status
= bfa_sfp_media(BFA_SFP_MOD(&bfad
->bfa
), &iocmd
->media
,
1452 bfad_hcb_comp
, &fcomp
);
1453 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1454 bfa_trc(bfad
, iocmd
->status
);
1455 if (iocmd
->status
!= BFA_STATUS_SFP_NOT_READY
)
1458 wait_for_completion(&fcomp
.comp
);
1459 iocmd
->status
= fcomp
.status
;
1465 bfad_iocmd_sfp_speed(struct bfad_s
*bfad
, void *cmd
)
1467 struct bfa_bsg_sfp_speed_s
*iocmd
= (struct bfa_bsg_sfp_speed_s
*)cmd
;
1468 struct bfad_hal_comp fcomp
;
1469 unsigned long flags
;
1471 init_completion(&fcomp
.comp
);
1472 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1473 iocmd
->status
= bfa_sfp_speed(BFA_SFP_MOD(&bfad
->bfa
), iocmd
->speed
,
1474 bfad_hcb_comp
, &fcomp
);
1475 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1476 bfa_trc(bfad
, iocmd
->status
);
1477 if (iocmd
->status
!= BFA_STATUS_SFP_NOT_READY
)
1479 wait_for_completion(&fcomp
.comp
);
1480 iocmd
->status
= fcomp
.status
;
1486 bfad_iocmd_flash_get_attr(struct bfad_s
*bfad
, void *cmd
)
1488 struct bfa_bsg_flash_attr_s
*iocmd
=
1489 (struct bfa_bsg_flash_attr_s
*)cmd
;
1490 struct bfad_hal_comp fcomp
;
1491 unsigned long flags
;
1493 init_completion(&fcomp
.comp
);
1494 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1495 iocmd
->status
= bfa_flash_get_attr(BFA_FLASH(&bfad
->bfa
), &iocmd
->attr
,
1496 bfad_hcb_comp
, &fcomp
);
1497 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1498 if (iocmd
->status
!= BFA_STATUS_OK
)
1500 wait_for_completion(&fcomp
.comp
);
1501 iocmd
->status
= fcomp
.status
;
1507 bfad_iocmd_flash_erase_part(struct bfad_s
*bfad
, void *cmd
)
1509 struct bfa_bsg_flash_s
*iocmd
= (struct bfa_bsg_flash_s
*)cmd
;
1510 struct bfad_hal_comp fcomp
;
1511 unsigned long flags
;
1513 init_completion(&fcomp
.comp
);
1514 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1515 iocmd
->status
= bfa_flash_erase_part(BFA_FLASH(&bfad
->bfa
), iocmd
->type
,
1516 iocmd
->instance
, bfad_hcb_comp
, &fcomp
);
1517 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1518 if (iocmd
->status
!= BFA_STATUS_OK
)
1520 wait_for_completion(&fcomp
.comp
);
1521 iocmd
->status
= fcomp
.status
;
1527 bfad_iocmd_flash_update_part(struct bfad_s
*bfad
, void *cmd
,
1528 unsigned int payload_len
)
1530 struct bfa_bsg_flash_s
*iocmd
= (struct bfa_bsg_flash_s
*)cmd
;
1532 struct bfad_hal_comp fcomp
;
1533 unsigned long flags
;
1535 if (bfad_chk_iocmd_sz(payload_len
,
1536 sizeof(struct bfa_bsg_flash_s
),
1537 iocmd
->bufsz
) != BFA_STATUS_OK
) {
1538 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
1542 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_flash_s
);
1544 init_completion(&fcomp
.comp
);
1545 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1546 iocmd
->status
= bfa_flash_update_part(BFA_FLASH(&bfad
->bfa
),
1547 iocmd
->type
, iocmd
->instance
, iocmd_bufptr
,
1548 iocmd
->bufsz
, 0, bfad_hcb_comp
, &fcomp
);
1549 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1550 if (iocmd
->status
!= BFA_STATUS_OK
)
1552 wait_for_completion(&fcomp
.comp
);
1553 iocmd
->status
= fcomp
.status
;
1559 bfad_iocmd_flash_read_part(struct bfad_s
*bfad
, void *cmd
,
1560 unsigned int payload_len
)
1562 struct bfa_bsg_flash_s
*iocmd
= (struct bfa_bsg_flash_s
*)cmd
;
1563 struct bfad_hal_comp fcomp
;
1565 unsigned long flags
;
1567 if (bfad_chk_iocmd_sz(payload_len
,
1568 sizeof(struct bfa_bsg_flash_s
),
1569 iocmd
->bufsz
) != BFA_STATUS_OK
) {
1570 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
1574 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_flash_s
);
1576 init_completion(&fcomp
.comp
);
1577 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1578 iocmd
->status
= bfa_flash_read_part(BFA_FLASH(&bfad
->bfa
), iocmd
->type
,
1579 iocmd
->instance
, iocmd_bufptr
, iocmd
->bufsz
, 0,
1580 bfad_hcb_comp
, &fcomp
);
1581 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1582 if (iocmd
->status
!= BFA_STATUS_OK
)
1584 wait_for_completion(&fcomp
.comp
);
1585 iocmd
->status
= fcomp
.status
;
1591 bfad_iocmd_diag_temp(struct bfad_s
*bfad
, void *cmd
)
1593 struct bfa_bsg_diag_get_temp_s
*iocmd
=
1594 (struct bfa_bsg_diag_get_temp_s
*)cmd
;
1595 struct bfad_hal_comp fcomp
;
1596 unsigned long flags
;
1598 init_completion(&fcomp
.comp
);
1599 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1600 iocmd
->status
= bfa_diag_tsensor_query(BFA_DIAG_MOD(&bfad
->bfa
),
1601 &iocmd
->result
, bfad_hcb_comp
, &fcomp
);
1602 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1603 bfa_trc(bfad
, iocmd
->status
);
1604 if (iocmd
->status
!= BFA_STATUS_OK
)
1606 wait_for_completion(&fcomp
.comp
);
1607 iocmd
->status
= fcomp
.status
;
1613 bfad_iocmd_diag_memtest(struct bfad_s
*bfad
, void *cmd
)
1615 struct bfa_bsg_diag_memtest_s
*iocmd
=
1616 (struct bfa_bsg_diag_memtest_s
*)cmd
;
1617 struct bfad_hal_comp fcomp
;
1618 unsigned long flags
;
1620 init_completion(&fcomp
.comp
);
1621 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1622 iocmd
->status
= bfa_diag_memtest(BFA_DIAG_MOD(&bfad
->bfa
),
1623 &iocmd
->memtest
, iocmd
->pat
,
1624 &iocmd
->result
, bfad_hcb_comp
, &fcomp
);
1625 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1626 bfa_trc(bfad
, iocmd
->status
);
1627 if (iocmd
->status
!= BFA_STATUS_OK
)
1629 wait_for_completion(&fcomp
.comp
);
1630 iocmd
->status
= fcomp
.status
;
1636 bfad_iocmd_diag_loopback(struct bfad_s
*bfad
, void *cmd
)
1638 struct bfa_bsg_diag_loopback_s
*iocmd
=
1639 (struct bfa_bsg_diag_loopback_s
*)cmd
;
1640 struct bfad_hal_comp fcomp
;
1641 unsigned long flags
;
1643 init_completion(&fcomp
.comp
);
1644 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1645 iocmd
->status
= bfa_fcdiag_loopback(&bfad
->bfa
, iocmd
->opmode
,
1646 iocmd
->speed
, iocmd
->lpcnt
, iocmd
->pat
,
1647 &iocmd
->result
, bfad_hcb_comp
, &fcomp
);
1648 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1649 bfa_trc(bfad
, iocmd
->status
);
1650 if (iocmd
->status
!= BFA_STATUS_OK
)
1652 wait_for_completion(&fcomp
.comp
);
1653 iocmd
->status
= fcomp
.status
;
1659 bfad_iocmd_diag_fwping(struct bfad_s
*bfad
, void *cmd
)
1661 struct bfa_bsg_diag_fwping_s
*iocmd
=
1662 (struct bfa_bsg_diag_fwping_s
*)cmd
;
1663 struct bfad_hal_comp fcomp
;
1664 unsigned long flags
;
1666 init_completion(&fcomp
.comp
);
1667 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1668 iocmd
->status
= bfa_diag_fwping(BFA_DIAG_MOD(&bfad
->bfa
), iocmd
->cnt
,
1669 iocmd
->pattern
, &iocmd
->result
,
1670 bfad_hcb_comp
, &fcomp
);
1671 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1672 bfa_trc(bfad
, iocmd
->status
);
1673 if (iocmd
->status
!= BFA_STATUS_OK
)
1675 bfa_trc(bfad
, 0x77771);
1676 wait_for_completion(&fcomp
.comp
);
1677 iocmd
->status
= fcomp
.status
;
1683 bfad_iocmd_diag_queuetest(struct bfad_s
*bfad
, void *cmd
)
1685 struct bfa_bsg_diag_qtest_s
*iocmd
= (struct bfa_bsg_diag_qtest_s
*)cmd
;
1686 struct bfad_hal_comp fcomp
;
1687 unsigned long flags
;
1689 init_completion(&fcomp
.comp
);
1690 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1691 iocmd
->status
= bfa_fcdiag_queuetest(&bfad
->bfa
, iocmd
->force
,
1692 iocmd
->queue
, &iocmd
->result
,
1693 bfad_hcb_comp
, &fcomp
);
1694 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1695 if (iocmd
->status
!= BFA_STATUS_OK
)
1697 wait_for_completion(&fcomp
.comp
);
1698 iocmd
->status
= fcomp
.status
;
1704 bfad_iocmd_diag_sfp(struct bfad_s
*bfad
, void *cmd
)
1706 struct bfa_bsg_sfp_show_s
*iocmd
=
1707 (struct bfa_bsg_sfp_show_s
*)cmd
;
1708 struct bfad_hal_comp fcomp
;
1709 unsigned long flags
;
1711 init_completion(&fcomp
.comp
);
1712 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1713 iocmd
->status
= bfa_sfp_show(BFA_SFP_MOD(&bfad
->bfa
), &iocmd
->sfp
,
1714 bfad_hcb_comp
, &fcomp
);
1715 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1716 bfa_trc(bfad
, iocmd
->status
);
1717 if (iocmd
->status
!= BFA_STATUS_OK
)
1719 wait_for_completion(&fcomp
.comp
);
1720 iocmd
->status
= fcomp
.status
;
1721 bfa_trc(bfad
, iocmd
->status
);
1727 bfad_iocmd_diag_led(struct bfad_s
*bfad
, void *cmd
)
1729 struct bfa_bsg_diag_led_s
*iocmd
= (struct bfa_bsg_diag_led_s
*)cmd
;
1730 unsigned long flags
;
1732 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1733 iocmd
->status
= bfa_diag_ledtest(BFA_DIAG_MOD(&bfad
->bfa
),
1735 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1740 bfad_iocmd_diag_beacon_lport(struct bfad_s
*bfad
, void *cmd
)
1742 struct bfa_bsg_diag_beacon_s
*iocmd
=
1743 (struct bfa_bsg_diag_beacon_s
*)cmd
;
1744 unsigned long flags
;
1746 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1747 iocmd
->status
= bfa_diag_beacon_port(BFA_DIAG_MOD(&bfad
->bfa
),
1748 iocmd
->beacon
, iocmd
->link_e2e_beacon
,
1750 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1755 bfad_iocmd_diag_lb_stat(struct bfad_s
*bfad
, void *cmd
)
1757 struct bfa_bsg_diag_lb_stat_s
*iocmd
=
1758 (struct bfa_bsg_diag_lb_stat_s
*)cmd
;
1759 unsigned long flags
;
1761 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1762 iocmd
->status
= bfa_fcdiag_lb_is_running(&bfad
->bfa
);
1763 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1764 bfa_trc(bfad
, iocmd
->status
);
1770 bfad_iocmd_diag_cfg_dport(struct bfad_s
*bfad
, unsigned int cmd
, void *pcmd
)
1772 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)pcmd
;
1773 unsigned long flags
;
1774 struct bfad_hal_comp fcomp
;
1776 init_completion(&fcomp
.comp
);
1777 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1778 if (cmd
== IOCMD_DIAG_DPORT_ENABLE
)
1779 iocmd
->status
= bfa_dport_enable(&bfad
->bfa
,
1780 bfad_hcb_comp
, &fcomp
);
1781 else if (cmd
== IOCMD_DIAG_DPORT_DISABLE
)
1782 iocmd
->status
= bfa_dport_disable(&bfad
->bfa
,
1783 bfad_hcb_comp
, &fcomp
);
1786 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1789 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1791 if (iocmd
->status
!= BFA_STATUS_OK
)
1792 bfa_trc(bfad
, iocmd
->status
);
1794 wait_for_completion(&fcomp
.comp
);
1795 iocmd
->status
= fcomp
.status
;
1802 bfad_iocmd_diag_dport_get_state(struct bfad_s
*bfad
, void *pcmd
)
1804 struct bfa_bsg_diag_dport_get_state_s
*iocmd
=
1805 (struct bfa_bsg_diag_dport_get_state_s
*)pcmd
;
1806 unsigned long flags
;
1808 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1809 iocmd
->status
= bfa_dport_get_state(&bfad
->bfa
, &iocmd
->state
);
1810 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1816 bfad_iocmd_phy_get_attr(struct bfad_s
*bfad
, void *cmd
)
1818 struct bfa_bsg_phy_attr_s
*iocmd
=
1819 (struct bfa_bsg_phy_attr_s
*)cmd
;
1820 struct bfad_hal_comp fcomp
;
1821 unsigned long flags
;
1823 init_completion(&fcomp
.comp
);
1824 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1825 iocmd
->status
= bfa_phy_get_attr(BFA_PHY(&bfad
->bfa
), iocmd
->instance
,
1826 &iocmd
->attr
, bfad_hcb_comp
, &fcomp
);
1827 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1828 if (iocmd
->status
!= BFA_STATUS_OK
)
1830 wait_for_completion(&fcomp
.comp
);
1831 iocmd
->status
= fcomp
.status
;
1837 bfad_iocmd_phy_get_stats(struct bfad_s
*bfad
, void *cmd
)
1839 struct bfa_bsg_phy_stats_s
*iocmd
=
1840 (struct bfa_bsg_phy_stats_s
*)cmd
;
1841 struct bfad_hal_comp fcomp
;
1842 unsigned long flags
;
1844 init_completion(&fcomp
.comp
);
1845 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1846 iocmd
->status
= bfa_phy_get_stats(BFA_PHY(&bfad
->bfa
), iocmd
->instance
,
1847 &iocmd
->stats
, bfad_hcb_comp
, &fcomp
);
1848 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1849 if (iocmd
->status
!= BFA_STATUS_OK
)
1851 wait_for_completion(&fcomp
.comp
);
1852 iocmd
->status
= fcomp
.status
;
1858 bfad_iocmd_phy_read(struct bfad_s
*bfad
, void *cmd
, unsigned int payload_len
)
1860 struct bfa_bsg_phy_s
*iocmd
= (struct bfa_bsg_phy_s
*)cmd
;
1861 struct bfad_hal_comp fcomp
;
1863 unsigned long flags
;
1865 if (bfad_chk_iocmd_sz(payload_len
,
1866 sizeof(struct bfa_bsg_phy_s
),
1867 iocmd
->bufsz
) != BFA_STATUS_OK
) {
1868 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
1872 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_phy_s
);
1873 init_completion(&fcomp
.comp
);
1874 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1875 iocmd
->status
= bfa_phy_read(BFA_PHY(&bfad
->bfa
),
1876 iocmd
->instance
, iocmd_bufptr
, iocmd
->bufsz
,
1877 0, bfad_hcb_comp
, &fcomp
);
1878 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1879 if (iocmd
->status
!= BFA_STATUS_OK
)
1881 wait_for_completion(&fcomp
.comp
);
1882 iocmd
->status
= fcomp
.status
;
1883 if (iocmd
->status
!= BFA_STATUS_OK
)
1890 bfad_iocmd_vhba_query(struct bfad_s
*bfad
, void *cmd
)
1892 struct bfa_bsg_vhba_attr_s
*iocmd
=
1893 (struct bfa_bsg_vhba_attr_s
*)cmd
;
1894 struct bfa_vhba_attr_s
*attr
= &iocmd
->attr
;
1895 unsigned long flags
;
1897 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1898 attr
->pwwn
= bfad
->bfa
.ioc
.attr
->pwwn
;
1899 attr
->nwwn
= bfad
->bfa
.ioc
.attr
->nwwn
;
1900 attr
->plog_enabled
= (bfa_boolean_t
)bfad
->bfa
.plog
->plog_enabled
;
1901 attr
->io_profile
= bfa_fcpim_get_io_profile(&bfad
->bfa
);
1902 attr
->path_tov
= bfa_fcpim_path_tov_get(&bfad
->bfa
);
1903 iocmd
->status
= BFA_STATUS_OK
;
1904 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1909 bfad_iocmd_phy_update(struct bfad_s
*bfad
, void *cmd
, unsigned int payload_len
)
1911 struct bfa_bsg_phy_s
*iocmd
= (struct bfa_bsg_phy_s
*)cmd
;
1913 struct bfad_hal_comp fcomp
;
1914 unsigned long flags
;
1916 if (bfad_chk_iocmd_sz(payload_len
,
1917 sizeof(struct bfa_bsg_phy_s
),
1918 iocmd
->bufsz
) != BFA_STATUS_OK
) {
1919 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
1923 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_phy_s
);
1924 init_completion(&fcomp
.comp
);
1925 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1926 iocmd
->status
= bfa_phy_update(BFA_PHY(&bfad
->bfa
),
1927 iocmd
->instance
, iocmd_bufptr
, iocmd
->bufsz
,
1928 0, bfad_hcb_comp
, &fcomp
);
1929 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1930 if (iocmd
->status
!= BFA_STATUS_OK
)
1932 wait_for_completion(&fcomp
.comp
);
1933 iocmd
->status
= fcomp
.status
;
1939 bfad_iocmd_porglog_get(struct bfad_s
*bfad
, void *cmd
)
1941 struct bfa_bsg_debug_s
*iocmd
= (struct bfa_bsg_debug_s
*)cmd
;
1944 if (iocmd
->bufsz
< sizeof(struct bfa_plog_s
)) {
1945 bfa_trc(bfad
, sizeof(struct bfa_plog_s
));
1946 iocmd
->status
= BFA_STATUS_EINVAL
;
1950 iocmd
->status
= BFA_STATUS_OK
;
1951 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_debug_s
);
1952 memcpy(iocmd_bufptr
, (u8
*) &bfad
->plog_buf
, sizeof(struct bfa_plog_s
));
1957 #define BFA_DEBUG_FW_CORE_CHUNK_SZ 0x4000U /* 16K chunks for FW dump */
1959 bfad_iocmd_debug_fw_core(struct bfad_s
*bfad
, void *cmd
,
1960 unsigned int payload_len
)
1962 struct bfa_bsg_debug_s
*iocmd
= (struct bfa_bsg_debug_s
*)cmd
;
1964 unsigned long flags
;
1967 if (bfad_chk_iocmd_sz(payload_len
, sizeof(struct bfa_bsg_debug_s
),
1968 BFA_DEBUG_FW_CORE_CHUNK_SZ
) != BFA_STATUS_OK
) {
1969 iocmd
->status
= BFA_STATUS_VERSION_FAIL
;
1973 if (iocmd
->bufsz
< BFA_DEBUG_FW_CORE_CHUNK_SZ
||
1974 !IS_ALIGNED(iocmd
->bufsz
, sizeof(u16
)) ||
1975 !IS_ALIGNED(iocmd
->offset
, sizeof(u32
))) {
1976 bfa_trc(bfad
, BFA_DEBUG_FW_CORE_CHUNK_SZ
);
1977 iocmd
->status
= BFA_STATUS_EINVAL
;
1981 iocmd_bufptr
= (char *)iocmd
+ sizeof(struct bfa_bsg_debug_s
);
1982 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1983 offset
= iocmd
->offset
;
1984 iocmd
->status
= bfa_ioc_debug_fwcore(&bfad
->bfa
.ioc
, iocmd_bufptr
,
1985 &offset
, &iocmd
->bufsz
);
1986 iocmd
->offset
= offset
;
1987 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1993 bfad_iocmd_debug_ctl(struct bfad_s
*bfad
, void *cmd
, unsigned int v_cmd
)
1995 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
1996 unsigned long flags
;
1998 if (v_cmd
== IOCMD_DEBUG_FW_STATE_CLR
) {
1999 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2000 bfad
->bfa
.ioc
.dbg_fwsave_once
= BFA_TRUE
;
2001 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2002 } else if (v_cmd
== IOCMD_DEBUG_PORTLOG_CLR
)
2003 bfad
->plog_buf
.head
= bfad
->plog_buf
.tail
= 0;
2004 else if (v_cmd
== IOCMD_DEBUG_START_DTRC
)
2005 bfa_trc_init(bfad
->trcmod
);
2006 else if (v_cmd
== IOCMD_DEBUG_STOP_DTRC
)
2007 bfa_trc_stop(bfad
->trcmod
);
2009 iocmd
->status
= BFA_STATUS_OK
;
2014 bfad_iocmd_porglog_ctl(struct bfad_s
*bfad
, void *cmd
)
2016 struct bfa_bsg_portlogctl_s
*iocmd
= (struct bfa_bsg_portlogctl_s
*)cmd
;
2018 if (iocmd
->ctl
== BFA_TRUE
)
2019 bfad
->plog_buf
.plog_enabled
= 1;
2021 bfad
->plog_buf
.plog_enabled
= 0;
2023 iocmd
->status
= BFA_STATUS_OK
;
2028 bfad_iocmd_fcpim_cfg_profile(struct bfad_s
*bfad
, void *cmd
, unsigned int v_cmd
)
2030 struct bfa_bsg_fcpim_profile_s
*iocmd
=
2031 (struct bfa_bsg_fcpim_profile_s
*)cmd
;
2033 unsigned long flags
;
2035 do_gettimeofday(&tv
);
2036 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2037 if (v_cmd
== IOCMD_FCPIM_PROFILE_ON
)
2038 iocmd
->status
= bfa_fcpim_profile_on(&bfad
->bfa
, tv
.tv_sec
);
2039 else if (v_cmd
== IOCMD_FCPIM_PROFILE_OFF
)
2040 iocmd
->status
= bfa_fcpim_profile_off(&bfad
->bfa
);
2041 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2047 bfad_iocmd_itnim_get_ioprofile(struct bfad_s
*bfad
, void *cmd
)
2049 struct bfa_bsg_itnim_ioprofile_s
*iocmd
=
2050 (struct bfa_bsg_itnim_ioprofile_s
*)cmd
;
2051 struct bfa_fcs_lport_s
*fcs_port
;
2052 struct bfa_fcs_itnim_s
*itnim
;
2053 unsigned long flags
;
2055 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2056 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
,
2057 iocmd
->vf_id
, iocmd
->lpwwn
);
2059 iocmd
->status
= BFA_STATUS_UNKNOWN_LWWN
;
2061 itnim
= bfa_fcs_itnim_lookup(fcs_port
, iocmd
->rpwwn
);
2063 iocmd
->status
= BFA_STATUS_UNKNOWN_RWWN
;
2065 iocmd
->status
= bfa_itnim_get_ioprofile(
2066 bfa_fcs_itnim_get_halitn(itnim
),
2069 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2074 bfad_iocmd_fcport_get_stats(struct bfad_s
*bfad
, void *cmd
)
2076 struct bfa_bsg_fcport_stats_s
*iocmd
=
2077 (struct bfa_bsg_fcport_stats_s
*)cmd
;
2078 struct bfad_hal_comp fcomp
;
2079 unsigned long flags
;
2080 struct bfa_cb_pending_q_s cb_qe
;
2082 init_completion(&fcomp
.comp
);
2083 bfa_pending_q_init(&cb_qe
, (bfa_cb_cbfn_t
)bfad_hcb_comp
,
2084 &fcomp
, &iocmd
->stats
);
2085 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2086 iocmd
->status
= bfa_fcport_get_stats(&bfad
->bfa
, &cb_qe
);
2087 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2088 if (iocmd
->status
!= BFA_STATUS_OK
) {
2089 bfa_trc(bfad
, iocmd
->status
);
2092 wait_for_completion(&fcomp
.comp
);
2093 iocmd
->status
= fcomp
.status
;
2099 bfad_iocmd_fcport_reset_stats(struct bfad_s
*bfad
, void *cmd
)
2101 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
2102 struct bfad_hal_comp fcomp
;
2103 unsigned long flags
;
2104 struct bfa_cb_pending_q_s cb_qe
;
2106 init_completion(&fcomp
.comp
);
2107 bfa_pending_q_init(&cb_qe
, (bfa_cb_cbfn_t
)bfad_hcb_comp
, &fcomp
, NULL
);
2109 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2110 iocmd
->status
= bfa_fcport_clear_stats(&bfad
->bfa
, &cb_qe
);
2111 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2112 if (iocmd
->status
!= BFA_STATUS_OK
) {
2113 bfa_trc(bfad
, iocmd
->status
);
2116 wait_for_completion(&fcomp
.comp
);
2117 iocmd
->status
= fcomp
.status
;
2123 bfad_iocmd_boot_cfg(struct bfad_s
*bfad
, void *cmd
)
2125 struct bfa_bsg_boot_s
*iocmd
= (struct bfa_bsg_boot_s
*)cmd
;
2126 struct bfad_hal_comp fcomp
;
2127 unsigned long flags
;
2129 init_completion(&fcomp
.comp
);
2130 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2131 iocmd
->status
= bfa_flash_update_part(BFA_FLASH(&bfad
->bfa
),
2132 BFA_FLASH_PART_BOOT
, bfad
->bfa
.ioc
.port_id
,
2133 &iocmd
->cfg
, sizeof(struct bfa_boot_cfg_s
), 0,
2134 bfad_hcb_comp
, &fcomp
);
2135 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2136 if (iocmd
->status
!= BFA_STATUS_OK
)
2138 wait_for_completion(&fcomp
.comp
);
2139 iocmd
->status
= fcomp
.status
;
2145 bfad_iocmd_boot_query(struct bfad_s
*bfad
, void *cmd
)
2147 struct bfa_bsg_boot_s
*iocmd
= (struct bfa_bsg_boot_s
*)cmd
;
2148 struct bfad_hal_comp fcomp
;
2149 unsigned long flags
;
2151 init_completion(&fcomp
.comp
);
2152 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2153 iocmd
->status
= bfa_flash_read_part(BFA_FLASH(&bfad
->bfa
),
2154 BFA_FLASH_PART_BOOT
, bfad
->bfa
.ioc
.port_id
,
2155 &iocmd
->cfg
, sizeof(struct bfa_boot_cfg_s
), 0,
2156 bfad_hcb_comp
, &fcomp
);
2157 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2158 if (iocmd
->status
!= BFA_STATUS_OK
)
2160 wait_for_completion(&fcomp
.comp
);
2161 iocmd
->status
= fcomp
.status
;
2167 bfad_iocmd_preboot_query(struct bfad_s
*bfad
, void *cmd
)
2169 struct bfa_bsg_preboot_s
*iocmd
= (struct bfa_bsg_preboot_s
*)cmd
;
2170 struct bfi_iocfc_cfgrsp_s
*cfgrsp
= bfad
->bfa
.iocfc
.cfgrsp
;
2171 struct bfa_boot_pbc_s
*pbcfg
= &iocmd
->cfg
;
2172 unsigned long flags
;
2174 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2175 pbcfg
->enable
= cfgrsp
->pbc_cfg
.boot_enabled
;
2176 pbcfg
->nbluns
= cfgrsp
->pbc_cfg
.nbluns
;
2177 pbcfg
->speed
= cfgrsp
->pbc_cfg
.port_speed
;
2178 memcpy(pbcfg
->pblun
, cfgrsp
->pbc_cfg
.blun
, sizeof(pbcfg
->pblun
));
2179 iocmd
->status
= BFA_STATUS_OK
;
2180 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2186 bfad_iocmd_ethboot_cfg(struct bfad_s
*bfad
, void *cmd
)
2188 struct bfa_bsg_ethboot_s
*iocmd
= (struct bfa_bsg_ethboot_s
*)cmd
;
2189 struct bfad_hal_comp fcomp
;
2190 unsigned long flags
;
2192 init_completion(&fcomp
.comp
);
2193 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2194 iocmd
->status
= bfa_flash_update_part(BFA_FLASH(&bfad
->bfa
),
2195 BFA_FLASH_PART_PXECFG
,
2196 bfad
->bfa
.ioc
.port_id
, &iocmd
->cfg
,
2197 sizeof(struct bfa_ethboot_cfg_s
), 0,
2198 bfad_hcb_comp
, &fcomp
);
2199 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2200 if (iocmd
->status
!= BFA_STATUS_OK
)
2202 wait_for_completion(&fcomp
.comp
);
2203 iocmd
->status
= fcomp
.status
;
2209 bfad_iocmd_ethboot_query(struct bfad_s
*bfad
, void *cmd
)
2211 struct bfa_bsg_ethboot_s
*iocmd
= (struct bfa_bsg_ethboot_s
*)cmd
;
2212 struct bfad_hal_comp fcomp
;
2213 unsigned long flags
;
2215 init_completion(&fcomp
.comp
);
2216 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2217 iocmd
->status
= bfa_flash_read_part(BFA_FLASH(&bfad
->bfa
),
2218 BFA_FLASH_PART_PXECFG
,
2219 bfad
->bfa
.ioc
.port_id
, &iocmd
->cfg
,
2220 sizeof(struct bfa_ethboot_cfg_s
), 0,
2221 bfad_hcb_comp
, &fcomp
);
2222 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2223 if (iocmd
->status
!= BFA_STATUS_OK
)
2225 wait_for_completion(&fcomp
.comp
);
2226 iocmd
->status
= fcomp
.status
;
2232 bfad_iocmd_cfg_trunk(struct bfad_s
*bfad
, void *cmd
, unsigned int v_cmd
)
2234 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
2235 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
2236 struct bfa_fcport_trunk_s
*trunk
= &fcport
->trunk
;
2237 unsigned long flags
;
2239 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2241 if (bfa_fcport_is_dport(&bfad
->bfa
))
2242 return BFA_STATUS_DPORT_ERR
;
2244 if ((fcport
->cfg
.topology
== BFA_PORT_TOPOLOGY_LOOP
) ||
2245 (fcport
->topology
== BFA_PORT_TOPOLOGY_LOOP
))
2246 iocmd
->status
= BFA_STATUS_TOPOLOGY_LOOP
;
2248 if (v_cmd
== IOCMD_TRUNK_ENABLE
) {
2249 trunk
->attr
.state
= BFA_TRUNK_OFFLINE
;
2250 bfa_fcport_disable(&bfad
->bfa
);
2251 fcport
->cfg
.trunked
= BFA_TRUE
;
2252 } else if (v_cmd
== IOCMD_TRUNK_DISABLE
) {
2253 trunk
->attr
.state
= BFA_TRUNK_DISABLED
;
2254 bfa_fcport_disable(&bfad
->bfa
);
2255 fcport
->cfg
.trunked
= BFA_FALSE
;
2258 if (!bfa_fcport_is_disabled(&bfad
->bfa
))
2259 bfa_fcport_enable(&bfad
->bfa
);
2261 iocmd
->status
= BFA_STATUS_OK
;
2264 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2270 bfad_iocmd_trunk_get_attr(struct bfad_s
*bfad
, void *cmd
)
2272 struct bfa_bsg_trunk_attr_s
*iocmd
= (struct bfa_bsg_trunk_attr_s
*)cmd
;
2273 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
2274 struct bfa_fcport_trunk_s
*trunk
= &fcport
->trunk
;
2275 unsigned long flags
;
2277 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2278 if ((fcport
->cfg
.topology
== BFA_PORT_TOPOLOGY_LOOP
) ||
2279 (fcport
->topology
== BFA_PORT_TOPOLOGY_LOOP
))
2280 iocmd
->status
= BFA_STATUS_TOPOLOGY_LOOP
;
2282 memcpy((void *)&iocmd
->attr
, (void *)&trunk
->attr
,
2283 sizeof(struct bfa_trunk_attr_s
));
2284 iocmd
->attr
.port_id
= bfa_lps_get_base_pid(&bfad
->bfa
);
2285 iocmd
->status
= BFA_STATUS_OK
;
2287 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2293 bfad_iocmd_qos(struct bfad_s
*bfad
, void *cmd
, unsigned int v_cmd
)
2295 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
2296 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
2297 unsigned long flags
;
2299 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2300 if (bfa_ioc_get_type(&bfad
->bfa
.ioc
) == BFA_IOC_TYPE_FC
) {
2301 if ((fcport
->cfg
.topology
== BFA_PORT_TOPOLOGY_LOOP
) &&
2302 (fcport
->topology
== BFA_PORT_TOPOLOGY_LOOP
))
2303 iocmd
->status
= BFA_STATUS_TOPOLOGY_LOOP
;
2305 if (v_cmd
== IOCMD_QOS_ENABLE
)
2306 fcport
->cfg
.qos_enabled
= BFA_TRUE
;
2307 else if (v_cmd
== IOCMD_QOS_DISABLE
) {
2308 fcport
->cfg
.qos_enabled
= BFA_FALSE
;
2309 fcport
->cfg
.qos_bw
.high
= BFA_QOS_BW_HIGH
;
2310 fcport
->cfg
.qos_bw
.med
= BFA_QOS_BW_MED
;
2311 fcport
->cfg
.qos_bw
.low
= BFA_QOS_BW_LOW
;
2315 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2321 bfad_iocmd_qos_get_attr(struct bfad_s
*bfad
, void *cmd
)
2323 struct bfa_bsg_qos_attr_s
*iocmd
= (struct bfa_bsg_qos_attr_s
*)cmd
;
2324 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
2325 unsigned long flags
;
2327 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2328 if ((fcport
->cfg
.topology
== BFA_PORT_TOPOLOGY_LOOP
) &&
2329 (fcport
->topology
== BFA_PORT_TOPOLOGY_LOOP
))
2330 iocmd
->status
= BFA_STATUS_TOPOLOGY_LOOP
;
2332 iocmd
->attr
.state
= fcport
->qos_attr
.state
;
2333 iocmd
->attr
.total_bb_cr
=
2334 be32_to_cpu(fcport
->qos_attr
.total_bb_cr
);
2335 iocmd
->attr
.qos_bw
.high
= fcport
->cfg
.qos_bw
.high
;
2336 iocmd
->attr
.qos_bw
.med
= fcport
->cfg
.qos_bw
.med
;
2337 iocmd
->attr
.qos_bw
.low
= fcport
->cfg
.qos_bw
.low
;
2338 iocmd
->attr
.qos_bw_op
= fcport
->qos_attr
.qos_bw_op
;
2339 iocmd
->status
= BFA_STATUS_OK
;
2341 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2347 bfad_iocmd_qos_get_vc_attr(struct bfad_s
*bfad
, void *cmd
)
2349 struct bfa_bsg_qos_vc_attr_s
*iocmd
=
2350 (struct bfa_bsg_qos_vc_attr_s
*)cmd
;
2351 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
2352 struct bfa_qos_vc_attr_s
*bfa_vc_attr
= &fcport
->qos_vc_attr
;
2353 unsigned long flags
;
2356 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2357 iocmd
->attr
.total_vc_count
= be16_to_cpu(bfa_vc_attr
->total_vc_count
);
2358 iocmd
->attr
.shared_credit
= be16_to_cpu(bfa_vc_attr
->shared_credit
);
2359 iocmd
->attr
.elp_opmode_flags
=
2360 be32_to_cpu(bfa_vc_attr
->elp_opmode_flags
);
2362 /* Individual VC info */
2363 while (i
< iocmd
->attr
.total_vc_count
) {
2364 iocmd
->attr
.vc_info
[i
].vc_credit
=
2365 bfa_vc_attr
->vc_info
[i
].vc_credit
;
2366 iocmd
->attr
.vc_info
[i
].borrow_credit
=
2367 bfa_vc_attr
->vc_info
[i
].borrow_credit
;
2368 iocmd
->attr
.vc_info
[i
].priority
=
2369 bfa_vc_attr
->vc_info
[i
].priority
;
2372 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2374 iocmd
->status
= BFA_STATUS_OK
;
2379 bfad_iocmd_qos_get_stats(struct bfad_s
*bfad
, void *cmd
)
2381 struct bfa_bsg_fcport_stats_s
*iocmd
=
2382 (struct bfa_bsg_fcport_stats_s
*)cmd
;
2383 struct bfad_hal_comp fcomp
;
2384 unsigned long flags
;
2385 struct bfa_cb_pending_q_s cb_qe
;
2386 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
2388 init_completion(&fcomp
.comp
);
2389 bfa_pending_q_init(&cb_qe
, (bfa_cb_cbfn_t
)bfad_hcb_comp
,
2390 &fcomp
, &iocmd
->stats
);
2392 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2393 WARN_ON(!bfa_ioc_get_fcmode(&bfad
->bfa
.ioc
));
2394 if ((fcport
->cfg
.topology
== BFA_PORT_TOPOLOGY_LOOP
) &&
2395 (fcport
->topology
== BFA_PORT_TOPOLOGY_LOOP
))
2396 iocmd
->status
= BFA_STATUS_TOPOLOGY_LOOP
;
2398 iocmd
->status
= bfa_fcport_get_stats(&bfad
->bfa
, &cb_qe
);
2399 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2400 if (iocmd
->status
!= BFA_STATUS_OK
) {
2401 bfa_trc(bfad
, iocmd
->status
);
2404 wait_for_completion(&fcomp
.comp
);
2405 iocmd
->status
= fcomp
.status
;
2411 bfad_iocmd_qos_reset_stats(struct bfad_s
*bfad
, void *cmd
)
2413 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)cmd
;
2414 struct bfad_hal_comp fcomp
;
2415 unsigned long flags
;
2416 struct bfa_cb_pending_q_s cb_qe
;
2417 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
2419 init_completion(&fcomp
.comp
);
2420 bfa_pending_q_init(&cb_qe
, (bfa_cb_cbfn_t
)bfad_hcb_comp
,
2423 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2424 WARN_ON(!bfa_ioc_get_fcmode(&bfad
->bfa
.ioc
));
2425 if ((fcport
->cfg
.topology
== BFA_PORT_TOPOLOGY_LOOP
) &&
2426 (fcport
->topology
== BFA_PORT_TOPOLOGY_LOOP
))
2427 iocmd
->status
= BFA_STATUS_TOPOLOGY_LOOP
;
2429 iocmd
->status
= bfa_fcport_clear_stats(&bfad
->bfa
, &cb_qe
);
2430 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2431 if (iocmd
->status
!= BFA_STATUS_OK
) {
2432 bfa_trc(bfad
, iocmd
->status
);
2435 wait_for_completion(&fcomp
.comp
);
2436 iocmd
->status
= fcomp
.status
;
2442 bfad_iocmd_vf_get_stats(struct bfad_s
*bfad
, void *cmd
)
2444 struct bfa_bsg_vf_stats_s
*iocmd
=
2445 (struct bfa_bsg_vf_stats_s
*)cmd
;
2446 struct bfa_fcs_fabric_s
*fcs_vf
;
2447 unsigned long flags
;
2449 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2450 fcs_vf
= bfa_fcs_vf_lookup(&bfad
->bfa_fcs
, iocmd
->vf_id
);
2451 if (fcs_vf
== NULL
) {
2452 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2453 iocmd
->status
= BFA_STATUS_UNKNOWN_VFID
;
2456 memcpy((void *)&iocmd
->stats
, (void *)&fcs_vf
->stats
,
2457 sizeof(struct bfa_vf_stats_s
));
2458 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2459 iocmd
->status
= BFA_STATUS_OK
;
2465 bfad_iocmd_vf_clr_stats(struct bfad_s
*bfad
, void *cmd
)
2467 struct bfa_bsg_vf_reset_stats_s
*iocmd
=
2468 (struct bfa_bsg_vf_reset_stats_s
*)cmd
;
2469 struct bfa_fcs_fabric_s
*fcs_vf
;
2470 unsigned long flags
;
2472 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2473 fcs_vf
= bfa_fcs_vf_lookup(&bfad
->bfa_fcs
, iocmd
->vf_id
);
2474 if (fcs_vf
== NULL
) {
2475 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2476 iocmd
->status
= BFA_STATUS_UNKNOWN_VFID
;
2479 memset((void *)&fcs_vf
->stats
, 0, sizeof(struct bfa_vf_stats_s
));
2480 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2481 iocmd
->status
= BFA_STATUS_OK
;
2486 /* Function to reset the LUN SCAN mode */
2488 bfad_iocmd_lunmask_reset_lunscan_mode(struct bfad_s
*bfad
, int lunmask_cfg
)
2490 struct bfad_im_port_s
*pport_im
= bfad
->pport
.im_port
;
2491 struct bfad_vport_s
*vport
= NULL
;
2493 /* Set the scsi device LUN SCAN flags for base port */
2494 bfad_reset_sdev_bflags(pport_im
, lunmask_cfg
);
2496 /* Set the scsi device LUN SCAN flags for the vports */
2497 list_for_each_entry(vport
, &bfad
->vport_list
, list_entry
)
2498 bfad_reset_sdev_bflags(vport
->drv_port
.im_port
, lunmask_cfg
);
2502 bfad_iocmd_lunmask(struct bfad_s
*bfad
, void *pcmd
, unsigned int v_cmd
)
2504 struct bfa_bsg_gen_s
*iocmd
= (struct bfa_bsg_gen_s
*)pcmd
;
2505 unsigned long flags
;
2507 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2508 if (v_cmd
== IOCMD_FCPIM_LUNMASK_ENABLE
) {
2509 iocmd
->status
= bfa_fcpim_lunmask_update(&bfad
->bfa
, BFA_TRUE
);
2510 /* Set the LUN Scanning mode to be Sequential scan */
2511 if (iocmd
->status
== BFA_STATUS_OK
)
2512 bfad_iocmd_lunmask_reset_lunscan_mode(bfad
, BFA_TRUE
);
2513 } else if (v_cmd
== IOCMD_FCPIM_LUNMASK_DISABLE
) {
2514 iocmd
->status
= bfa_fcpim_lunmask_update(&bfad
->bfa
, BFA_FALSE
);
2515 /* Set the LUN Scanning mode to default REPORT_LUNS scan */
2516 if (iocmd
->status
== BFA_STATUS_OK
)
2517 bfad_iocmd_lunmask_reset_lunscan_mode(bfad
, BFA_FALSE
);
2518 } else if (v_cmd
== IOCMD_FCPIM_LUNMASK_CLEAR
)
2519 iocmd
->status
= bfa_fcpim_lunmask_clear(&bfad
->bfa
);
2520 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2525 bfad_iocmd_fcpim_lunmask_query(struct bfad_s
*bfad
, void *cmd
)
2527 struct bfa_bsg_fcpim_lunmask_query_s
*iocmd
=
2528 (struct bfa_bsg_fcpim_lunmask_query_s
*)cmd
;
2529 struct bfa_lunmask_cfg_s
*lun_mask
= &iocmd
->lun_mask
;
2530 unsigned long flags
;
2532 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2533 iocmd
->status
= bfa_fcpim_lunmask_query(&bfad
->bfa
, lun_mask
);
2534 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2539 bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s
*bfad
, void *cmd
, unsigned int v_cmd
)
2541 struct bfa_bsg_fcpim_lunmask_s
*iocmd
=
2542 (struct bfa_bsg_fcpim_lunmask_s
*)cmd
;
2543 unsigned long flags
;
2545 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2546 if (v_cmd
== IOCMD_FCPIM_LUNMASK_ADD
)
2547 iocmd
->status
= bfa_fcpim_lunmask_add(&bfad
->bfa
, iocmd
->vf_id
,
2548 &iocmd
->pwwn
, iocmd
->rpwwn
, iocmd
->lun
);
2549 else if (v_cmd
== IOCMD_FCPIM_LUNMASK_DELETE
)
2550 iocmd
->status
= bfa_fcpim_lunmask_delete(&bfad
->bfa
,
2551 iocmd
->vf_id
, &iocmd
->pwwn
,
2552 iocmd
->rpwwn
, iocmd
->lun
);
2553 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2558 bfad_iocmd_fcpim_throttle_query(struct bfad_s
*bfad
, void *cmd
)
2560 struct bfa_bsg_fcpim_throttle_s
*iocmd
=
2561 (struct bfa_bsg_fcpim_throttle_s
*)cmd
;
2562 unsigned long flags
;
2564 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2565 iocmd
->status
= bfa_fcpim_throttle_get(&bfad
->bfa
,
2566 (void *)&iocmd
->throttle
);
2567 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2573 bfad_iocmd_fcpim_throttle_set(struct bfad_s
*bfad
, void *cmd
)
2575 struct bfa_bsg_fcpim_throttle_s
*iocmd
=
2576 (struct bfa_bsg_fcpim_throttle_s
*)cmd
;
2577 unsigned long flags
;
2579 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2580 iocmd
->status
= bfa_fcpim_throttle_set(&bfad
->bfa
,
2581 iocmd
->throttle
.cfg_value
);
2582 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2588 bfad_iocmd_tfru_read(struct bfad_s
*bfad
, void *cmd
)
2590 struct bfa_bsg_tfru_s
*iocmd
=
2591 (struct bfa_bsg_tfru_s
*)cmd
;
2592 struct bfad_hal_comp fcomp
;
2593 unsigned long flags
= 0;
2595 init_completion(&fcomp
.comp
);
2596 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2597 iocmd
->status
= bfa_tfru_read(BFA_FRU(&bfad
->bfa
),
2598 &iocmd
->data
, iocmd
->len
, iocmd
->offset
,
2599 bfad_hcb_comp
, &fcomp
);
2600 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2601 if (iocmd
->status
== BFA_STATUS_OK
) {
2602 wait_for_completion(&fcomp
.comp
);
2603 iocmd
->status
= fcomp
.status
;
2610 bfad_iocmd_tfru_write(struct bfad_s
*bfad
, void *cmd
)
2612 struct bfa_bsg_tfru_s
*iocmd
=
2613 (struct bfa_bsg_tfru_s
*)cmd
;
2614 struct bfad_hal_comp fcomp
;
2615 unsigned long flags
= 0;
2617 init_completion(&fcomp
.comp
);
2618 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2619 iocmd
->status
= bfa_tfru_write(BFA_FRU(&bfad
->bfa
),
2620 &iocmd
->data
, iocmd
->len
, iocmd
->offset
,
2621 bfad_hcb_comp
, &fcomp
);
2622 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2623 if (iocmd
->status
== BFA_STATUS_OK
) {
2624 wait_for_completion(&fcomp
.comp
);
2625 iocmd
->status
= fcomp
.status
;
2632 bfad_iocmd_fruvpd_read(struct bfad_s
*bfad
, void *cmd
)
2634 struct bfa_bsg_fruvpd_s
*iocmd
=
2635 (struct bfa_bsg_fruvpd_s
*)cmd
;
2636 struct bfad_hal_comp fcomp
;
2637 unsigned long flags
= 0;
2639 init_completion(&fcomp
.comp
);
2640 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2641 iocmd
->status
= bfa_fruvpd_read(BFA_FRU(&bfad
->bfa
),
2642 &iocmd
->data
, iocmd
->len
, iocmd
->offset
,
2643 bfad_hcb_comp
, &fcomp
);
2644 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2645 if (iocmd
->status
== BFA_STATUS_OK
) {
2646 wait_for_completion(&fcomp
.comp
);
2647 iocmd
->status
= fcomp
.status
;
2654 bfad_iocmd_fruvpd_update(struct bfad_s
*bfad
, void *cmd
)
2656 struct bfa_bsg_fruvpd_s
*iocmd
=
2657 (struct bfa_bsg_fruvpd_s
*)cmd
;
2658 struct bfad_hal_comp fcomp
;
2659 unsigned long flags
= 0;
2661 init_completion(&fcomp
.comp
);
2662 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2663 iocmd
->status
= bfa_fruvpd_update(BFA_FRU(&bfad
->bfa
),
2664 &iocmd
->data
, iocmd
->len
, iocmd
->offset
,
2665 bfad_hcb_comp
, &fcomp
);
2666 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2667 if (iocmd
->status
== BFA_STATUS_OK
) {
2668 wait_for_completion(&fcomp
.comp
);
2669 iocmd
->status
= fcomp
.status
;
2676 bfad_iocmd_fruvpd_get_max_size(struct bfad_s
*bfad
, void *cmd
)
2678 struct bfa_bsg_fruvpd_max_size_s
*iocmd
=
2679 (struct bfa_bsg_fruvpd_max_size_s
*)cmd
;
2680 unsigned long flags
= 0;
2682 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
2683 iocmd
->status
= bfa_fruvpd_get_max_size(BFA_FRU(&bfad
->bfa
),
2685 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
2691 bfad_iocmd_handler(struct bfad_s
*bfad
, unsigned int cmd
, void *iocmd
,
2692 unsigned int payload_len
)
2697 case IOCMD_IOC_ENABLE
:
2698 rc
= bfad_iocmd_ioc_enable(bfad
, iocmd
);
2700 case IOCMD_IOC_DISABLE
:
2701 rc
= bfad_iocmd_ioc_disable(bfad
, iocmd
);
2703 case IOCMD_IOC_GET_INFO
:
2704 rc
= bfad_iocmd_ioc_get_info(bfad
, iocmd
);
2706 case IOCMD_IOC_GET_ATTR
:
2707 rc
= bfad_iocmd_ioc_get_attr(bfad
, iocmd
);
2709 case IOCMD_IOC_GET_STATS
:
2710 rc
= bfad_iocmd_ioc_get_stats(bfad
, iocmd
);
2712 case IOCMD_IOC_GET_FWSTATS
:
2713 rc
= bfad_iocmd_ioc_get_fwstats(bfad
, iocmd
, payload_len
);
2715 case IOCMD_IOC_RESET_STATS
:
2716 case IOCMD_IOC_RESET_FWSTATS
:
2717 rc
= bfad_iocmd_ioc_reset_stats(bfad
, iocmd
, cmd
);
2719 case IOCMD_IOC_SET_ADAPTER_NAME
:
2720 case IOCMD_IOC_SET_PORT_NAME
:
2721 rc
= bfad_iocmd_ioc_set_name(bfad
, iocmd
, cmd
);
2723 case IOCMD_IOCFC_GET_ATTR
:
2724 rc
= bfad_iocmd_iocfc_get_attr(bfad
, iocmd
);
2726 case IOCMD_IOCFC_SET_INTR
:
2727 rc
= bfad_iocmd_iocfc_set_intr(bfad
, iocmd
);
2729 case IOCMD_PORT_ENABLE
:
2730 rc
= bfad_iocmd_port_enable(bfad
, iocmd
);
2732 case IOCMD_PORT_DISABLE
:
2733 rc
= bfad_iocmd_port_disable(bfad
, iocmd
);
2735 case IOCMD_PORT_GET_ATTR
:
2736 rc
= bfad_iocmd_port_get_attr(bfad
, iocmd
);
2738 case IOCMD_PORT_GET_STATS
:
2739 rc
= bfad_iocmd_port_get_stats(bfad
, iocmd
, payload_len
);
2741 case IOCMD_PORT_RESET_STATS
:
2742 rc
= bfad_iocmd_port_reset_stats(bfad
, iocmd
);
2744 case IOCMD_PORT_CFG_TOPO
:
2745 case IOCMD_PORT_CFG_SPEED
:
2746 case IOCMD_PORT_CFG_ALPA
:
2747 case IOCMD_PORT_CLR_ALPA
:
2748 rc
= bfad_iocmd_set_port_cfg(bfad
, iocmd
, cmd
);
2750 case IOCMD_PORT_CFG_MAXFRSZ
:
2751 rc
= bfad_iocmd_port_cfg_maxfrsize(bfad
, iocmd
);
2753 case IOCMD_PORT_BBSC_ENABLE
:
2754 case IOCMD_PORT_BBSC_DISABLE
:
2755 rc
= bfad_iocmd_port_cfg_bbsc(bfad
, iocmd
, cmd
);
2757 case IOCMD_LPORT_GET_ATTR
:
2758 rc
= bfad_iocmd_lport_get_attr(bfad
, iocmd
);
2760 case IOCMD_LPORT_GET_STATS
:
2761 rc
= bfad_iocmd_lport_get_stats(bfad
, iocmd
);
2763 case IOCMD_LPORT_RESET_STATS
:
2764 rc
= bfad_iocmd_lport_reset_stats(bfad
, iocmd
);
2766 case IOCMD_LPORT_GET_IOSTATS
:
2767 rc
= bfad_iocmd_lport_get_iostats(bfad
, iocmd
);
2769 case IOCMD_LPORT_GET_RPORTS
:
2770 rc
= bfad_iocmd_lport_get_rports(bfad
, iocmd
, payload_len
);
2772 case IOCMD_RPORT_GET_ATTR
:
2773 rc
= bfad_iocmd_rport_get_attr(bfad
, iocmd
);
2775 case IOCMD_RPORT_GET_ADDR
:
2776 rc
= bfad_iocmd_rport_get_addr(bfad
, iocmd
);
2778 case IOCMD_RPORT_GET_STATS
:
2779 rc
= bfad_iocmd_rport_get_stats(bfad
, iocmd
);
2781 case IOCMD_RPORT_RESET_STATS
:
2782 rc
= bfad_iocmd_rport_clr_stats(bfad
, iocmd
);
2784 case IOCMD_RPORT_SET_SPEED
:
2785 rc
= bfad_iocmd_rport_set_speed(bfad
, iocmd
);
2787 case IOCMD_VPORT_GET_ATTR
:
2788 rc
= bfad_iocmd_vport_get_attr(bfad
, iocmd
);
2790 case IOCMD_VPORT_GET_STATS
:
2791 rc
= bfad_iocmd_vport_get_stats(bfad
, iocmd
);
2793 case IOCMD_VPORT_RESET_STATS
:
2794 rc
= bfad_iocmd_vport_clr_stats(bfad
, iocmd
);
2796 case IOCMD_FABRIC_GET_LPORTS
:
2797 rc
= bfad_iocmd_fabric_get_lports(bfad
, iocmd
, payload_len
);
2799 case IOCMD_RATELIM_ENABLE
:
2800 case IOCMD_RATELIM_DISABLE
:
2801 rc
= bfad_iocmd_ratelim(bfad
, cmd
, iocmd
);
2803 case IOCMD_RATELIM_DEF_SPEED
:
2804 rc
= bfad_iocmd_ratelim_speed(bfad
, cmd
, iocmd
);
2806 case IOCMD_FCPIM_FAILOVER
:
2807 rc
= bfad_iocmd_cfg_fcpim(bfad
, iocmd
);
2809 case IOCMD_FCPIM_MODSTATS
:
2810 rc
= bfad_iocmd_fcpim_get_modstats(bfad
, iocmd
);
2812 case IOCMD_FCPIM_MODSTATSCLR
:
2813 rc
= bfad_iocmd_fcpim_clr_modstats(bfad
, iocmd
);
2815 case IOCMD_FCPIM_DEL_ITN_STATS
:
2816 rc
= bfad_iocmd_fcpim_get_del_itn_stats(bfad
, iocmd
);
2818 case IOCMD_ITNIM_GET_ATTR
:
2819 rc
= bfad_iocmd_itnim_get_attr(bfad
, iocmd
);
2821 case IOCMD_ITNIM_GET_IOSTATS
:
2822 rc
= bfad_iocmd_itnim_get_iostats(bfad
, iocmd
);
2824 case IOCMD_ITNIM_RESET_STATS
:
2825 rc
= bfad_iocmd_itnim_reset_stats(bfad
, iocmd
);
2827 case IOCMD_ITNIM_GET_ITNSTATS
:
2828 rc
= bfad_iocmd_itnim_get_itnstats(bfad
, iocmd
);
2830 case IOCMD_FCPORT_ENABLE
:
2831 rc
= bfad_iocmd_fcport_enable(bfad
, iocmd
);
2833 case IOCMD_FCPORT_DISABLE
:
2834 rc
= bfad_iocmd_fcport_disable(bfad
, iocmd
);
2836 case IOCMD_IOC_PCIFN_CFG
:
2837 rc
= bfad_iocmd_ioc_get_pcifn_cfg(bfad
, iocmd
);
2839 case IOCMD_PCIFN_CREATE
:
2840 rc
= bfad_iocmd_pcifn_create(bfad
, iocmd
);
2842 case IOCMD_PCIFN_DELETE
:
2843 rc
= bfad_iocmd_pcifn_delete(bfad
, iocmd
);
2845 case IOCMD_PCIFN_BW
:
2846 rc
= bfad_iocmd_pcifn_bw(bfad
, iocmd
);
2848 case IOCMD_ADAPTER_CFG_MODE
:
2849 rc
= bfad_iocmd_adapter_cfg_mode(bfad
, iocmd
);
2851 case IOCMD_PORT_CFG_MODE
:
2852 rc
= bfad_iocmd_port_cfg_mode(bfad
, iocmd
);
2854 case IOCMD_FLASH_ENABLE_OPTROM
:
2855 case IOCMD_FLASH_DISABLE_OPTROM
:
2856 rc
= bfad_iocmd_ablk_optrom(bfad
, cmd
, iocmd
);
2858 case IOCMD_FAA_QUERY
:
2859 rc
= bfad_iocmd_faa_query(bfad
, iocmd
);
2861 case IOCMD_CEE_GET_ATTR
:
2862 rc
= bfad_iocmd_cee_attr(bfad
, iocmd
, payload_len
);
2864 case IOCMD_CEE_GET_STATS
:
2865 rc
= bfad_iocmd_cee_get_stats(bfad
, iocmd
, payload_len
);
2867 case IOCMD_CEE_RESET_STATS
:
2868 rc
= bfad_iocmd_cee_reset_stats(bfad
, iocmd
);
2870 case IOCMD_SFP_MEDIA
:
2871 rc
= bfad_iocmd_sfp_media(bfad
, iocmd
);
2873 case IOCMD_SFP_SPEED
:
2874 rc
= bfad_iocmd_sfp_speed(bfad
, iocmd
);
2876 case IOCMD_FLASH_GET_ATTR
:
2877 rc
= bfad_iocmd_flash_get_attr(bfad
, iocmd
);
2879 case IOCMD_FLASH_ERASE_PART
:
2880 rc
= bfad_iocmd_flash_erase_part(bfad
, iocmd
);
2882 case IOCMD_FLASH_UPDATE_PART
:
2883 rc
= bfad_iocmd_flash_update_part(bfad
, iocmd
, payload_len
);
2885 case IOCMD_FLASH_READ_PART
:
2886 rc
= bfad_iocmd_flash_read_part(bfad
, iocmd
, payload_len
);
2888 case IOCMD_DIAG_TEMP
:
2889 rc
= bfad_iocmd_diag_temp(bfad
, iocmd
);
2891 case IOCMD_DIAG_MEMTEST
:
2892 rc
= bfad_iocmd_diag_memtest(bfad
, iocmd
);
2894 case IOCMD_DIAG_LOOPBACK
:
2895 rc
= bfad_iocmd_diag_loopback(bfad
, iocmd
);
2897 case IOCMD_DIAG_FWPING
:
2898 rc
= bfad_iocmd_diag_fwping(bfad
, iocmd
);
2900 case IOCMD_DIAG_QUEUETEST
:
2901 rc
= bfad_iocmd_diag_queuetest(bfad
, iocmd
);
2903 case IOCMD_DIAG_SFP
:
2904 rc
= bfad_iocmd_diag_sfp(bfad
, iocmd
);
2906 case IOCMD_DIAG_LED
:
2907 rc
= bfad_iocmd_diag_led(bfad
, iocmd
);
2909 case IOCMD_DIAG_BEACON_LPORT
:
2910 rc
= bfad_iocmd_diag_beacon_lport(bfad
, iocmd
);
2912 case IOCMD_DIAG_LB_STAT
:
2913 rc
= bfad_iocmd_diag_lb_stat(bfad
, iocmd
);
2915 case IOCMD_DIAG_DPORT_ENABLE
:
2916 case IOCMD_DIAG_DPORT_DISABLE
:
2917 rc
= bfad_iocmd_diag_cfg_dport(bfad
, cmd
, iocmd
);
2919 case IOCMD_DIAG_DPORT_GET_STATE
:
2920 rc
= bfad_iocmd_diag_dport_get_state(bfad
, iocmd
);
2922 case IOCMD_PHY_GET_ATTR
:
2923 rc
= bfad_iocmd_phy_get_attr(bfad
, iocmd
);
2925 case IOCMD_PHY_GET_STATS
:
2926 rc
= bfad_iocmd_phy_get_stats(bfad
, iocmd
);
2928 case IOCMD_PHY_UPDATE_FW
:
2929 rc
= bfad_iocmd_phy_update(bfad
, iocmd
, payload_len
);
2931 case IOCMD_PHY_READ_FW
:
2932 rc
= bfad_iocmd_phy_read(bfad
, iocmd
, payload_len
);
2934 case IOCMD_VHBA_QUERY
:
2935 rc
= bfad_iocmd_vhba_query(bfad
, iocmd
);
2937 case IOCMD_DEBUG_PORTLOG
:
2938 rc
= bfad_iocmd_porglog_get(bfad
, iocmd
);
2940 case IOCMD_DEBUG_FW_CORE
:
2941 rc
= bfad_iocmd_debug_fw_core(bfad
, iocmd
, payload_len
);
2943 case IOCMD_DEBUG_FW_STATE_CLR
:
2944 case IOCMD_DEBUG_PORTLOG_CLR
:
2945 case IOCMD_DEBUG_START_DTRC
:
2946 case IOCMD_DEBUG_STOP_DTRC
:
2947 rc
= bfad_iocmd_debug_ctl(bfad
, iocmd
, cmd
);
2949 case IOCMD_DEBUG_PORTLOG_CTL
:
2950 rc
= bfad_iocmd_porglog_ctl(bfad
, iocmd
);
2952 case IOCMD_FCPIM_PROFILE_ON
:
2953 case IOCMD_FCPIM_PROFILE_OFF
:
2954 rc
= bfad_iocmd_fcpim_cfg_profile(bfad
, iocmd
, cmd
);
2956 case IOCMD_ITNIM_GET_IOPROFILE
:
2957 rc
= bfad_iocmd_itnim_get_ioprofile(bfad
, iocmd
);
2959 case IOCMD_FCPORT_GET_STATS
:
2960 rc
= bfad_iocmd_fcport_get_stats(bfad
, iocmd
);
2962 case IOCMD_FCPORT_RESET_STATS
:
2963 rc
= bfad_iocmd_fcport_reset_stats(bfad
, iocmd
);
2965 case IOCMD_BOOT_CFG
:
2966 rc
= bfad_iocmd_boot_cfg(bfad
, iocmd
);
2968 case IOCMD_BOOT_QUERY
:
2969 rc
= bfad_iocmd_boot_query(bfad
, iocmd
);
2971 case IOCMD_PREBOOT_QUERY
:
2972 rc
= bfad_iocmd_preboot_query(bfad
, iocmd
);
2974 case IOCMD_ETHBOOT_CFG
:
2975 rc
= bfad_iocmd_ethboot_cfg(bfad
, iocmd
);
2977 case IOCMD_ETHBOOT_QUERY
:
2978 rc
= bfad_iocmd_ethboot_query(bfad
, iocmd
);
2980 case IOCMD_TRUNK_ENABLE
:
2981 case IOCMD_TRUNK_DISABLE
:
2982 rc
= bfad_iocmd_cfg_trunk(bfad
, iocmd
, cmd
);
2984 case IOCMD_TRUNK_GET_ATTR
:
2985 rc
= bfad_iocmd_trunk_get_attr(bfad
, iocmd
);
2987 case IOCMD_QOS_ENABLE
:
2988 case IOCMD_QOS_DISABLE
:
2989 rc
= bfad_iocmd_qos(bfad
, iocmd
, cmd
);
2991 case IOCMD_QOS_GET_ATTR
:
2992 rc
= bfad_iocmd_qos_get_attr(bfad
, iocmd
);
2994 case IOCMD_QOS_GET_VC_ATTR
:
2995 rc
= bfad_iocmd_qos_get_vc_attr(bfad
, iocmd
);
2997 case IOCMD_QOS_GET_STATS
:
2998 rc
= bfad_iocmd_qos_get_stats(bfad
, iocmd
);
3000 case IOCMD_QOS_RESET_STATS
:
3001 rc
= bfad_iocmd_qos_reset_stats(bfad
, iocmd
);
3003 case IOCMD_QOS_SET_BW
:
3004 rc
= bfad_iocmd_qos_set_bw(bfad
, iocmd
);
3006 case IOCMD_VF_GET_STATS
:
3007 rc
= bfad_iocmd_vf_get_stats(bfad
, iocmd
);
3009 case IOCMD_VF_RESET_STATS
:
3010 rc
= bfad_iocmd_vf_clr_stats(bfad
, iocmd
);
3012 case IOCMD_FCPIM_LUNMASK_ENABLE
:
3013 case IOCMD_FCPIM_LUNMASK_DISABLE
:
3014 case IOCMD_FCPIM_LUNMASK_CLEAR
:
3015 rc
= bfad_iocmd_lunmask(bfad
, iocmd
, cmd
);
3017 case IOCMD_FCPIM_LUNMASK_QUERY
:
3018 rc
= bfad_iocmd_fcpim_lunmask_query(bfad
, iocmd
);
3020 case IOCMD_FCPIM_LUNMASK_ADD
:
3021 case IOCMD_FCPIM_LUNMASK_DELETE
:
3022 rc
= bfad_iocmd_fcpim_cfg_lunmask(bfad
, iocmd
, cmd
);
3024 case IOCMD_FCPIM_THROTTLE_QUERY
:
3025 rc
= bfad_iocmd_fcpim_throttle_query(bfad
, iocmd
);
3027 case IOCMD_FCPIM_THROTTLE_SET
:
3028 rc
= bfad_iocmd_fcpim_throttle_set(bfad
, iocmd
);
3031 case IOCMD_TFRU_READ
:
3032 rc
= bfad_iocmd_tfru_read(bfad
, iocmd
);
3034 case IOCMD_TFRU_WRITE
:
3035 rc
= bfad_iocmd_tfru_write(bfad
, iocmd
);
3038 case IOCMD_FRUVPD_READ
:
3039 rc
= bfad_iocmd_fruvpd_read(bfad
, iocmd
);
3041 case IOCMD_FRUVPD_UPDATE
:
3042 rc
= bfad_iocmd_fruvpd_update(bfad
, iocmd
);
3044 case IOCMD_FRUVPD_GET_MAX_SIZE
:
3045 rc
= bfad_iocmd_fruvpd_get_max_size(bfad
, iocmd
);
3055 bfad_im_bsg_vendor_request(struct fc_bsg_job
*job
)
3057 uint32_t vendor_cmd
= job
->request
->rqst_data
.h_vendor
.vendor_cmd
[0];
3058 struct bfad_im_port_s
*im_port
=
3059 (struct bfad_im_port_s
*) job
->shost
->hostdata
[0];
3060 struct bfad_s
*bfad
= im_port
->bfad
;
3061 struct request_queue
*request_q
= job
->req
->q
;
3066 * Set the BSG device request_queue size to 256 to support
3067 * payloads larger than 512*1024K bytes.
3069 blk_queue_max_segments(request_q
, 256);
3071 /* Allocate a temp buffer to hold the passed in user space command */
3072 payload_kbuf
= kzalloc(job
->request_payload
.payload_len
, GFP_KERNEL
);
3073 if (!payload_kbuf
) {
3078 /* Copy the sg_list passed in to a linear buffer: holds the cmnd data */
3079 sg_copy_to_buffer(job
->request_payload
.sg_list
,
3080 job
->request_payload
.sg_cnt
, payload_kbuf
,
3081 job
->request_payload
.payload_len
);
3083 /* Invoke IOCMD handler - to handle all the vendor command requests */
3084 rc
= bfad_iocmd_handler(bfad
, vendor_cmd
, payload_kbuf
,
3085 job
->request_payload
.payload_len
);
3086 if (rc
!= BFA_STATUS_OK
)
3089 /* Copy the response data to the job->reply_payload sg_list */
3090 sg_copy_from_buffer(job
->reply_payload
.sg_list
,
3091 job
->reply_payload
.sg_cnt
,
3093 job
->reply_payload
.payload_len
);
3095 /* free the command buffer */
3096 kfree(payload_kbuf
);
3098 /* Fill the BSG job reply data */
3099 job
->reply_len
= job
->reply_payload
.payload_len
;
3100 job
->reply
->reply_payload_rcv_len
= job
->reply_payload
.payload_len
;
3101 job
->reply
->result
= rc
;
3106 /* free the command buffer */
3107 kfree(payload_kbuf
);
3109 job
->reply
->result
= rc
;
3110 job
->reply_len
= sizeof(uint32_t);
3111 job
->reply
->reply_payload_rcv_len
= 0;
3115 /* FC passthru call backs */
3117 bfad_fcxp_get_req_sgaddr_cb(void *bfad_fcxp
, int sgeid
)
3119 struct bfad_fcxp
*drv_fcxp
= bfad_fcxp
;
3120 struct bfa_sge_s
*sge
;
3123 sge
= drv_fcxp
->req_sge
+ sgeid
;
3124 addr
= (u64
)(size_t) sge
->sg_addr
;
3129 bfad_fcxp_get_req_sglen_cb(void *bfad_fcxp
, int sgeid
)
3131 struct bfad_fcxp
*drv_fcxp
= bfad_fcxp
;
3132 struct bfa_sge_s
*sge
;
3134 sge
= drv_fcxp
->req_sge
+ sgeid
;
3139 bfad_fcxp_get_rsp_sgaddr_cb(void *bfad_fcxp
, int sgeid
)
3141 struct bfad_fcxp
*drv_fcxp
= bfad_fcxp
;
3142 struct bfa_sge_s
*sge
;
3145 sge
= drv_fcxp
->rsp_sge
+ sgeid
;
3146 addr
= (u64
)(size_t) sge
->sg_addr
;
3151 bfad_fcxp_get_rsp_sglen_cb(void *bfad_fcxp
, int sgeid
)
3153 struct bfad_fcxp
*drv_fcxp
= bfad_fcxp
;
3154 struct bfa_sge_s
*sge
;
3156 sge
= drv_fcxp
->rsp_sge
+ sgeid
;
3161 bfad_send_fcpt_cb(void *bfad_fcxp
, struct bfa_fcxp_s
*fcxp
, void *cbarg
,
3162 bfa_status_t req_status
, u32 rsp_len
, u32 resid_len
,
3163 struct fchs_s
*rsp_fchs
)
3165 struct bfad_fcxp
*drv_fcxp
= bfad_fcxp
;
3167 drv_fcxp
->req_status
= req_status
;
3168 drv_fcxp
->rsp_len
= rsp_len
;
3170 /* bfa_fcxp will be automatically freed by BFA */
3171 drv_fcxp
->bfa_fcxp
= NULL
;
3172 complete(&drv_fcxp
->comp
);
3175 struct bfad_buf_info
*
3176 bfad_fcxp_map_sg(struct bfad_s
*bfad
, void *payload_kbuf
,
3177 uint32_t payload_len
, uint32_t *num_sgles
)
3179 struct bfad_buf_info
*buf_base
, *buf_info
;
3180 struct bfa_sge_s
*sg_table
;
3183 buf_base
= kzalloc((sizeof(struct bfad_buf_info
) +
3184 sizeof(struct bfa_sge_s
)) * sge_num
, GFP_KERNEL
);
3188 sg_table
= (struct bfa_sge_s
*) (((uint8_t *)buf_base
) +
3189 (sizeof(struct bfad_buf_info
) * sge_num
));
3191 /* Allocate dma coherent memory */
3192 buf_info
= buf_base
;
3193 buf_info
->size
= payload_len
;
3194 buf_info
->virt
= dma_alloc_coherent(&bfad
->pcidev
->dev
, buf_info
->size
,
3195 &buf_info
->phys
, GFP_KERNEL
);
3196 if (!buf_info
->virt
)
3199 /* copy the linear bsg buffer to buf_info */
3200 memset(buf_info
->virt
, 0, buf_info
->size
);
3201 memcpy(buf_info
->virt
, payload_kbuf
, buf_info
->size
);
3206 sg_table
->sg_len
= buf_info
->size
;
3207 sg_table
->sg_addr
= (void *)(size_t) buf_info
->phys
;
3209 *num_sgles
= sge_num
;
3219 bfad_fcxp_free_mem(struct bfad_s
*bfad
, struct bfad_buf_info
*buf_base
,
3223 struct bfad_buf_info
*buf_info
= buf_base
;
3226 for (i
= 0; i
< num_sgles
; buf_info
++, i
++) {
3227 if (buf_info
->virt
!= NULL
)
3228 dma_free_coherent(&bfad
->pcidev
->dev
,
3229 buf_info
->size
, buf_info
->virt
,
3237 bfad_fcxp_bsg_send(struct fc_bsg_job
*job
, struct bfad_fcxp
*drv_fcxp
,
3238 bfa_bsg_fcpt_t
*bsg_fcpt
)
3240 struct bfa_fcxp_s
*hal_fcxp
;
3241 struct bfad_s
*bfad
= drv_fcxp
->port
->bfad
;
3242 unsigned long flags
;
3245 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
3247 /* Allocate bfa_fcxp structure */
3248 hal_fcxp
= bfa_fcxp_req_rsp_alloc(drv_fcxp
, &bfad
->bfa
,
3249 drv_fcxp
->num_req_sgles
,
3250 drv_fcxp
->num_rsp_sgles
,
3251 bfad_fcxp_get_req_sgaddr_cb
,
3252 bfad_fcxp_get_req_sglen_cb
,
3253 bfad_fcxp_get_rsp_sgaddr_cb
,
3254 bfad_fcxp_get_rsp_sglen_cb
, BFA_TRUE
);
3257 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
3258 return BFA_STATUS_ENOMEM
;
3261 drv_fcxp
->bfa_fcxp
= hal_fcxp
;
3263 lp_tag
= bfa_lps_get_tag_from_pid(&bfad
->bfa
, bsg_fcpt
->fchs
.s_id
);
3265 bfa_fcxp_send(hal_fcxp
, drv_fcxp
->bfa_rport
, bsg_fcpt
->vf_id
, lp_tag
,
3266 bsg_fcpt
->cts
, bsg_fcpt
->cos
,
3267 job
->request_payload
.payload_len
,
3268 &bsg_fcpt
->fchs
, bfad_send_fcpt_cb
, bfad
,
3269 job
->reply_payload
.payload_len
, bsg_fcpt
->tsecs
);
3271 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
3273 return BFA_STATUS_OK
;
3277 bfad_im_bsg_els_ct_request(struct fc_bsg_job
*job
)
3279 struct bfa_bsg_data
*bsg_data
;
3280 struct bfad_im_port_s
*im_port
=
3281 (struct bfad_im_port_s
*) job
->shost
->hostdata
[0];
3282 struct bfad_s
*bfad
= im_port
->bfad
;
3283 bfa_bsg_fcpt_t
*bsg_fcpt
;
3284 struct bfad_fcxp
*drv_fcxp
;
3285 struct bfa_fcs_lport_s
*fcs_port
;
3286 struct bfa_fcs_rport_s
*fcs_rport
;
3287 uint32_t command_type
= job
->request
->msgcode
;
3288 unsigned long flags
;
3289 struct bfad_buf_info
*rsp_buf_info
;
3290 void *req_kbuf
= NULL
, *rsp_kbuf
= NULL
;
3293 job
->reply_len
= sizeof(uint32_t); /* Atleast uint32_t reply_len */
3294 job
->reply
->reply_payload_rcv_len
= 0;
3296 /* Get the payload passed in from userspace */
3297 bsg_data
= (struct bfa_bsg_data
*) (((char *)job
->request
) +
3298 sizeof(struct fc_bsg_request
));
3299 if (bsg_data
== NULL
)
3303 * Allocate buffer for bsg_fcpt and do a copy_from_user op for payload
3304 * buffer of size bsg_data->payload_len
3306 bsg_fcpt
= kzalloc(bsg_data
->payload_len
, GFP_KERNEL
);
3312 if (copy_from_user((uint8_t *)bsg_fcpt
, bsg_data
->payload
,
3313 bsg_data
->payload_len
)) {
3319 drv_fcxp
= kzalloc(sizeof(struct bfad_fcxp
), GFP_KERNEL
);
3320 if (drv_fcxp
== NULL
) {
3326 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
3327 fcs_port
= bfa_fcs_lookup_port(&bfad
->bfa_fcs
, bsg_fcpt
->vf_id
,
3329 if (fcs_port
== NULL
) {
3330 bsg_fcpt
->status
= BFA_STATUS_UNKNOWN_LWWN
;
3331 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
3335 /* Check if the port is online before sending FC Passthru cmd */
3336 if (!bfa_fcs_lport_is_online(fcs_port
)) {
3337 bsg_fcpt
->status
= BFA_STATUS_PORT_OFFLINE
;
3338 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
3342 drv_fcxp
->port
= fcs_port
->bfad_port
;
3344 if (drv_fcxp
->port
->bfad
== 0)
3345 drv_fcxp
->port
->bfad
= bfad
;
3347 /* Fetch the bfa_rport - if nexus needed */
3348 if (command_type
== FC_BSG_HST_ELS_NOLOGIN
||
3349 command_type
== FC_BSG_HST_CT
) {
3350 /* BSG HST commands: no nexus needed */
3351 drv_fcxp
->bfa_rport
= NULL
;
3353 } else if (command_type
== FC_BSG_RPT_ELS
||
3354 command_type
== FC_BSG_RPT_CT
) {
3355 /* BSG RPT commands: nexus needed */
3356 fcs_rport
= bfa_fcs_lport_get_rport_by_pwwn(fcs_port
,
3358 if (fcs_rport
== NULL
) {
3359 bsg_fcpt
->status
= BFA_STATUS_UNKNOWN_RWWN
;
3360 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
3364 drv_fcxp
->bfa_rport
= fcs_rport
->bfa_rport
;
3366 } else { /* Unknown BSG msgcode; return -EINVAL */
3367 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
3371 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
3373 /* allocate memory for req / rsp buffers */
3374 req_kbuf
= kzalloc(job
->request_payload
.payload_len
, GFP_KERNEL
);
3376 printk(KERN_INFO
"bfa %s: fcpt request buffer alloc failed\n",
3382 rsp_kbuf
= kzalloc(job
->reply_payload
.payload_len
, GFP_KERNEL
);
3384 printk(KERN_INFO
"bfa %s: fcpt response buffer alloc failed\n",
3390 /* map req sg - copy the sg_list passed in to the linear buffer */
3391 sg_copy_to_buffer(job
->request_payload
.sg_list
,
3392 job
->request_payload
.sg_cnt
, req_kbuf
,
3393 job
->request_payload
.payload_len
);
3395 drv_fcxp
->reqbuf_info
= bfad_fcxp_map_sg(bfad
, req_kbuf
,
3396 job
->request_payload
.payload_len
,
3397 &drv_fcxp
->num_req_sgles
);
3398 if (!drv_fcxp
->reqbuf_info
) {
3399 printk(KERN_INFO
"bfa %s: fcpt request fcxp_map_sg failed\n",
3405 drv_fcxp
->req_sge
= (struct bfa_sge_s
*)
3406 (((uint8_t *)drv_fcxp
->reqbuf_info
) +
3407 (sizeof(struct bfad_buf_info
) *
3408 drv_fcxp
->num_req_sgles
));
3411 drv_fcxp
->rspbuf_info
= bfad_fcxp_map_sg(bfad
, rsp_kbuf
,
3412 job
->reply_payload
.payload_len
,
3413 &drv_fcxp
->num_rsp_sgles
);
3414 if (!drv_fcxp
->rspbuf_info
) {
3415 printk(KERN_INFO
"bfa %s: fcpt response fcxp_map_sg failed\n",
3421 rsp_buf_info
= (struct bfad_buf_info
*)drv_fcxp
->rspbuf_info
;
3422 drv_fcxp
->rsp_sge
= (struct bfa_sge_s
*)
3423 (((uint8_t *)drv_fcxp
->rspbuf_info
) +
3424 (sizeof(struct bfad_buf_info
) *
3425 drv_fcxp
->num_rsp_sgles
));
3428 init_completion(&drv_fcxp
->comp
);
3429 rc
= bfad_fcxp_bsg_send(job
, drv_fcxp
, bsg_fcpt
);
3430 if (rc
== BFA_STATUS_OK
) {
3431 wait_for_completion(&drv_fcxp
->comp
);
3432 bsg_fcpt
->status
= drv_fcxp
->req_status
;
3434 bsg_fcpt
->status
= rc
;
3438 /* fill the job->reply data */
3439 if (drv_fcxp
->req_status
== BFA_STATUS_OK
) {
3440 job
->reply_len
= drv_fcxp
->rsp_len
;
3441 job
->reply
->reply_payload_rcv_len
= drv_fcxp
->rsp_len
;
3442 job
->reply
->reply_data
.ctels_reply
.status
= FC_CTELS_STATUS_OK
;
3444 job
->reply
->reply_payload_rcv_len
=
3445 sizeof(struct fc_bsg_ctels_reply
);
3446 job
->reply_len
= sizeof(uint32_t);
3447 job
->reply
->reply_data
.ctels_reply
.status
=
3448 FC_CTELS_STATUS_REJECT
;
3451 /* Copy the response data to the reply_payload sg list */
3452 sg_copy_from_buffer(job
->reply_payload
.sg_list
,
3453 job
->reply_payload
.sg_cnt
,
3454 (uint8_t *)rsp_buf_info
->virt
,
3455 job
->reply_payload
.payload_len
);
3458 bfad_fcxp_free_mem(bfad
, drv_fcxp
->rspbuf_info
,
3459 drv_fcxp
->num_rsp_sgles
);
3460 bfad_fcxp_free_mem(bfad
, drv_fcxp
->reqbuf_info
,
3461 drv_fcxp
->num_req_sgles
);
3465 /* Need a copy to user op */
3466 if (copy_to_user(bsg_data
->payload
, (void *) bsg_fcpt
,
3467 bsg_data
->payload_len
))
3473 job
->reply
->result
= rc
;
3475 if (rc
== BFA_STATUS_OK
)
3482 bfad_im_bsg_request(struct fc_bsg_job
*job
)
3484 uint32_t rc
= BFA_STATUS_OK
;
3486 switch (job
->request
->msgcode
) {
3487 case FC_BSG_HST_VENDOR
:
3488 /* Process BSG HST Vendor requests */
3489 rc
= bfad_im_bsg_vendor_request(job
);
3491 case FC_BSG_HST_ELS_NOLOGIN
:
3492 case FC_BSG_RPT_ELS
:
3495 /* Process BSG ELS/CT commands */
3496 rc
= bfad_im_bsg_els_ct_request(job
);
3499 job
->reply
->result
= rc
= -EINVAL
;
3500 job
->reply
->reply_payload_rcv_len
= 0;
3508 bfad_im_bsg_timeout(struct fc_bsg_job
*job
)
3510 /* Don't complete the BSG job request - return -EAGAIN
3511 * to reset bsg job timeout : for ELS/CT pass thru we
3512 * already have timer to track the request.