2 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
3 * Copyright (c) 2014- QLogic Corporation.
7 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License (GPL) Version 2 as
11 * published by the Free Software Foundation
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
20 * bfad_im.c Linux driver IM module.
23 #include <linux/export.h>
29 BFA_TRC_FILE(LDRV
, IM
);
31 DEFINE_IDR(bfad_im_port_index
);
32 struct scsi_transport_template
*bfad_im_scsi_transport_template
;
33 struct scsi_transport_template
*bfad_im_scsi_vport_transport_template
;
34 static void bfad_im_itnim_work_handler(struct work_struct
*work
);
35 static int bfad_im_queuecommand(struct Scsi_Host
*h
, struct scsi_cmnd
*cmnd
);
36 static int bfad_im_slave_alloc(struct scsi_device
*sdev
);
37 static void bfad_im_fc_rport_add(struct bfad_im_port_s
*im_port
,
38 struct bfad_itnim_s
*itnim
);
41 bfa_cb_ioim_done(void *drv
, struct bfad_ioim_s
*dio
,
42 enum bfi_ioim_status io_status
, u8 scsi_status
,
43 int sns_len
, u8
*sns_info
, s32 residue
)
45 struct scsi_cmnd
*cmnd
= (struct scsi_cmnd
*)dio
;
46 struct bfad_s
*bfad
= drv
;
47 struct bfad_itnim_data_s
*itnim_data
;
48 struct bfad_itnim_s
*itnim
;
49 u8 host_status
= DID_OK
;
53 bfa_trc(bfad
, scsi_status
);
54 scsi_set_resid(cmnd
, 0);
57 bfa_trc(bfad
, sns_len
);
58 if (sns_len
> SCSI_SENSE_BUFFERSIZE
)
59 sns_len
= SCSI_SENSE_BUFFERSIZE
;
60 memcpy(cmnd
->sense_buffer
, sns_info
, sns_len
);
64 bfa_trc(bfad
, residue
);
65 scsi_set_resid(cmnd
, residue
);
66 if (!sns_len
&& (scsi_status
== SAM_STAT_GOOD
) &&
67 (scsi_bufflen(cmnd
) - residue
) <
70 host_status
= DID_ERROR
;
73 cmnd
->result
= ScsiResult(host_status
, scsi_status
);
77 case BFI_IOIM_STS_TIMEDOUT
:
78 host_status
= DID_TIME_OUT
;
79 cmnd
->result
= ScsiResult(host_status
, 0);
81 case BFI_IOIM_STS_PATHTOV
:
82 host_status
= DID_TRANSPORT_DISRUPTED
;
83 cmnd
->result
= ScsiResult(host_status
, 0);
86 host_status
= DID_ERROR
;
87 cmnd
->result
= ScsiResult(host_status
, 0);
90 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */
91 if (cmnd
->device
->host
!= NULL
)
94 cmnd
->host_scribble
= NULL
;
95 bfa_trc(bfad
, cmnd
->result
);
97 itnim_data
= cmnd
->device
->hostdata
;
99 itnim
= itnim_data
->itnim
;
100 if (!cmnd
->result
&& itnim
&&
101 (bfa_lun_queue_depth
> cmnd
->device
->queue_depth
)) {
102 /* Queue depth adjustment for good status completion */
103 bfad_ramp_up_qdepth(itnim
, cmnd
->device
);
104 } else if (cmnd
->result
== SAM_STAT_TASK_SET_FULL
&& itnim
) {
106 bfad_handle_qfull(itnim
, cmnd
->device
);
110 cmnd
->scsi_done(cmnd
);
114 bfa_cb_ioim_good_comp(void *drv
, struct bfad_ioim_s
*dio
)
116 struct scsi_cmnd
*cmnd
= (struct scsi_cmnd
*)dio
;
117 struct bfad_itnim_data_s
*itnim_data
;
118 struct bfad_itnim_s
*itnim
;
120 cmnd
->result
= ScsiResult(DID_OK
, SCSI_STATUS_GOOD
);
122 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */
123 if (cmnd
->device
->host
!= NULL
)
124 scsi_dma_unmap(cmnd
);
126 cmnd
->host_scribble
= NULL
;
128 /* Queue depth adjustment */
129 if (bfa_lun_queue_depth
> cmnd
->device
->queue_depth
) {
130 itnim_data
= cmnd
->device
->hostdata
;
132 itnim
= itnim_data
->itnim
;
134 bfad_ramp_up_qdepth(itnim
, cmnd
->device
);
138 cmnd
->scsi_done(cmnd
);
142 bfa_cb_ioim_abort(void *drv
, struct bfad_ioim_s
*dio
)
144 struct scsi_cmnd
*cmnd
= (struct scsi_cmnd
*)dio
;
145 struct bfad_s
*bfad
= drv
;
147 cmnd
->result
= ScsiResult(DID_ERROR
, 0);
149 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */
150 if (cmnd
->device
->host
!= NULL
)
151 scsi_dma_unmap(cmnd
);
153 bfa_trc(bfad
, cmnd
->result
);
154 cmnd
->host_scribble
= NULL
;
158 bfa_cb_tskim_done(void *bfad
, struct bfad_tskim_s
*dtsk
,
159 enum bfi_tskim_status tsk_status
)
161 struct scsi_cmnd
*cmnd
= (struct scsi_cmnd
*)dtsk
;
162 wait_queue_head_t
*wq
;
164 cmnd
->SCp
.Status
|= tsk_status
<< 1;
165 set_bit(IO_DONE_BIT
, (unsigned long *)&cmnd
->SCp
.Status
);
166 wq
= (wait_queue_head_t
*) cmnd
->SCp
.ptr
;
167 cmnd
->SCp
.ptr
= NULL
;
174 * Scsi_Host_template SCSI host template
177 * Scsi_Host template entry, returns BFAD PCI info.
180 bfad_im_info(struct Scsi_Host
*shost
)
182 static char bfa_buf
[256];
183 struct bfad_im_port_s
*im_port
=
184 (struct bfad_im_port_s
*) shost
->hostdata
[0];
185 struct bfad_s
*bfad
= im_port
->bfad
;
187 memset(bfa_buf
, 0, sizeof(bfa_buf
));
188 snprintf(bfa_buf
, sizeof(bfa_buf
),
189 "QLogic BR-series FC/FCOE Adapter, hwpath: %s driver: %s",
190 bfad
->pci_name
, BFAD_DRIVER_VERSION
);
196 * Scsi_Host template entry, aborts the specified SCSI command.
198 * Returns: SUCCESS or FAILED.
201 bfad_im_abort_handler(struct scsi_cmnd
*cmnd
)
203 struct Scsi_Host
*shost
= cmnd
->device
->host
;
204 struct bfad_im_port_s
*im_port
=
205 (struct bfad_im_port_s
*) shost
->hostdata
[0];
206 struct bfad_s
*bfad
= im_port
->bfad
;
207 struct bfa_ioim_s
*hal_io
;
212 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
213 hal_io
= (struct bfa_ioim_s
*) cmnd
->host_scribble
;
215 /* IO has been completed, return success */
219 if (hal_io
->dio
!= (struct bfad_ioim_s
*) cmnd
) {
224 bfa_trc(bfad
, hal_io
->iotag
);
225 BFA_LOG(KERN_INFO
, bfad
, bfa_log_level
,
226 "scsi%d: abort cmnd %p iotag %x\n",
227 im_port
->shost
->host_no
, cmnd
, hal_io
->iotag
);
228 (void) bfa_ioim_abort(hal_io
);
229 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
231 /* Need to wait until the command get aborted */
233 while ((struct bfa_ioim_s
*) cmnd
->host_scribble
== hal_io
) {
234 set_current_state(TASK_UNINTERRUPTIBLE
);
235 schedule_timeout(timeout
);
236 if (timeout
< 4 * HZ
)
240 cmnd
->scsi_done(cmnd
);
241 bfa_trc(bfad
, hal_io
->iotag
);
242 BFA_LOG(KERN_INFO
, bfad
, bfa_log_level
,
243 "scsi%d: complete abort 0x%p iotag 0x%x\n",
244 im_port
->shost
->host_no
, cmnd
, hal_io
->iotag
);
247 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
252 bfad_im_target_reset_send(struct bfad_s
*bfad
, struct scsi_cmnd
*cmnd
,
253 struct bfad_itnim_s
*itnim
)
255 struct bfa_tskim_s
*tskim
;
256 struct bfa_itnim_s
*bfa_itnim
;
257 bfa_status_t rc
= BFA_STATUS_OK
;
258 struct scsi_lun scsilun
;
260 tskim
= bfa_tskim_alloc(&bfad
->bfa
, (struct bfad_tskim_s
*) cmnd
);
262 BFA_LOG(KERN_ERR
, bfad
, bfa_log_level
,
263 "target reset, fail to allocate tskim\n");
264 rc
= BFA_STATUS_FAILED
;
269 * Set host_scribble to NULL to avoid aborting a task command if
272 cmnd
->host_scribble
= NULL
;
273 cmnd
->SCp
.Status
= 0;
274 bfa_itnim
= bfa_fcs_itnim_get_halitn(&itnim
->fcs_itnim
);
276 * bfa_itnim can be NULL if the port gets disconnected and the bfa
277 * and fcs layers have cleaned up their nexus with the targets and
278 * the same has not been cleaned up by the shim
280 if (bfa_itnim
== NULL
) {
281 bfa_tskim_free(tskim
);
282 BFA_LOG(KERN_ERR
, bfad
, bfa_log_level
,
283 "target reset, bfa_itnim is NULL\n");
284 rc
= BFA_STATUS_FAILED
;
288 memset(&scsilun
, 0, sizeof(scsilun
));
289 bfa_tskim_start(tskim
, bfa_itnim
, scsilun
,
290 FCP_TM_TARGET_RESET
, BFAD_TARGET_RESET_TMO
);
296 * Scsi_Host template entry, resets a LUN and abort its all commands.
298 * Returns: SUCCESS or FAILED.
302 bfad_im_reset_lun_handler(struct scsi_cmnd
*cmnd
)
304 struct Scsi_Host
*shost
= cmnd
->device
->host
;
305 struct bfad_im_port_s
*im_port
=
306 (struct bfad_im_port_s
*) shost
->hostdata
[0];
307 struct bfad_itnim_data_s
*itnim_data
= cmnd
->device
->hostdata
;
308 struct bfad_s
*bfad
= im_port
->bfad
;
309 struct bfa_tskim_s
*tskim
;
310 struct bfad_itnim_s
*itnim
;
311 struct bfa_itnim_s
*bfa_itnim
;
312 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq
);
315 enum bfi_tskim_status task_status
;
316 struct scsi_lun scsilun
;
318 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
319 itnim
= itnim_data
->itnim
;
321 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
326 tskim
= bfa_tskim_alloc(&bfad
->bfa
, (struct bfad_tskim_s
*) cmnd
);
328 BFA_LOG(KERN_ERR
, bfad
, bfa_log_level
,
329 "LUN reset, fail to allocate tskim");
330 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
336 * Set host_scribble to NULL to avoid aborting a task command
339 cmnd
->host_scribble
= NULL
;
340 cmnd
->SCp
.ptr
= (char *)&wq
;
341 cmnd
->SCp
.Status
= 0;
342 bfa_itnim
= bfa_fcs_itnim_get_halitn(&itnim
->fcs_itnim
);
344 * bfa_itnim can be NULL if the port gets disconnected and the bfa
345 * and fcs layers have cleaned up their nexus with the targets and
346 * the same has not been cleaned up by the shim
348 if (bfa_itnim
== NULL
) {
349 bfa_tskim_free(tskim
);
350 BFA_LOG(KERN_ERR
, bfad
, bfa_log_level
,
351 "lun reset, bfa_itnim is NULL\n");
352 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
356 int_to_scsilun(cmnd
->device
->lun
, &scsilun
);
357 bfa_tskim_start(tskim
, bfa_itnim
, scsilun
,
358 FCP_TM_LUN_RESET
, BFAD_LUN_RESET_TMO
);
359 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
361 wait_event(wq
, test_bit(IO_DONE_BIT
,
362 (unsigned long *)&cmnd
->SCp
.Status
));
364 task_status
= cmnd
->SCp
.Status
>> 1;
365 if (task_status
!= BFI_TSKIM_STS_OK
) {
366 BFA_LOG(KERN_ERR
, bfad
, bfa_log_level
,
367 "LUN reset failure, status: %d\n", task_status
);
376 * Scsi_Host template entry, resets the bus and abort all commands.
379 bfad_im_reset_bus_handler(struct scsi_cmnd
*cmnd
)
381 struct Scsi_Host
*shost
= cmnd
->device
->host
;
382 struct bfad_im_port_s
*im_port
=
383 (struct bfad_im_port_s
*) shost
->hostdata
[0];
384 struct bfad_s
*bfad
= im_port
->bfad
;
385 struct bfad_itnim_s
*itnim
;
387 u32 i
, rc
, err_cnt
= 0;
388 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq
);
389 enum bfi_tskim_status task_status
;
391 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
392 for (i
= 0; i
< MAX_FCP_TARGET
; i
++) {
393 itnim
= bfad_get_itnim(im_port
, i
);
395 cmnd
->SCp
.ptr
= (char *)&wq
;
396 rc
= bfad_im_target_reset_send(bfad
, cmnd
, itnim
);
397 if (rc
!= BFA_STATUS_OK
) {
402 /* wait target reset to complete */
403 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
404 wait_event(wq
, test_bit(IO_DONE_BIT
,
405 (unsigned long *)&cmnd
->SCp
.Status
));
406 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
408 task_status
= cmnd
->SCp
.Status
>> 1;
409 if (task_status
!= BFI_TSKIM_STS_OK
) {
410 BFA_LOG(KERN_ERR
, bfad
, bfa_log_level
,
411 "target reset failure,"
412 " status: %d\n", task_status
);
417 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
426 * Scsi_Host template entry slave_destroy.
429 bfad_im_slave_destroy(struct scsi_device
*sdev
)
431 sdev
->hostdata
= NULL
;
436 * BFA FCS itnim callbacks
440 * BFA FCS itnim alloc callback, after successful PRLI
444 bfa_fcb_itnim_alloc(struct bfad_s
*bfad
, struct bfa_fcs_itnim_s
**itnim
,
445 struct bfad_itnim_s
**itnim_drv
)
447 *itnim_drv
= kzalloc(sizeof(struct bfad_itnim_s
), GFP_ATOMIC
);
448 if (*itnim_drv
== NULL
)
451 (*itnim_drv
)->im
= bfad
->im
;
452 *itnim
= &(*itnim_drv
)->fcs_itnim
;
453 (*itnim_drv
)->state
= ITNIM_STATE_NONE
;
456 * Initiaze the itnim_work
458 INIT_WORK(&(*itnim_drv
)->itnim_work
, bfad_im_itnim_work_handler
);
459 bfad
->bfad_flags
|= BFAD_RPORT_ONLINE
;
463 * BFA FCS itnim free callback.
464 * Context: Interrupt. bfad_lock is held
467 bfa_fcb_itnim_free(struct bfad_s
*bfad
, struct bfad_itnim_s
*itnim_drv
)
469 struct bfad_port_s
*port
;
472 char wwpn_str
[32], fcid_str
[16];
473 struct bfad_im_s
*im
= itnim_drv
->im
;
475 /* online to free state transtion should not happen */
476 WARN_ON(itnim_drv
->state
== ITNIM_STATE_ONLINE
);
478 itnim_drv
->queue_work
= 1;
479 /* offline request is not yet done, use the same request to free */
480 if (itnim_drv
->state
== ITNIM_STATE_OFFLINE_PENDING
)
481 itnim_drv
->queue_work
= 0;
483 itnim_drv
->state
= ITNIM_STATE_FREE
;
484 port
= bfa_fcs_itnim_get_drvport(&itnim_drv
->fcs_itnim
);
485 itnim_drv
->im_port
= port
->im_port
;
486 wwpn
= bfa_fcs_itnim_get_pwwn(&itnim_drv
->fcs_itnim
);
487 fcid
= bfa_fcs_itnim_get_fcid(&itnim_drv
->fcs_itnim
);
488 wwn2str(wwpn_str
, wwpn
);
489 fcid2str(fcid_str
, fcid
);
490 BFA_LOG(KERN_INFO
, bfad
, bfa_log_level
,
491 "ITNIM FREE scsi%d: FCID: %s WWPN: %s\n",
492 port
->im_port
->shost
->host_no
,
495 /* ITNIM processing */
496 if (itnim_drv
->queue_work
)
497 queue_work(im
->drv_workq
, &itnim_drv
->itnim_work
);
501 * BFA FCS itnim online callback.
502 * Context: Interrupt. bfad_lock is held
505 bfa_fcb_itnim_online(struct bfad_itnim_s
*itnim_drv
)
507 struct bfad_port_s
*port
;
508 struct bfad_im_s
*im
= itnim_drv
->im
;
510 itnim_drv
->bfa_itnim
= bfa_fcs_itnim_get_halitn(&itnim_drv
->fcs_itnim
);
511 port
= bfa_fcs_itnim_get_drvport(&itnim_drv
->fcs_itnim
);
512 itnim_drv
->state
= ITNIM_STATE_ONLINE
;
513 itnim_drv
->queue_work
= 1;
514 itnim_drv
->im_port
= port
->im_port
;
516 /* ITNIM processing */
517 if (itnim_drv
->queue_work
)
518 queue_work(im
->drv_workq
, &itnim_drv
->itnim_work
);
522 * BFA FCS itnim offline callback.
523 * Context: Interrupt. bfad_lock is held
526 bfa_fcb_itnim_offline(struct bfad_itnim_s
*itnim_drv
)
528 struct bfad_port_s
*port
;
530 struct bfad_im_s
*im
= itnim_drv
->im
;
532 port
= bfa_fcs_itnim_get_drvport(&itnim_drv
->fcs_itnim
);
534 if ((bfad
->pport
.flags
& BFAD_PORT_DELETE
) ||
535 (port
->flags
& BFAD_PORT_DELETE
)) {
536 itnim_drv
->state
= ITNIM_STATE_OFFLINE
;
539 itnim_drv
->im_port
= port
->im_port
;
540 itnim_drv
->state
= ITNIM_STATE_OFFLINE_PENDING
;
541 itnim_drv
->queue_work
= 1;
543 /* ITNIM processing */
544 if (itnim_drv
->queue_work
)
545 queue_work(im
->drv_workq
, &itnim_drv
->itnim_work
);
549 * Allocate a Scsi_Host for a port.
552 bfad_im_scsi_host_alloc(struct bfad_s
*bfad
, struct bfad_im_port_s
*im_port
,
557 mutex_lock(&bfad_mutex
);
558 error
= idr_alloc(&bfad_im_port_index
, im_port
, 0, 0, GFP_KERNEL
);
560 mutex_unlock(&bfad_mutex
);
561 printk(KERN_WARNING
"idr_alloc failure\n");
564 im_port
->idr_id
= error
;
565 mutex_unlock(&bfad_mutex
);
567 im_port
->shost
= bfad_scsi_host_alloc(im_port
, bfad
);
568 if (!im_port
->shost
) {
573 im_port
->shost
->hostdata
[0] = (unsigned long)im_port
;
574 im_port
->shost
->unique_id
= im_port
->idr_id
;
575 im_port
->shost
->this_id
= -1;
576 im_port
->shost
->max_id
= MAX_FCP_TARGET
;
577 im_port
->shost
->max_lun
= MAX_FCP_LUN
;
578 im_port
->shost
->max_cmd_len
= 16;
579 im_port
->shost
->can_queue
= bfad
->cfg_data
.ioc_queue_depth
;
580 if (im_port
->port
->pvb_type
== BFAD_PORT_PHYS_BASE
)
581 im_port
->shost
->transportt
= bfad_im_scsi_transport_template
;
583 im_port
->shost
->transportt
=
584 bfad_im_scsi_vport_transport_template
;
586 error
= scsi_add_host_with_dma(im_port
->shost
, dev
, &bfad
->pcidev
->dev
);
588 printk(KERN_WARNING
"scsi_add_host failure %d\n", error
);
595 scsi_host_put(im_port
->shost
);
596 im_port
->shost
= NULL
;
598 mutex_lock(&bfad_mutex
);
599 idr_remove(&bfad_im_port_index
, im_port
->idr_id
);
600 mutex_unlock(&bfad_mutex
);
606 bfad_im_scsi_host_free(struct bfad_s
*bfad
, struct bfad_im_port_s
*im_port
)
608 bfa_trc(bfad
, bfad
->inst_no
);
609 BFA_LOG(KERN_INFO
, bfad
, bfa_log_level
, "Free scsi%d\n",
610 im_port
->shost
->host_no
);
612 fc_remove_host(im_port
->shost
);
614 scsi_remove_host(im_port
->shost
);
615 scsi_host_put(im_port
->shost
);
617 mutex_lock(&bfad_mutex
);
618 idr_remove(&bfad_im_port_index
, im_port
->idr_id
);
619 mutex_unlock(&bfad_mutex
);
623 bfad_im_port_delete_handler(struct work_struct
*work
)
625 struct bfad_im_port_s
*im_port
=
626 container_of(work
, struct bfad_im_port_s
, port_delete_work
);
628 if (im_port
->port
->pvb_type
!= BFAD_PORT_PHYS_BASE
) {
629 im_port
->flags
|= BFAD_PORT_DELETE
;
630 fc_vport_terminate(im_port
->fc_vport
);
635 bfad_im_port_new(struct bfad_s
*bfad
, struct bfad_port_s
*port
)
637 int rc
= BFA_STATUS_OK
;
638 struct bfad_im_port_s
*im_port
;
640 im_port
= kzalloc(sizeof(struct bfad_im_port_s
), GFP_ATOMIC
);
641 if (im_port
== NULL
) {
642 rc
= BFA_STATUS_ENOMEM
;
645 port
->im_port
= im_port
;
646 im_port
->port
= port
;
647 im_port
->bfad
= bfad
;
649 INIT_WORK(&im_port
->port_delete_work
, bfad_im_port_delete_handler
);
650 INIT_LIST_HEAD(&im_port
->itnim_mapped_list
);
651 INIT_LIST_HEAD(&im_port
->binding_list
);
658 bfad_im_port_delete(struct bfad_s
*bfad
, struct bfad_port_s
*port
)
660 struct bfad_im_port_s
*im_port
= port
->im_port
;
662 queue_work(bfad
->im
->drv_workq
,
663 &im_port
->port_delete_work
);
667 bfad_im_port_clean(struct bfad_im_port_s
*im_port
)
669 struct bfad_fcp_binding
*bp
, *bp_new
;
671 struct bfad_s
*bfad
= im_port
->bfad
;
673 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
674 list_for_each_entry_safe(bp
, bp_new
, &im_port
->binding_list
,
676 list_del(&bp
->list_entry
);
680 /* the itnim_mapped_list must be empty at this time */
681 WARN_ON(!list_empty(&im_port
->itnim_mapped_list
));
683 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
686 static void bfad_aen_im_notify_handler(struct work_struct
*work
)
688 struct bfad_im_s
*im
=
689 container_of(work
, struct bfad_im_s
, aen_im_notify_work
);
690 struct bfa_aen_entry_s
*aen_entry
;
691 struct bfad_s
*bfad
= im
->bfad
;
692 struct Scsi_Host
*shost
= bfad
->pport
.im_port
->shost
;
696 while (!list_empty(&bfad
->active_aen_q
)) {
697 spin_lock_irqsave(&bfad
->bfad_aen_spinlock
, flags
);
698 bfa_q_deq(&bfad
->active_aen_q
, &aen_entry
);
699 spin_unlock_irqrestore(&bfad
->bfad_aen_spinlock
, flags
);
700 event_data
= (char *)aen_entry
+ sizeof(struct list_head
);
701 fc_host_post_vendor_event(shost
, fc_get_event_number(),
702 sizeof(struct bfa_aen_entry_s
) -
703 sizeof(struct list_head
),
704 (char *)event_data
, BFAD_NL_VENDOR_ID
);
705 spin_lock_irqsave(&bfad
->bfad_aen_spinlock
, flags
);
706 list_add_tail(&aen_entry
->qe
, &bfad
->free_aen_q
);
707 spin_unlock_irqrestore(&bfad
->bfad_aen_spinlock
, flags
);
712 bfad_im_probe(struct bfad_s
*bfad
)
714 struct bfad_im_s
*im
;
716 im
= kzalloc(sizeof(struct bfad_im_s
), GFP_KERNEL
);
718 return BFA_STATUS_ENOMEM
;
723 if (bfad_thread_workq(bfad
) != BFA_STATUS_OK
) {
725 return BFA_STATUS_FAILED
;
728 INIT_WORK(&im
->aen_im_notify_work
, bfad_aen_im_notify_handler
);
729 return BFA_STATUS_OK
;
733 bfad_im_probe_undo(struct bfad_s
*bfad
)
736 bfad_destroy_workq(bfad
->im
);
743 bfad_scsi_host_alloc(struct bfad_im_port_s
*im_port
, struct bfad_s
*bfad
)
745 struct scsi_host_template
*sht
;
747 if (im_port
->port
->pvb_type
== BFAD_PORT_PHYS_BASE
)
748 sht
= &bfad_im_scsi_host_template
;
750 sht
= &bfad_im_vport_template
;
752 if (max_xfer_size
!= BFAD_MAX_SECTORS
>> 1)
753 sht
->max_sectors
= max_xfer_size
<< 1;
755 sht
->sg_tablesize
= bfad
->cfg_data
.io_max_sge
;
757 return scsi_host_alloc(sht
, sizeof(unsigned long));
761 bfad_scsi_host_free(struct bfad_s
*bfad
, struct bfad_im_port_s
*im_port
)
763 if (!(im_port
->flags
& BFAD_PORT_DELETE
))
764 flush_workqueue(bfad
->im
->drv_workq
);
765 bfad_im_scsi_host_free(im_port
->bfad
, im_port
);
766 bfad_im_port_clean(im_port
);
771 bfad_destroy_workq(struct bfad_im_s
*im
)
773 if (im
&& im
->drv_workq
) {
774 flush_workqueue(im
->drv_workq
);
775 destroy_workqueue(im
->drv_workq
);
776 im
->drv_workq
= NULL
;
781 bfad_thread_workq(struct bfad_s
*bfad
)
783 struct bfad_im_s
*im
= bfad
->im
;
786 snprintf(im
->drv_workq_name
, KOBJ_NAME_LEN
, "bfad_wq_%d",
788 im
->drv_workq
= create_singlethread_workqueue(im
->drv_workq_name
);
790 return BFA_STATUS_FAILED
;
792 return BFA_STATUS_OK
;
796 * Scsi_Host template entry.
799 * OS entry point to adjust the queue_depths on a per-device basis.
800 * Called once per device during the bus scan.
801 * Return non-zero if fails.
804 bfad_im_slave_configure(struct scsi_device
*sdev
)
806 scsi_change_queue_depth(sdev
, bfa_lun_queue_depth
);
810 struct scsi_host_template bfad_im_scsi_host_template
= {
811 .module
= THIS_MODULE
,
812 .name
= BFAD_DRIVER_NAME
,
813 .info
= bfad_im_info
,
814 .queuecommand
= bfad_im_queuecommand
,
815 .eh_abort_handler
= bfad_im_abort_handler
,
816 .eh_device_reset_handler
= bfad_im_reset_lun_handler
,
817 .eh_bus_reset_handler
= bfad_im_reset_bus_handler
,
819 .slave_alloc
= bfad_im_slave_alloc
,
820 .slave_configure
= bfad_im_slave_configure
,
821 .slave_destroy
= bfad_im_slave_destroy
,
824 .sg_tablesize
= BFAD_IO_MAX_SGE
,
826 .use_clustering
= ENABLE_CLUSTERING
,
827 .shost_attrs
= bfad_im_host_attrs
,
828 .max_sectors
= BFAD_MAX_SECTORS
,
829 .vendor_id
= BFA_PCI_VENDOR_ID_BROCADE
,
832 struct scsi_host_template bfad_im_vport_template
= {
833 .module
= THIS_MODULE
,
834 .name
= BFAD_DRIVER_NAME
,
835 .info
= bfad_im_info
,
836 .queuecommand
= bfad_im_queuecommand
,
837 .eh_abort_handler
= bfad_im_abort_handler
,
838 .eh_device_reset_handler
= bfad_im_reset_lun_handler
,
839 .eh_bus_reset_handler
= bfad_im_reset_bus_handler
,
841 .slave_alloc
= bfad_im_slave_alloc
,
842 .slave_configure
= bfad_im_slave_configure
,
843 .slave_destroy
= bfad_im_slave_destroy
,
846 .sg_tablesize
= BFAD_IO_MAX_SGE
,
848 .use_clustering
= ENABLE_CLUSTERING
,
849 .shost_attrs
= bfad_im_vport_attrs
,
850 .max_sectors
= BFAD_MAX_SECTORS
,
854 bfad_im_module_init(void)
856 bfad_im_scsi_transport_template
=
857 fc_attach_transport(&bfad_im_fc_function_template
);
858 if (!bfad_im_scsi_transport_template
)
859 return BFA_STATUS_ENOMEM
;
861 bfad_im_scsi_vport_transport_template
=
862 fc_attach_transport(&bfad_im_vport_fc_function_template
);
863 if (!bfad_im_scsi_vport_transport_template
) {
864 fc_release_transport(bfad_im_scsi_transport_template
);
865 return BFA_STATUS_ENOMEM
;
868 return BFA_STATUS_OK
;
872 bfad_im_module_exit(void)
874 if (bfad_im_scsi_transport_template
)
875 fc_release_transport(bfad_im_scsi_transport_template
);
877 if (bfad_im_scsi_vport_transport_template
)
878 fc_release_transport(bfad_im_scsi_vport_transport_template
);
880 idr_destroy(&bfad_im_port_index
);
884 bfad_ramp_up_qdepth(struct bfad_itnim_s
*itnim
, struct scsi_device
*sdev
)
886 struct scsi_device
*tmp_sdev
;
888 if (((jiffies
- itnim
->last_ramp_up_time
) >
889 BFA_QUEUE_FULL_RAMP_UP_TIME
* HZ
) &&
890 ((jiffies
- itnim
->last_queue_full_time
) >
891 BFA_QUEUE_FULL_RAMP_UP_TIME
* HZ
)) {
892 shost_for_each_device(tmp_sdev
, sdev
->host
) {
893 if (bfa_lun_queue_depth
> tmp_sdev
->queue_depth
) {
894 if (tmp_sdev
->id
!= sdev
->id
)
896 scsi_change_queue_depth(tmp_sdev
,
897 tmp_sdev
->queue_depth
+ 1);
899 itnim
->last_ramp_up_time
= jiffies
;
906 bfad_handle_qfull(struct bfad_itnim_s
*itnim
, struct scsi_device
*sdev
)
908 struct scsi_device
*tmp_sdev
;
910 itnim
->last_queue_full_time
= jiffies
;
912 shost_for_each_device(tmp_sdev
, sdev
->host
) {
913 if (tmp_sdev
->id
!= sdev
->id
)
915 scsi_track_queue_full(tmp_sdev
, tmp_sdev
->queue_depth
- 1);
919 struct bfad_itnim_s
*
920 bfad_get_itnim(struct bfad_im_port_s
*im_port
, int id
)
922 struct bfad_itnim_s
*itnim
= NULL
;
924 /* Search the mapped list for this target ID */
925 list_for_each_entry(itnim
, &im_port
->itnim_mapped_list
, list_entry
) {
926 if (id
== itnim
->scsi_tgt_id
)
934 * Function is invoked from the SCSI Host Template slave_alloc() entry point.
935 * Has the logic to query the LUN Mask database to check if this LUN needs to
936 * be made visible to the SCSI mid-layer or not.
938 * Returns BFA_STATUS_OK if this LUN needs to be added to the OS stack.
939 * Returns -ENXIO to notify SCSI mid-layer to not add this LUN to the OS stack.
942 bfad_im_check_if_make_lun_visible(struct scsi_device
*sdev
,
943 struct fc_rport
*rport
)
945 struct bfad_itnim_data_s
*itnim_data
=
946 (struct bfad_itnim_data_s
*) rport
->dd_data
;
947 struct bfa_s
*bfa
= itnim_data
->itnim
->bfa_itnim
->bfa
;
948 struct bfa_rport_s
*bfa_rport
= itnim_data
->itnim
->bfa_itnim
->rport
;
949 struct bfa_lun_mask_s
*lun_list
= bfa_get_lun_mask_list(bfa
);
950 int i
= 0, ret
= -ENXIO
;
952 for (i
= 0; i
< MAX_LUN_MASK_CFG
; i
++) {
953 if (lun_list
[i
].state
== BFA_IOIM_LUN_MASK_ACTIVE
&&
954 scsilun_to_int(&lun_list
[i
].lun
) == sdev
->lun
&&
955 lun_list
[i
].rp_tag
== bfa_rport
->rport_tag
&&
956 lun_list
[i
].lp_tag
== (u8
)bfa_rport
->rport_info
.lp_tag
) {
965 * Scsi_Host template entry slave_alloc
968 bfad_im_slave_alloc(struct scsi_device
*sdev
)
970 struct fc_rport
*rport
= starget_to_rport(scsi_target(sdev
));
971 struct bfad_itnim_data_s
*itnim_data
;
974 if (!rport
|| fc_remote_port_chkready(rport
))
977 itnim_data
= (struct bfad_itnim_data_s
*) rport
->dd_data
;
978 bfa
= itnim_data
->itnim
->bfa_itnim
->bfa
;
980 if (bfa_get_lun_mask_status(bfa
) == BFA_LUNMASK_ENABLED
) {
982 * We should not mask LUN 0 - since this will translate
983 * to no LUN / TARGET for SCSI ml resulting no scan.
985 if (sdev
->lun
== 0) {
986 sdev
->sdev_bflags
|= BLIST_NOREPORTLUN
|
992 * Query LUN Mask configuration - to expose this LUN
993 * to the SCSI mid-layer or to mask it.
995 if (bfad_im_check_if_make_lun_visible(sdev
, rport
) !=
1000 sdev
->hostdata
= rport
->dd_data
;
1006 bfad_im_supported_speeds(struct bfa_s
*bfa
)
1008 struct bfa_ioc_attr_s
*ioc_attr
;
1009 u32 supported_speed
= 0;
1011 ioc_attr
= kzalloc(sizeof(struct bfa_ioc_attr_s
), GFP_KERNEL
);
1015 bfa_ioc_get_attr(&bfa
->ioc
, ioc_attr
);
1016 if (ioc_attr
->adapter_attr
.max_speed
== BFA_PORT_SPEED_16GBPS
)
1017 supported_speed
|= FC_PORTSPEED_16GBIT
| FC_PORTSPEED_8GBIT
|
1018 FC_PORTSPEED_4GBIT
| FC_PORTSPEED_2GBIT
;
1019 else if (ioc_attr
->adapter_attr
.max_speed
== BFA_PORT_SPEED_8GBPS
) {
1020 if (ioc_attr
->adapter_attr
.is_mezz
) {
1021 supported_speed
|= FC_PORTSPEED_8GBIT
|
1022 FC_PORTSPEED_4GBIT
|
1023 FC_PORTSPEED_2GBIT
| FC_PORTSPEED_1GBIT
;
1025 supported_speed
|= FC_PORTSPEED_8GBIT
|
1026 FC_PORTSPEED_4GBIT
|
1029 } else if (ioc_attr
->adapter_attr
.max_speed
== BFA_PORT_SPEED_4GBPS
) {
1030 supported_speed
|= FC_PORTSPEED_4GBIT
| FC_PORTSPEED_2GBIT
|
1032 } else if (ioc_attr
->adapter_attr
.max_speed
== BFA_PORT_SPEED_10GBPS
) {
1033 supported_speed
|= FC_PORTSPEED_10GBIT
;
1036 return supported_speed
;
1040 bfad_fc_host_init(struct bfad_im_port_s
*im_port
)
1042 struct Scsi_Host
*host
= im_port
->shost
;
1043 struct bfad_s
*bfad
= im_port
->bfad
;
1044 struct bfad_port_s
*port
= im_port
->port
;
1045 char symname
[BFA_SYMNAME_MAXLEN
];
1046 struct bfa_fcport_s
*fcport
= BFA_FCPORT_MOD(&bfad
->bfa
);
1048 fc_host_node_name(host
) =
1049 cpu_to_be64((bfa_fcs_lport_get_nwwn(port
->fcs_port
)));
1050 fc_host_port_name(host
) =
1051 cpu_to_be64((bfa_fcs_lport_get_pwwn(port
->fcs_port
)));
1052 fc_host_max_npiv_vports(host
) = bfa_lps_get_max_vport(&bfad
->bfa
);
1054 fc_host_supported_classes(host
) = FC_COS_CLASS3
;
1056 memset(fc_host_supported_fc4s(host
), 0,
1057 sizeof(fc_host_supported_fc4s(host
)));
1058 if (supported_fc4s
& BFA_LPORT_ROLE_FCP_IM
)
1059 /* For FCP type 0x08 */
1060 fc_host_supported_fc4s(host
)[2] = 1;
1061 /* For fibre channel services type 0x20 */
1062 fc_host_supported_fc4s(host
)[7] = 1;
1064 strlcpy(symname
, bfad
->bfa_fcs
.fabric
.bport
.port_cfg
.sym_name
.symname
,
1065 BFA_SYMNAME_MAXLEN
);
1066 sprintf(fc_host_symbolic_name(host
), "%s", symname
);
1068 fc_host_supported_speeds(host
) = bfad_im_supported_speeds(&bfad
->bfa
);
1069 fc_host_maxframe_size(host
) = fcport
->cfg
.maxfrsize
;
1073 bfad_im_fc_rport_add(struct bfad_im_port_s
*im_port
, struct bfad_itnim_s
*itnim
)
1075 struct fc_rport_identifiers rport_ids
;
1076 struct fc_rport
*fc_rport
;
1077 struct bfad_itnim_data_s
*itnim_data
;
1079 rport_ids
.node_name
=
1080 cpu_to_be64(bfa_fcs_itnim_get_nwwn(&itnim
->fcs_itnim
));
1081 rport_ids
.port_name
=
1082 cpu_to_be64(bfa_fcs_itnim_get_pwwn(&itnim
->fcs_itnim
));
1084 bfa_hton3b(bfa_fcs_itnim_get_fcid(&itnim
->fcs_itnim
));
1085 rport_ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
1087 itnim
->fc_rport
= fc_rport
=
1088 fc_remote_port_add(im_port
->shost
, 0, &rport_ids
);
1093 fc_rport
->maxframe_size
=
1094 bfa_fcs_itnim_get_maxfrsize(&itnim
->fcs_itnim
);
1095 fc_rport
->supported_classes
= bfa_fcs_itnim_get_cos(&itnim
->fcs_itnim
);
1097 itnim_data
= fc_rport
->dd_data
;
1098 itnim_data
->itnim
= itnim
;
1100 rport_ids
.roles
|= FC_RPORT_ROLE_FCP_TARGET
;
1102 if (rport_ids
.roles
!= FC_RPORT_ROLE_UNKNOWN
)
1103 fc_remote_port_rolechg(fc_rport
, rport_ids
.roles
);
1105 if ((fc_rport
->scsi_target_id
!= -1)
1106 && (fc_rport
->scsi_target_id
< MAX_FCP_TARGET
))
1107 itnim
->scsi_tgt_id
= fc_rport
->scsi_target_id
;
1109 itnim
->channel
= fc_rport
->channel
;
1115 * Work queue handler using FC transport service
1119 bfad_im_itnim_work_handler(struct work_struct
*work
)
1121 struct bfad_itnim_s
*itnim
= container_of(work
, struct bfad_itnim_s
,
1123 struct bfad_im_s
*im
= itnim
->im
;
1124 struct bfad_s
*bfad
= im
->bfad
;
1125 struct bfad_im_port_s
*im_port
;
1126 unsigned long flags
;
1127 struct fc_rport
*fc_rport
;
1130 char wwpn_str
[32], fcid_str
[16];
1132 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1133 im_port
= itnim
->im_port
;
1134 bfa_trc(bfad
, itnim
->state
);
1135 switch (itnim
->state
) {
1136 case ITNIM_STATE_ONLINE
:
1137 if (!itnim
->fc_rport
) {
1138 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1139 bfad_im_fc_rport_add(im_port
, itnim
);
1140 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1141 wwpn
= bfa_fcs_itnim_get_pwwn(&itnim
->fcs_itnim
);
1142 fcid
= bfa_fcs_itnim_get_fcid(&itnim
->fcs_itnim
);
1143 wwn2str(wwpn_str
, wwpn
);
1144 fcid2str(fcid_str
, fcid
);
1145 list_add_tail(&itnim
->list_entry
,
1146 &im_port
->itnim_mapped_list
);
1147 BFA_LOG(KERN_INFO
, bfad
, bfa_log_level
,
1148 "ITNIM ONLINE Target: %d:0:%d "
1149 "FCID: %s WWPN: %s\n",
1150 im_port
->shost
->host_no
,
1152 fcid_str
, wwpn_str
);
1155 "%s: itnim %llx is already in online state\n",
1157 bfa_fcs_itnim_get_pwwn(&itnim
->fcs_itnim
));
1161 case ITNIM_STATE_OFFLINE_PENDING
:
1162 itnim
->state
= ITNIM_STATE_OFFLINE
;
1163 if (itnim
->fc_rport
) {
1164 fc_rport
= itnim
->fc_rport
;
1165 ((struct bfad_itnim_data_s
*)
1166 fc_rport
->dd_data
)->itnim
= NULL
;
1167 itnim
->fc_rport
= NULL
;
1168 if (!(im_port
->port
->flags
& BFAD_PORT_DELETE
)) {
1169 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1170 fc_rport
->dev_loss_tmo
=
1171 bfa_fcpim_path_tov_get(&bfad
->bfa
) + 1;
1172 fc_remote_port_delete(fc_rport
);
1173 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1175 wwpn
= bfa_fcs_itnim_get_pwwn(&itnim
->fcs_itnim
);
1176 fcid
= bfa_fcs_itnim_get_fcid(&itnim
->fcs_itnim
);
1177 wwn2str(wwpn_str
, wwpn
);
1178 fcid2str(fcid_str
, fcid
);
1179 list_del(&itnim
->list_entry
);
1180 BFA_LOG(KERN_INFO
, bfad
, bfa_log_level
,
1181 "ITNIM OFFLINE Target: %d:0:%d "
1182 "FCID: %s WWPN: %s\n",
1183 im_port
->shost
->host_no
,
1185 fcid_str
, wwpn_str
);
1188 case ITNIM_STATE_FREE
:
1189 if (itnim
->fc_rport
) {
1190 fc_rport
= itnim
->fc_rport
;
1191 ((struct bfad_itnim_data_s
*)
1192 fc_rport
->dd_data
)->itnim
= NULL
;
1193 itnim
->fc_rport
= NULL
;
1194 if (!(im_port
->port
->flags
& BFAD_PORT_DELETE
)) {
1195 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1196 fc_rport
->dev_loss_tmo
=
1197 bfa_fcpim_path_tov_get(&bfad
->bfa
) + 1;
1198 fc_remote_port_delete(fc_rport
);
1199 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1201 list_del(&itnim
->list_entry
);
1211 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1215 * Scsi_Host template entry, queue a SCSI command to the BFAD.
1218 bfad_im_queuecommand_lck(struct scsi_cmnd
*cmnd
, void (*done
) (struct scsi_cmnd
*))
1220 struct bfad_im_port_s
*im_port
=
1221 (struct bfad_im_port_s
*) cmnd
->device
->host
->hostdata
[0];
1222 struct bfad_s
*bfad
= im_port
->bfad
;
1223 struct bfad_itnim_data_s
*itnim_data
= cmnd
->device
->hostdata
;
1224 struct bfad_itnim_s
*itnim
;
1225 struct bfa_ioim_s
*hal_io
;
1226 unsigned long flags
;
1229 struct fc_rport
*rport
= starget_to_rport(scsi_target(cmnd
->device
));
1231 rc
= fc_remote_port_chkready(rport
);
1238 if (bfad
->bfad_flags
& BFAD_EEH_BUSY
) {
1239 if (bfad
->bfad_flags
& BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE
)
1240 cmnd
->result
= DID_NO_CONNECT
<< 16;
1242 cmnd
->result
= DID_REQUEUE
<< 16;
1247 sg_cnt
= scsi_dma_map(cmnd
);
1249 return SCSI_MLQUEUE_HOST_BUSY
;
1251 cmnd
->scsi_done
= done
;
1253 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1254 if (!(bfad
->bfad_flags
& BFAD_HAL_START_DONE
)) {
1256 "bfad%d, queuecommand %p %x failed, BFA stopped\n",
1257 bfad
->inst_no
, cmnd
, cmnd
->cmnd
[0]);
1258 cmnd
->result
= ScsiResult(DID_NO_CONNECT
, 0);
1263 itnim
= itnim_data
->itnim
;
1265 cmnd
->result
= ScsiResult(DID_IMM_RETRY
, 0);
1269 hal_io
= bfa_ioim_alloc(&bfad
->bfa
, (struct bfad_ioim_s
*) cmnd
,
1270 itnim
->bfa_itnim
, sg_cnt
);
1272 printk(KERN_WARNING
"hal_io failure\n");
1273 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1274 scsi_dma_unmap(cmnd
);
1275 return SCSI_MLQUEUE_HOST_BUSY
;
1278 cmnd
->host_scribble
= (char *)hal_io
;
1279 bfa_ioim_start(hal_io
);
1280 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1285 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1286 scsi_dma_unmap(cmnd
);
1293 static DEF_SCSI_QCMD(bfad_im_queuecommand
)
1296 bfad_rport_online_wait(struct bfad_s
*bfad
)
1299 int rport_delay
= 10;
1301 for (i
= 0; !(bfad
->bfad_flags
& BFAD_PORT_ONLINE
)
1302 && i
< bfa_linkup_delay
; i
++) {
1303 set_current_state(TASK_UNINTERRUPTIBLE
);
1304 schedule_timeout(HZ
);
1307 if (bfad
->bfad_flags
& BFAD_PORT_ONLINE
) {
1308 rport_delay
= rport_delay
< bfa_linkup_delay
?
1309 rport_delay
: bfa_linkup_delay
;
1310 for (i
= 0; !(bfad
->bfad_flags
& BFAD_RPORT_ONLINE
)
1311 && i
< rport_delay
; i
++) {
1312 set_current_state(TASK_UNINTERRUPTIBLE
);
1313 schedule_timeout(HZ
);
1316 if (rport_delay
> 0 && (bfad
->bfad_flags
& BFAD_RPORT_ONLINE
)) {
1317 set_current_state(TASK_UNINTERRUPTIBLE
);
1318 schedule_timeout(rport_delay
* HZ
);
1324 bfad_get_linkup_delay(struct bfad_s
*bfad
)
1327 wwn_t wwns
[BFA_PREBOOT_BOOTLUN_MAX
];
1331 * Querying for the boot target port wwns
1332 * -- read from boot information in flash.
1333 * If nwwns > 0 => boot over SAN and set linkup_delay = 30
1334 * else => local boot machine set linkup_delay = 0
1337 bfa_iocfc_get_bootwwns(&bfad
->bfa
, &nwwns
, wwns
);
1340 /* If Boot over SAN set linkup_delay = 30sec */
1343 /* If local boot; no linkup_delay */
1346 return linkup_delay
;