4 * Fibre Channel related functions for the zfcp device driver.
6 * Copyright IBM Corporation 2008
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
14 enum rscn_address_format
{
15 RSCN_PORT_ADDRESS
= 0x0,
16 RSCN_AREA_ADDRESS
= 0x1,
17 RSCN_DOMAIN_ADDRESS
= 0x2,
18 RSCN_FABRIC_ADDRESS
= 0x3,
21 static u32 rscn_range_mask
[] = {
22 [RSCN_PORT_ADDRESS
] = 0xFFFFFF,
23 [RSCN_AREA_ADDRESS
] = 0xFFFF00,
24 [RSCN_DOMAIN_ADDRESS
] = 0xFF0000,
25 [RSCN_FABRIC_ADDRESS
] = 0x000000,
28 struct ct_iu_gpn_ft_req
{
34 } __attribute__ ((packed
));
36 struct gpn_ft_resp_acc
{
41 } __attribute__ ((packed
));
43 #define ZFCP_CT_SIZE_ONE_PAGE (PAGE_SIZE - sizeof(struct ct_hdr))
44 #define ZFCP_GPN_FT_ENTRIES (ZFCP_CT_SIZE_ONE_PAGE \
45 / sizeof(struct gpn_ft_resp_acc))
46 #define ZFCP_GPN_FT_BUFFERS 4
47 #define ZFCP_GPN_FT_MAX_SIZE (ZFCP_GPN_FT_BUFFERS * PAGE_SIZE \
48 - sizeof(struct ct_hdr))
49 #define ZFCP_GPN_FT_MAX_ENTRIES ZFCP_GPN_FT_BUFFERS * (ZFCP_GPN_FT_ENTRIES + 1)
51 struct ct_iu_gpn_ft_resp
{
53 struct gpn_ft_resp_acc accept
[ZFCP_GPN_FT_ENTRIES
];
54 } __attribute__ ((packed
));
57 struct zfcp_send_ct ct
;
58 struct scatterlist sg_req
;
59 struct scatterlist sg_resp
[ZFCP_GPN_FT_BUFFERS
];
62 struct zfcp_fc_ns_handler_data
{
63 struct completion done
;
64 void (*handler
)(unsigned long);
65 unsigned long handler_data
;
68 static int zfcp_wka_port_get(struct zfcp_wka_port
*wka_port
)
70 if (mutex_lock_interruptible(&wka_port
->mutex
))
73 if (wka_port
->status
== ZFCP_WKA_PORT_OFFLINE
||
74 wka_port
->status
== ZFCP_WKA_PORT_CLOSING
) {
75 wka_port
->status
= ZFCP_WKA_PORT_OPENING
;
76 if (zfcp_fsf_open_wka_port(wka_port
))
77 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
80 mutex_unlock(&wka_port
->mutex
);
83 wka_port
->completion_wq
,
84 wka_port
->status
== ZFCP_WKA_PORT_ONLINE
||
85 wka_port
->status
== ZFCP_WKA_PORT_OFFLINE
,
88 if (wka_port
->status
== ZFCP_WKA_PORT_ONLINE
) {
89 atomic_inc(&wka_port
->refcount
);
95 static void zfcp_wka_port_offline(struct work_struct
*work
)
97 struct delayed_work
*dw
= container_of(work
, struct delayed_work
, work
);
98 struct zfcp_wka_port
*wka_port
=
99 container_of(dw
, struct zfcp_wka_port
, work
);
101 wait_event(wka_port
->completion_wq
,
102 atomic_read(&wka_port
->refcount
) == 0);
104 mutex_lock(&wka_port
->mutex
);
105 if ((atomic_read(&wka_port
->refcount
) != 0) ||
106 (wka_port
->status
!= ZFCP_WKA_PORT_ONLINE
))
109 wka_port
->status
= ZFCP_WKA_PORT_CLOSING
;
110 if (zfcp_fsf_close_wka_port(wka_port
)) {
111 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
112 wake_up(&wka_port
->completion_wq
);
115 mutex_unlock(&wka_port
->mutex
);
118 static void zfcp_wka_port_put(struct zfcp_wka_port
*wka_port
)
120 if (atomic_dec_return(&wka_port
->refcount
) != 0)
122 /* wait 10 miliseconds, other reqs might pop in */
123 schedule_delayed_work(&wka_port
->work
, HZ
/ 100);
126 void zfcp_fc_nameserver_init(struct zfcp_adapter
*adapter
)
128 struct zfcp_wka_port
*wka_port
= &adapter
->nsp
;
130 init_waitqueue_head(&wka_port
->completion_wq
);
132 wka_port
->adapter
= adapter
;
133 wka_port
->d_id
= ZFCP_DID_DIRECTORY_SERVICE
;
135 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
136 atomic_set(&wka_port
->refcount
, 0);
137 mutex_init(&wka_port
->mutex
);
138 INIT_DELAYED_WORK(&wka_port
->work
, zfcp_wka_port_offline
);
141 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
, u32 range
,
142 struct fcp_rscn_element
*elem
)
145 struct zfcp_port
*port
;
147 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
148 list_for_each_entry(port
, &fsf_req
->adapter
->port_list_head
, list
)
149 if ((port
->d_id
& range
) == (elem
->nport_did
& range
))
150 zfcp_test_link(port
);
152 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
155 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
)
157 struct fsf_status_read_buffer
*status_buffer
= (void *)fsf_req
->data
;
158 struct fcp_rscn_head
*fcp_rscn_head
;
159 struct fcp_rscn_element
*fcp_rscn_element
;
164 fcp_rscn_head
= (struct fcp_rscn_head
*) status_buffer
->payload
.data
;
165 fcp_rscn_element
= (struct fcp_rscn_element
*) fcp_rscn_head
;
168 no_entries
= fcp_rscn_head
->payload_len
/
169 sizeof(struct fcp_rscn_element
);
171 for (i
= 1; i
< no_entries
; i
++) {
172 /* skip head and start with 1st element */
174 range_mask
= rscn_range_mask
[fcp_rscn_element
->addr_format
];
175 _zfcp_fc_incoming_rscn(fsf_req
, range_mask
, fcp_rscn_element
);
177 schedule_work(&fsf_req
->adapter
->scan_work
);
180 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req
*req
, u64 wwpn
)
182 struct zfcp_adapter
*adapter
= req
->adapter
;
183 struct zfcp_port
*port
;
186 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
187 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
188 if (port
->wwpn
== wwpn
)
190 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
192 if (port
&& (port
->wwpn
== wwpn
))
193 zfcp_erp_port_forced_reopen(port
, 0, "fciwwp1", req
);
196 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req
*req
)
198 struct fsf_status_read_buffer
*status_buffer
=
199 (struct fsf_status_read_buffer
*)req
->data
;
200 struct fsf_plogi
*els_plogi
=
201 (struct fsf_plogi
*) status_buffer
->payload
.data
;
203 zfcp_fc_incoming_wwpn(req
, els_plogi
->serv_param
.wwpn
);
206 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req
*req
)
208 struct fsf_status_read_buffer
*status_buffer
=
209 (struct fsf_status_read_buffer
*)req
->data
;
210 struct fcp_logo
*els_logo
=
211 (struct fcp_logo
*) status_buffer
->payload
.data
;
213 zfcp_fc_incoming_wwpn(req
, els_logo
->nport_wwpn
);
217 * zfcp_fc_incoming_els - handle incoming ELS
218 * @fsf_req - request which contains incoming ELS
220 void zfcp_fc_incoming_els(struct zfcp_fsf_req
*fsf_req
)
222 struct fsf_status_read_buffer
*status_buffer
=
223 (struct fsf_status_read_buffer
*) fsf_req
->data
;
224 unsigned int els_type
= status_buffer
->payload
.data
[0];
226 zfcp_san_dbf_event_incoming_els(fsf_req
);
227 if (els_type
== LS_PLOGI
)
228 zfcp_fc_incoming_plogi(fsf_req
);
229 else if (els_type
== LS_LOGO
)
230 zfcp_fc_incoming_logo(fsf_req
);
231 else if (els_type
== LS_RSCN
)
232 zfcp_fc_incoming_rscn(fsf_req
);
235 static void zfcp_fc_ns_handler(unsigned long data
)
237 struct zfcp_fc_ns_handler_data
*compl_rec
=
238 (struct zfcp_fc_ns_handler_data
*) data
;
240 if (compl_rec
->handler
)
241 compl_rec
->handler(compl_rec
->handler_data
);
243 complete(&compl_rec
->done
);
246 static void zfcp_fc_ns_gid_pn_eval(unsigned long data
)
248 struct zfcp_gid_pn_data
*gid_pn
= (struct zfcp_gid_pn_data
*) data
;
249 struct zfcp_send_ct
*ct
= &gid_pn
->ct
;
250 struct ct_iu_gid_pn_req
*ct_iu_req
= sg_virt(ct
->req
);
251 struct ct_iu_gid_pn_resp
*ct_iu_resp
= sg_virt(ct
->resp
);
252 struct zfcp_port
*port
= gid_pn
->port
;
256 if (ct_iu_resp
->header
.cmd_rsp_code
!= ZFCP_CT_ACCEPT
)
260 if (ct_iu_req
->wwpn
!= port
->wwpn
)
262 /* looks like a valid d_id */
263 port
->d_id
= ct_iu_resp
->d_id
& ZFCP_DID_MASK
;
266 int static zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action
*erp_action
,
267 struct zfcp_gid_pn_data
*gid_pn
)
269 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
270 struct zfcp_fc_ns_handler_data compl_rec
;
273 /* setup parameters for send generic command */
274 gid_pn
->port
= erp_action
->port
;
275 gid_pn
->ct
.wka_port
= &adapter
->nsp
;
276 gid_pn
->ct
.handler
= zfcp_fc_ns_handler
;
277 gid_pn
->ct
.handler_data
= (unsigned long) &compl_rec
;
278 gid_pn
->ct
.timeout
= ZFCP_NS_GID_PN_TIMEOUT
;
279 gid_pn
->ct
.req
= &gid_pn
->req
;
280 gid_pn
->ct
.resp
= &gid_pn
->resp
;
281 sg_init_one(&gid_pn
->req
, &gid_pn
->ct_iu_req
,
282 sizeof(struct ct_iu_gid_pn_req
));
283 sg_init_one(&gid_pn
->resp
, &gid_pn
->ct_iu_resp
,
284 sizeof(struct ct_iu_gid_pn_resp
));
286 /* setup nameserver request */
287 gid_pn
->ct_iu_req
.header
.revision
= ZFCP_CT_REVISION
;
288 gid_pn
->ct_iu_req
.header
.gs_type
= ZFCP_CT_DIRECTORY_SERVICE
;
289 gid_pn
->ct_iu_req
.header
.gs_subtype
= ZFCP_CT_NAME_SERVER
;
290 gid_pn
->ct_iu_req
.header
.options
= ZFCP_CT_SYNCHRONOUS
;
291 gid_pn
->ct_iu_req
.header
.cmd_rsp_code
= ZFCP_CT_GID_PN
;
292 gid_pn
->ct_iu_req
.header
.max_res_size
= ZFCP_CT_SIZE_ONE_PAGE
/ 4;
293 gid_pn
->ct_iu_req
.wwpn
= erp_action
->port
->wwpn
;
295 init_completion(&compl_rec
.done
);
296 compl_rec
.handler
= zfcp_fc_ns_gid_pn_eval
;
297 compl_rec
.handler_data
= (unsigned long) gid_pn
;
298 ret
= zfcp_fsf_send_ct(&gid_pn
->ct
, adapter
->pool
.fsf_req_erp
,
301 wait_for_completion(&compl_rec
.done
);
306 * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
307 * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed
308 * return: -ENOMEM on error, 0 otherwise
310 int zfcp_fc_ns_gid_pn(struct zfcp_erp_action
*erp_action
)
313 struct zfcp_gid_pn_data
*gid_pn
;
314 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
316 gid_pn
= mempool_alloc(adapter
->pool
.data_gid_pn
, GFP_ATOMIC
);
320 memset(gid_pn
, 0, sizeof(*gid_pn
));
322 ret
= zfcp_wka_port_get(&adapter
->nsp
);
326 ret
= zfcp_fc_ns_gid_pn_request(erp_action
, gid_pn
);
328 zfcp_wka_port_put(&adapter
->nsp
);
330 mempool_free(gid_pn
, adapter
->pool
.data_gid_pn
);
335 * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
336 * @port: zfcp_port structure
337 * @plogi: plogi payload
339 * Evaluate PLOGI playload and copy important fields into zfcp_port structure
341 void zfcp_fc_plogi_evaluate(struct zfcp_port
*port
, struct fsf_plogi
*plogi
)
343 port
->maxframe_size
= plogi
->serv_param
.common_serv_param
[7] |
344 ((plogi
->serv_param
.common_serv_param
[6] & 0x0F) << 8);
345 if (plogi
->serv_param
.class1_serv_param
[0] & 0x80)
346 port
->supported_classes
|= FC_COS_CLASS1
;
347 if (plogi
->serv_param
.class2_serv_param
[0] & 0x80)
348 port
->supported_classes
|= FC_COS_CLASS2
;
349 if (plogi
->serv_param
.class3_serv_param
[0] & 0x80)
350 port
->supported_classes
|= FC_COS_CLASS3
;
351 if (plogi
->serv_param
.class4_serv_param
[0] & 0x80)
352 port
->supported_classes
|= FC_COS_CLASS4
;
355 struct zfcp_els_adisc
{
356 struct zfcp_send_els els
;
357 struct scatterlist req
;
358 struct scatterlist resp
;
359 struct zfcp_ls_adisc ls_adisc
;
360 struct zfcp_ls_adisc ls_adisc_acc
;
363 static void zfcp_fc_adisc_handler(unsigned long data
)
365 struct zfcp_els_adisc
*adisc
= (struct zfcp_els_adisc
*) data
;
366 struct zfcp_port
*port
= adisc
->els
.port
;
367 struct zfcp_ls_adisc
*ls_adisc
= &adisc
->ls_adisc_acc
;
369 if (adisc
->els
.status
) {
370 /* request rejected or timed out */
371 zfcp_erp_port_forced_reopen(port
, 0, "fcadh_1", NULL
);
376 port
->wwnn
= ls_adisc
->wwnn
;
378 if ((port
->wwpn
!= ls_adisc
->wwpn
) ||
379 !(atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_OPEN
))
380 zfcp_erp_port_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
388 static int zfcp_fc_adisc(struct zfcp_port
*port
)
390 struct zfcp_els_adisc
*adisc
;
391 struct zfcp_adapter
*adapter
= port
->adapter
;
393 adisc
= kzalloc(sizeof(struct zfcp_els_adisc
), GFP_ATOMIC
);
397 adisc
->els
.req
= &adisc
->req
;
398 adisc
->els
.resp
= &adisc
->resp
;
399 sg_init_one(adisc
->els
.req
, &adisc
->ls_adisc
,
400 sizeof(struct zfcp_ls_adisc
));
401 sg_init_one(adisc
->els
.resp
, &adisc
->ls_adisc_acc
,
402 sizeof(struct zfcp_ls_adisc
));
404 adisc
->els
.adapter
= adapter
;
405 adisc
->els
.port
= port
;
406 adisc
->els
.d_id
= port
->d_id
;
407 adisc
->els
.handler
= zfcp_fc_adisc_handler
;
408 adisc
->els
.handler_data
= (unsigned long) adisc
;
409 adisc
->els
.ls_code
= adisc
->ls_adisc
.code
= ZFCP_LS_ADISC
;
411 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
412 without FC-AL-2 capability, so we don't set it */
413 adisc
->ls_adisc
.wwpn
= fc_host_port_name(adapter
->scsi_host
);
414 adisc
->ls_adisc
.wwnn
= fc_host_node_name(adapter
->scsi_host
);
415 adisc
->ls_adisc
.nport_id
= fc_host_port_id(adapter
->scsi_host
);
417 return zfcp_fsf_send_els(&adisc
->els
);
420 void zfcp_fc_link_test_work(struct work_struct
*work
)
422 struct zfcp_port
*port
=
423 container_of(work
, struct zfcp_port
, test_link_work
);
426 retval
= zfcp_fc_adisc(port
);
430 /* send of ADISC was not possible */
432 if (retval
!= -EBUSY
)
433 zfcp_erp_port_forced_reopen(port
, 0, "fcltwk1", NULL
);
437 * zfcp_test_link - lightweight link test procedure
438 * @port: port to be tested
440 * Test status of a link to a remote port using the ELS command ADISC.
441 * If there is a problem with the remote port, error recovery steps
444 void zfcp_test_link(struct zfcp_port
*port
)
447 if (!queue_work(zfcp_data
.work_queue
, &port
->test_link_work
))
451 static void zfcp_free_sg_env(struct zfcp_gpn_ft
*gpn_ft
, int buf_num
)
453 struct scatterlist
*sg
= &gpn_ft
->sg_req
;
455 kfree(sg_virt(sg
)); /* free request buffer */
456 zfcp_sg_free_table(gpn_ft
->sg_resp
, buf_num
);
461 static struct zfcp_gpn_ft
*zfcp_alloc_sg_env(int buf_num
)
463 struct zfcp_gpn_ft
*gpn_ft
;
464 struct ct_iu_gpn_ft_req
*req
;
466 gpn_ft
= kzalloc(sizeof(*gpn_ft
), GFP_KERNEL
);
470 req
= kzalloc(sizeof(struct ct_iu_gpn_ft_req
), GFP_KERNEL
);
476 sg_init_one(&gpn_ft
->sg_req
, req
, sizeof(*req
));
478 if (zfcp_sg_setup_table(gpn_ft
->sg_resp
, buf_num
)) {
479 zfcp_free_sg_env(gpn_ft
, buf_num
);
487 static int zfcp_scan_issue_gpn_ft(struct zfcp_gpn_ft
*gpn_ft
,
488 struct zfcp_adapter
*adapter
,
491 struct zfcp_send_ct
*ct
= &gpn_ft
->ct
;
492 struct ct_iu_gpn_ft_req
*req
= sg_virt(&gpn_ft
->sg_req
);
493 struct zfcp_fc_ns_handler_data compl_rec
;
496 /* prepare CT IU for GPN_FT */
497 req
->header
.revision
= ZFCP_CT_REVISION
;
498 req
->header
.gs_type
= ZFCP_CT_DIRECTORY_SERVICE
;
499 req
->header
.gs_subtype
= ZFCP_CT_NAME_SERVER
;
500 req
->header
.options
= ZFCP_CT_SYNCHRONOUS
;
501 req
->header
.cmd_rsp_code
= ZFCP_CT_GPN_FT
;
502 req
->header
.max_res_size
= max_bytes
/ 4;
504 req
->domain_id_scope
= 0;
505 req
->area_id_scope
= 0;
506 req
->fc4_type
= ZFCP_CT_SCSI_FCP
;
508 /* prepare zfcp_send_ct */
509 ct
->wka_port
= &adapter
->nsp
;
510 ct
->handler
= zfcp_fc_ns_handler
;
511 ct
->handler_data
= (unsigned long)&compl_rec
;
513 ct
->req
= &gpn_ft
->sg_req
;
514 ct
->resp
= gpn_ft
->sg_resp
;
516 init_completion(&compl_rec
.done
);
517 compl_rec
.handler
= NULL
;
518 ret
= zfcp_fsf_send_ct(ct
, NULL
, NULL
);
520 wait_for_completion(&compl_rec
.done
);
524 static void zfcp_validate_port(struct zfcp_port
*port
)
526 struct zfcp_adapter
*adapter
= port
->adapter
;
528 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC
, &port
->status
);
530 if ((port
->supported_classes
!= 0) ||
531 !list_empty(&port
->unit_list_head
)) {
535 zfcp_erp_port_shutdown(port
, 0, "fcpval1", NULL
);
536 zfcp_erp_wait(adapter
);
538 zfcp_port_dequeue(port
);
541 static int zfcp_scan_eval_gpn_ft(struct zfcp_gpn_ft
*gpn_ft
, int max_entries
)
543 struct zfcp_send_ct
*ct
= &gpn_ft
->ct
;
544 struct scatterlist
*sg
= gpn_ft
->sg_resp
;
545 struct ct_hdr
*hdr
= sg_virt(sg
);
546 struct gpn_ft_resp_acc
*acc
= sg_virt(sg
);
547 struct zfcp_adapter
*adapter
= ct
->wka_port
->adapter
;
548 struct zfcp_port
*port
, *tmp
;
550 int ret
= 0, x
, last
= 0;
555 if (hdr
->cmd_rsp_code
!= ZFCP_CT_ACCEPT
) {
556 if (hdr
->reason_code
== ZFCP_CT_UNABLE_TO_PERFORM_CMD
)
557 return -EAGAIN
; /* might be a temporary condition */
561 if (hdr
->max_res_size
) {
562 dev_warn(&adapter
->ccw_device
->dev
,
563 "The name server reported %d words residual data\n",
568 down(&zfcp_data
.config_sema
);
570 /* first entry is the header */
571 for (x
= 1; x
< max_entries
&& !last
; x
++) {
572 if (x
% (ZFCP_GPN_FT_ENTRIES
+ 1))
577 last
= acc
->control
& 0x80;
578 d_id
= acc
->port_id
[0] << 16 | acc
->port_id
[1] << 8 |
581 /* don't attach ports with a well known address */
582 if ((d_id
& ZFCP_DID_WKA
) == ZFCP_DID_WKA
)
584 /* skip the adapter's port and known remote ports */
585 if (acc
->wwpn
== fc_host_port_name(adapter
->scsi_host
))
587 port
= zfcp_get_port_by_wwpn(adapter
, acc
->wwpn
);
593 port
= zfcp_port_enqueue(adapter
, acc
->wwpn
,
594 ZFCP_STATUS_COMMON_NOESC
, d_id
);
598 zfcp_erp_port_reopen(port
, 0, "fcegpf1", NULL
);
601 zfcp_erp_wait(adapter
);
602 list_for_each_entry_safe(port
, tmp
, &adapter
->port_list_head
, list
)
603 zfcp_validate_port(port
);
604 up(&zfcp_data
.config_sema
);
609 * zfcp_scan_ports - scan remote ports and attach new ports
610 * @adapter: pointer to struct zfcp_adapter
612 int zfcp_scan_ports(struct zfcp_adapter
*adapter
)
615 struct zfcp_gpn_ft
*gpn_ft
;
616 int chain
, max_entries
, buf_num
, max_bytes
;
618 chain
= adapter
->adapter_features
& FSF_FEATURE_ELS_CT_CHAINED_SBALS
;
619 buf_num
= chain
? ZFCP_GPN_FT_BUFFERS
: 1;
620 max_entries
= chain
? ZFCP_GPN_FT_MAX_ENTRIES
: ZFCP_GPN_FT_ENTRIES
;
621 max_bytes
= chain
? ZFCP_GPN_FT_MAX_SIZE
: ZFCP_CT_SIZE_ONE_PAGE
;
623 if (fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPORT
)
626 ret
= zfcp_wka_port_get(&adapter
->nsp
);
630 gpn_ft
= zfcp_alloc_sg_env(buf_num
);
636 for (i
= 0; i
< 3; i
++) {
637 ret
= zfcp_scan_issue_gpn_ft(gpn_ft
, adapter
, max_bytes
);
639 ret
= zfcp_scan_eval_gpn_ft(gpn_ft
, max_entries
);
646 zfcp_free_sg_env(gpn_ft
, buf_num
);
648 zfcp_wka_port_put(&adapter
->nsp
);
653 void _zfcp_scan_ports_later(struct work_struct
*work
)
655 zfcp_scan_ports(container_of(work
, struct zfcp_adapter
, scan_work
));