xref: /openbmc/linux/drivers/scsi/libfc/fc_lport.c (revision b6dcefde)
1 /*
2  * Copyright(c) 2007 Intel Corporation. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License along with
14  * this program; if not, write to the Free Software Foundation, Inc.,
15  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
16  *
17  * Maintained at www.Open-FCoE.org
18  */
19 
20 /*
21  * PORT LOCKING NOTES
22  *
23  * These comments only apply to the 'port code' which consists of the lport,
24  * disc and rport blocks.
25  *
26  * MOTIVATION
27  *
28  * The lport, disc and rport blocks all have mutexes that are used to protect
29  * those objects. The main motivation for these locks is to prevent from
30  * having an lport reset just before we send a frame. In that scenario the
31  * lport's FID would get set to zero and then we'd send a frame with an
32  * invalid SID. We also need to ensure that states don't change unexpectedly
33  * while processing another state.
34  *
35  * HEIRARCHY
36  *
37  * The following heirarchy defines the locking rules. A greater lock
38  * may be held before acquiring a lesser lock, but a lesser lock should never
39  * be held while attempting to acquire a greater lock. Here is the heirarchy-
40  *
41  * lport > disc, lport > rport, disc > rport
42  *
43  * CALLBACKS
44  *
45  * The callbacks cause complications with this scheme. There is a callback
46  * from the rport (to either lport or disc) and a callback from disc
47  * (to the lport).
48  *
49  * As rports exit the rport state machine a callback is made to the owner of
50  * the rport to notify success or failure. Since the callback is likely to
51  * cause the lport or disc to grab its lock we cannot hold the rport lock
52  * while making the callback. To ensure that the rport is not free'd while
53  * processing the callback the rport callbacks are serialized through a
54  * single-threaded workqueue. An rport would never be free'd while in a
55  * callback handler becuase no other rport work in this queue can be executed
56  * at the same time.
57  *
58  * When discovery succeeds or fails a callback is made to the lport as
59  * notification. Currently, successful discovery causes the lport to take no
60  * action. A failure will cause the lport to reset. There is likely a circular
61  * locking problem with this implementation.
62  */
63 
64 /*
65  * LPORT LOCKING
66  *
67  * The critical sections protected by the lport's mutex are quite broad and
68  * may be improved upon in the future. The lport code and its locking doesn't
69  * influence the I/O path, so excessive locking doesn't penalize I/O
70  * performance.
71  *
72  * The strategy is to lock whenever processing a request or response. Note
73  * that every _enter_* function corresponds to a state change. They generally
74  * change the lports state and then send a request out on the wire. We lock
75  * before calling any of these functions to protect that state change. This
76  * means that the entry points into the lport block manage the locks while
77  * the state machine can transition between states (i.e. _enter_* functions)
78  * while always staying protected.
79  *
80  * When handling responses we also hold the lport mutex broadly. When the
81  * lport receives the response frame it locks the mutex and then calls the
82  * appropriate handler for the particuar response. Generally a response will
83  * trigger a state change and so the lock must already be held.
84  *
85  * Retries also have to consider the locking. The retries occur from a work
86  * context and the work function will lock the lport and then retry the state
87  * (i.e. _enter_* function).
88  */
89 
90 #include <linux/timer.h>
91 #include <asm/unaligned.h>
92 
93 #include <scsi/fc/fc_gs.h>
94 
95 #include <scsi/libfc.h>
96 #include <scsi/fc_encode.h>
97 #include <linux/scatterlist.h>
98 
99 #include "fc_libfc.h"
100 
101 /* Fabric IDs to use for point-to-point mode, chosen on whims. */
102 #define FC_LOCAL_PTP_FID_LO   0x010101
103 #define FC_LOCAL_PTP_FID_HI   0x010102
104 
105 #define	DNS_DELAY	      3 /* Discovery delay after RSCN (in seconds)*/
106 
107 static void fc_lport_error(struct fc_lport *, struct fc_frame *);
108 
109 static void fc_lport_enter_reset(struct fc_lport *);
110 static void fc_lport_enter_flogi(struct fc_lport *);
111 static void fc_lport_enter_dns(struct fc_lport *);
112 static void fc_lport_enter_ns(struct fc_lport *, enum fc_lport_state);
113 static void fc_lport_enter_scr(struct fc_lport *);
114 static void fc_lport_enter_ready(struct fc_lport *);
115 static void fc_lport_enter_logo(struct fc_lport *);
116 
117 static const char *fc_lport_state_names[] = {
118 	[LPORT_ST_DISABLED] = "disabled",
119 	[LPORT_ST_FLOGI] =    "FLOGI",
120 	[LPORT_ST_DNS] =      "dNS",
121 	[LPORT_ST_RNN_ID] =   "RNN_ID",
122 	[LPORT_ST_RSNN_NN] =  "RSNN_NN",
123 	[LPORT_ST_RSPN_ID] =  "RSPN_ID",
124 	[LPORT_ST_RFT_ID] =   "RFT_ID",
125 	[LPORT_ST_RFF_ID] =   "RFF_ID",
126 	[LPORT_ST_SCR] =      "SCR",
127 	[LPORT_ST_READY] =    "Ready",
128 	[LPORT_ST_LOGO] =     "LOGO",
129 	[LPORT_ST_RESET] =    "reset",
130 };
131 
132 /**
133  * struct fc_bsg_info - FC Passthrough managemet structure
134  * @job:      The passthrough job
135  * @lport:    The local port to pass through a command
136  * @rsp_code: The expected response code
137  * @sg:	      job->reply_payload.sg_list
138  * @nents:    job->reply_payload.sg_cnt
139  * @offset:   The offset into the response data
140  */
141 struct fc_bsg_info {
142 	struct fc_bsg_job *job;
143 	struct fc_lport *lport;
144 	u16 rsp_code;
145 	struct scatterlist *sg;
146 	u32 nents;
147 	size_t offset;
148 };
149 
150 /**
151  * fc_frame_drop() - Dummy frame handler
152  * @lport: The local port the frame was received on
153  * @fp:	   The received frame
154  */
155 static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp)
156 {
157 	fc_frame_free(fp);
158 	return 0;
159 }
160 
161 /**
162  * fc_lport_rport_callback() - Event handler for rport events
163  * @lport: The lport which is receiving the event
164  * @rdata: private remote port data
165  * @event: The event that occured
166  *
167  * Locking Note: The rport lock should not be held when calling
168  *		 this function.
169  */
170 static void fc_lport_rport_callback(struct fc_lport *lport,
171 				    struct fc_rport_priv *rdata,
172 				    enum fc_rport_event event)
173 {
174 	FC_LPORT_DBG(lport, "Received a %d event for port (%6x)\n", event,
175 		     rdata->ids.port_id);
176 
177 	mutex_lock(&lport->lp_mutex);
178 	switch (event) {
179 	case RPORT_EV_READY:
180 		if (lport->state == LPORT_ST_DNS) {
181 			lport->dns_rdata = rdata;
182 			fc_lport_enter_ns(lport, LPORT_ST_RNN_ID);
183 		} else {
184 			FC_LPORT_DBG(lport, "Received an READY event "
185 				     "on port (%6x) for the directory "
186 				     "server, but the lport is not "
187 				     "in the DNS state, it's in the "
188 				     "%d state", rdata->ids.port_id,
189 				     lport->state);
190 			lport->tt.rport_logoff(rdata);
191 		}
192 		break;
193 	case RPORT_EV_LOGO:
194 	case RPORT_EV_FAILED:
195 	case RPORT_EV_STOP:
196 		lport->dns_rdata = NULL;
197 		break;
198 	case RPORT_EV_NONE:
199 		break;
200 	}
201 	mutex_unlock(&lport->lp_mutex);
202 }
203 
204 /**
205  * fc_lport_state() - Return a string which represents the lport's state
206  * @lport: The lport whose state is to converted to a string
207  */
208 static const char *fc_lport_state(struct fc_lport *lport)
209 {
210 	const char *cp;
211 
212 	cp = fc_lport_state_names[lport->state];
213 	if (!cp)
214 		cp = "unknown";
215 	return cp;
216 }
217 
218 /**
219  * fc_lport_ptp_setup() - Create an rport for point-to-point mode
220  * @lport:	 The lport to attach the ptp rport to
221  * @remote_fid:	 The FID of the ptp rport
222  * @remote_wwpn: The WWPN of the ptp rport
223  * @remote_wwnn: The WWNN of the ptp rport
224  */
225 static void fc_lport_ptp_setup(struct fc_lport *lport,
226 			       u32 remote_fid, u64 remote_wwpn,
227 			       u64 remote_wwnn)
228 {
229 	mutex_lock(&lport->disc.disc_mutex);
230 	if (lport->ptp_rdata)
231 		lport->tt.rport_logoff(lport->ptp_rdata);
232 	lport->ptp_rdata = lport->tt.rport_create(lport, remote_fid);
233 	lport->ptp_rdata->ids.port_name = remote_wwpn;
234 	lport->ptp_rdata->ids.node_name = remote_wwnn;
235 	mutex_unlock(&lport->disc.disc_mutex);
236 
237 	lport->tt.rport_login(lport->ptp_rdata);
238 
239 	fc_lport_enter_ready(lport);
240 }
241 
242 /**
243  * fc_get_host_port_type() - Return the port type of the given Scsi_Host
244  * @shost: The SCSI host whose port type is to be determined
245  */
246 void fc_get_host_port_type(struct Scsi_Host *shost)
247 {
248 	/* TODO - currently just NPORT */
249 	fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
250 }
251 EXPORT_SYMBOL(fc_get_host_port_type);
252 
253 /**
254  * fc_get_host_port_state() - Return the port state of the given Scsi_Host
255  * @shost:  The SCSI host whose port state is to be determined
256  */
257 void fc_get_host_port_state(struct Scsi_Host *shost)
258 {
259 	struct fc_lport *lport = shost_priv(shost);
260 
261 	mutex_lock(&lport->lp_mutex);
262 	if (!lport->link_up)
263 		fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
264 	else
265 		switch (lport->state) {
266 		case LPORT_ST_READY:
267 			fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
268 			break;
269 		default:
270 			fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
271 		}
272 	mutex_unlock(&lport->lp_mutex);
273 }
274 EXPORT_SYMBOL(fc_get_host_port_state);
275 
276 /**
277  * fc_get_host_speed() - Return the speed of the given Scsi_Host
278  * @shost: The SCSI host whose port speed is to be determined
279  */
280 void fc_get_host_speed(struct Scsi_Host *shost)
281 {
282 	struct fc_lport *lport = shost_priv(shost);
283 
284 	fc_host_speed(shost) = lport->link_speed;
285 }
286 EXPORT_SYMBOL(fc_get_host_speed);
287 
288 /**
289  * fc_get_host_stats() - Return the Scsi_Host's statistics
290  * @shost: The SCSI host whose statistics are to be returned
291  */
292 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
293 {
294 	struct fc_host_statistics *fcoe_stats;
295 	struct fc_lport *lport = shost_priv(shost);
296 	struct timespec v0, v1;
297 	unsigned int cpu;
298 
299 	fcoe_stats = &lport->host_stats;
300 	memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
301 
302 	jiffies_to_timespec(jiffies, &v0);
303 	jiffies_to_timespec(lport->boot_time, &v1);
304 	fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec);
305 
306 	for_each_possible_cpu(cpu) {
307 		struct fcoe_dev_stats *stats;
308 
309 		stats = per_cpu_ptr(lport->dev_stats, cpu);
310 
311 		fcoe_stats->tx_frames += stats->TxFrames;
312 		fcoe_stats->tx_words += stats->TxWords;
313 		fcoe_stats->rx_frames += stats->RxFrames;
314 		fcoe_stats->rx_words += stats->RxWords;
315 		fcoe_stats->error_frames += stats->ErrorFrames;
316 		fcoe_stats->invalid_crc_count += stats->InvalidCRCCount;
317 		fcoe_stats->fcp_input_requests += stats->InputRequests;
318 		fcoe_stats->fcp_output_requests += stats->OutputRequests;
319 		fcoe_stats->fcp_control_requests += stats->ControlRequests;
320 		fcoe_stats->fcp_input_megabytes += stats->InputMegabytes;
321 		fcoe_stats->fcp_output_megabytes += stats->OutputMegabytes;
322 		fcoe_stats->link_failure_count += stats->LinkFailureCount;
323 	}
324 	fcoe_stats->lip_count = -1;
325 	fcoe_stats->nos_count = -1;
326 	fcoe_stats->loss_of_sync_count = -1;
327 	fcoe_stats->loss_of_signal_count = -1;
328 	fcoe_stats->prim_seq_protocol_err_count = -1;
329 	fcoe_stats->dumped_frames = -1;
330 	return fcoe_stats;
331 }
332 EXPORT_SYMBOL(fc_get_host_stats);
333 
334 /**
335  * fc_lport_flogi_fill() - Fill in FLOGI command for request
336  * @lport: The local port the FLOGI is for
337  * @flogi: The FLOGI command
338  * @op:	   The opcode
339  */
340 static void fc_lport_flogi_fill(struct fc_lport *lport,
341 				struct fc_els_flogi *flogi,
342 				unsigned int op)
343 {
344 	struct fc_els_csp *sp;
345 	struct fc_els_cssp *cp;
346 
347 	memset(flogi, 0, sizeof(*flogi));
348 	flogi->fl_cmd = (u8) op;
349 	put_unaligned_be64(lport->wwpn, &flogi->fl_wwpn);
350 	put_unaligned_be64(lport->wwnn, &flogi->fl_wwnn);
351 	sp = &flogi->fl_csp;
352 	sp->sp_hi_ver = 0x20;
353 	sp->sp_lo_ver = 0x20;
354 	sp->sp_bb_cred = htons(10);	/* this gets set by gateway */
355 	sp->sp_bb_data = htons((u16) lport->mfs);
356 	cp = &flogi->fl_cssp[3 - 1];	/* class 3 parameters */
357 	cp->cp_class = htons(FC_CPC_VALID | FC_CPC_SEQ);
358 	if (op != ELS_FLOGI) {
359 		sp->sp_features = htons(FC_SP_FT_CIRO);
360 		sp->sp_tot_seq = htons(255);	/* seq. we accept */
361 		sp->sp_rel_off = htons(0x1f);
362 		sp->sp_e_d_tov = htonl(lport->e_d_tov);
363 
364 		cp->cp_rdfs = htons((u16) lport->mfs);
365 		cp->cp_con_seq = htons(255);
366 		cp->cp_open_seq = 1;
367 	}
368 }
369 
370 /**
371  * fc_lport_add_fc4_type() - Add a supported FC-4 type to a local port
372  * @lport: The local port to add a new FC-4 type to
373  * @type:  The new FC-4 type
374  */
375 static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
376 {
377 	__be32 *mp;
378 
379 	mp = &lport->fcts.ff_type_map[type / FC_NS_BPW];
380 	*mp = htonl(ntohl(*mp) | 1UL << (type % FC_NS_BPW));
381 }
382 
383 /**
384  * fc_lport_recv_rlir_req() - Handle received Registered Link Incident Report.
385  * @sp:	   The sequence in the RLIR exchange
386  * @fp:	   The RLIR request frame
387  * @lport: Fibre Channel local port recieving the RLIR
388  *
389  * Locking Note: The lport lock is expected to be held before calling
390  * this function.
391  */
392 static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
393 				   struct fc_lport *lport)
394 {
395 	FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
396 		     fc_lport_state(lport));
397 
398 	lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
399 	fc_frame_free(fp);
400 }
401 
402 /**
403  * fc_lport_recv_echo_req() - Handle received ECHO request
404  * @sp:	   The sequence in the ECHO exchange
405  * @fp:	   ECHO request frame
406  * @lport: The local port recieving the ECHO
407  *
408  * Locking Note: The lport lock is expected to be held before calling
409  * this function.
410  */
411 static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
412 				   struct fc_lport *lport)
413 {
414 	struct fc_frame *fp;
415 	struct fc_exch *ep = fc_seq_exch(sp);
416 	unsigned int len;
417 	void *pp;
418 	void *dp;
419 	u32 f_ctl;
420 
421 	FC_LPORT_DBG(lport, "Received ECHO request while in state %s\n",
422 		     fc_lport_state(lport));
423 
424 	len = fr_len(in_fp) - sizeof(struct fc_frame_header);
425 	pp = fc_frame_payload_get(in_fp, len);
426 
427 	if (len < sizeof(__be32))
428 		len = sizeof(__be32);
429 
430 	fp = fc_frame_alloc(lport, len);
431 	if (fp) {
432 		dp = fc_frame_payload_get(fp, len);
433 		memcpy(dp, pp, len);
434 		*((__be32 *)dp) = htonl(ELS_LS_ACC << 24);
435 		sp = lport->tt.seq_start_next(sp);
436 		f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
437 		fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
438 			       FC_TYPE_ELS, f_ctl, 0);
439 		lport->tt.seq_send(lport, sp, fp);
440 	}
441 	fc_frame_free(in_fp);
442 }
443 
444 /**
445  * fc_lport_recv_rnid_req() - Handle received Request Node ID data request
446  * @sp:	   The sequence in the RNID exchange
447  * @fp:	   The RNID request frame
448  * @lport: The local port recieving the RNID
449  *
450  * Locking Note: The lport lock is expected to be held before calling
451  * this function.
452  */
453 static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
454 				   struct fc_lport *lport)
455 {
456 	struct fc_frame *fp;
457 	struct fc_exch *ep = fc_seq_exch(sp);
458 	struct fc_els_rnid *req;
459 	struct {
460 		struct fc_els_rnid_resp rnid;
461 		struct fc_els_rnid_cid cid;
462 		struct fc_els_rnid_gen gen;
463 	} *rp;
464 	struct fc_seq_els_data rjt_data;
465 	u8 fmt;
466 	size_t len;
467 	u32 f_ctl;
468 
469 	FC_LPORT_DBG(lport, "Received RNID request while in state %s\n",
470 		     fc_lport_state(lport));
471 
472 	req = fc_frame_payload_get(in_fp, sizeof(*req));
473 	if (!req) {
474 		rjt_data.fp = NULL;
475 		rjt_data.reason = ELS_RJT_LOGIC;
476 		rjt_data.explan = ELS_EXPL_NONE;
477 		lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
478 	} else {
479 		fmt = req->rnid_fmt;
480 		len = sizeof(*rp);
481 		if (fmt != ELS_RNIDF_GEN ||
482 		    ntohl(lport->rnid_gen.rnid_atype) == 0) {
483 			fmt = ELS_RNIDF_NONE;	/* nothing to provide */
484 			len -= sizeof(rp->gen);
485 		}
486 		fp = fc_frame_alloc(lport, len);
487 		if (fp) {
488 			rp = fc_frame_payload_get(fp, len);
489 			memset(rp, 0, len);
490 			rp->rnid.rnid_cmd = ELS_LS_ACC;
491 			rp->rnid.rnid_fmt = fmt;
492 			rp->rnid.rnid_cid_len = sizeof(rp->cid);
493 			rp->cid.rnid_wwpn = htonll(lport->wwpn);
494 			rp->cid.rnid_wwnn = htonll(lport->wwnn);
495 			if (fmt == ELS_RNIDF_GEN) {
496 				rp->rnid.rnid_sid_len = sizeof(rp->gen);
497 				memcpy(&rp->gen, &lport->rnid_gen,
498 				       sizeof(rp->gen));
499 			}
500 			sp = lport->tt.seq_start_next(sp);
501 			f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ;
502 			f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT;
503 			fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
504 				       FC_TYPE_ELS, f_ctl, 0);
505 			lport->tt.seq_send(lport, sp, fp);
506 		}
507 	}
508 	fc_frame_free(in_fp);
509 }
510 
511 /**
512  * fc_lport_recv_logo_req() - Handle received fabric LOGO request
513  * @sp:	   The sequence in the LOGO exchange
514  * @fp:	   The LOGO request frame
515  * @lport: The local port recieving the LOGO
516  *
517  * Locking Note: The lport lock is exected to be held before calling
518  * this function.
519  */
520 static void fc_lport_recv_logo_req(struct fc_seq *sp, struct fc_frame *fp,
521 				   struct fc_lport *lport)
522 {
523 	lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
524 	fc_lport_enter_reset(lport);
525 	fc_frame_free(fp);
526 }
527 
528 /**
529  * fc_fabric_login() - Start the lport state machine
530  * @lport: The local port that should log into the fabric
531  *
532  * Locking Note: This function should not be called
533  *		 with the lport lock held.
534  */
535 int fc_fabric_login(struct fc_lport *lport)
536 {
537 	int rc = -1;
538 
539 	mutex_lock(&lport->lp_mutex);
540 	if (lport->state == LPORT_ST_DISABLED ||
541 	    lport->state == LPORT_ST_LOGO) {
542 		fc_lport_state_enter(lport, LPORT_ST_RESET);
543 		fc_lport_enter_reset(lport);
544 		rc = 0;
545 	}
546 	mutex_unlock(&lport->lp_mutex);
547 
548 	return rc;
549 }
550 EXPORT_SYMBOL(fc_fabric_login);
551 
552 /**
553  * __fc_linkup() - Handler for transport linkup events
554  * @lport: The lport whose link is up
555  *
556  * Locking: must be called with the lp_mutex held
557  */
558 void __fc_linkup(struct fc_lport *lport)
559 {
560 	if (!lport->link_up) {
561 		lport->link_up = 1;
562 
563 		if (lport->state == LPORT_ST_RESET)
564 			fc_lport_enter_flogi(lport);
565 	}
566 }
567 
568 /**
569  * fc_linkup() - Handler for transport linkup events
570  * @lport: The local port whose link is up
571  */
572 void fc_linkup(struct fc_lport *lport)
573 {
574 	printk(KERN_INFO "host%d: libfc: Link up on port (%6x)\n",
575 	       lport->host->host_no, fc_host_port_id(lport->host));
576 
577 	mutex_lock(&lport->lp_mutex);
578 	__fc_linkup(lport);
579 	mutex_unlock(&lport->lp_mutex);
580 }
581 EXPORT_SYMBOL(fc_linkup);
582 
583 /**
584  * __fc_linkdown() - Handler for transport linkdown events
585  * @lport: The lport whose link is down
586  *
587  * Locking: must be called with the lp_mutex held
588  */
589 void __fc_linkdown(struct fc_lport *lport)
590 {
591 	if (lport->link_up) {
592 		lport->link_up = 0;
593 		fc_lport_enter_reset(lport);
594 		lport->tt.fcp_cleanup(lport);
595 	}
596 }
597 
598 /**
599  * fc_linkdown() - Handler for transport linkdown events
600  * @lport: The local port whose link is down
601  */
602 void fc_linkdown(struct fc_lport *lport)
603 {
604 	printk(KERN_INFO "host%d: libfc: Link down on port (%6x)\n",
605 	       lport->host->host_no, fc_host_port_id(lport->host));
606 
607 	mutex_lock(&lport->lp_mutex);
608 	__fc_linkdown(lport);
609 	mutex_unlock(&lport->lp_mutex);
610 }
611 EXPORT_SYMBOL(fc_linkdown);
612 
613 /**
614  * fc_fabric_logoff() - Logout of the fabric
615  * @lport: The local port to logoff the fabric
616  *
617  * Return value:
618  *	0 for success, -1 for failure
619  */
620 int fc_fabric_logoff(struct fc_lport *lport)
621 {
622 	lport->tt.disc_stop_final(lport);
623 	mutex_lock(&lport->lp_mutex);
624 	if (lport->dns_rdata)
625 		lport->tt.rport_logoff(lport->dns_rdata);
626 	mutex_unlock(&lport->lp_mutex);
627 	lport->tt.rport_flush_queue();
628 	mutex_lock(&lport->lp_mutex);
629 	fc_lport_enter_logo(lport);
630 	mutex_unlock(&lport->lp_mutex);
631 	cancel_delayed_work_sync(&lport->retry_work);
632 	return 0;
633 }
634 EXPORT_SYMBOL(fc_fabric_logoff);
635 
636 /**
637  * fc_lport_destroy() - Unregister a fc_lport
638  * @lport: The local port to unregister
639  *
640  * Note:
641  * exit routine for fc_lport instance
642  * clean-up all the allocated memory
643  * and free up other system resources.
644  *
645  */
646 int fc_lport_destroy(struct fc_lport *lport)
647 {
648 	mutex_lock(&lport->lp_mutex);
649 	lport->state = LPORT_ST_DISABLED;
650 	lport->link_up = 0;
651 	lport->tt.frame_send = fc_frame_drop;
652 	mutex_unlock(&lport->lp_mutex);
653 
654 	lport->tt.fcp_abort_io(lport);
655 	lport->tt.disc_stop_final(lport);
656 	lport->tt.exch_mgr_reset(lport, 0, 0);
657 	return 0;
658 }
659 EXPORT_SYMBOL(fc_lport_destroy);
660 
661 /**
662  * fc_set_mfs() - Set the maximum frame size for a local port
663  * @lport: The local port to set the MFS for
664  * @mfs:   The new MFS
665  */
666 int fc_set_mfs(struct fc_lport *lport, u32 mfs)
667 {
668 	unsigned int old_mfs;
669 	int rc = -EINVAL;
670 
671 	mutex_lock(&lport->lp_mutex);
672 
673 	old_mfs = lport->mfs;
674 
675 	if (mfs >= FC_MIN_MAX_FRAME) {
676 		mfs &= ~3;
677 		if (mfs > FC_MAX_FRAME)
678 			mfs = FC_MAX_FRAME;
679 		mfs -= sizeof(struct fc_frame_header);
680 		lport->mfs = mfs;
681 		rc = 0;
682 	}
683 
684 	if (!rc && mfs < old_mfs)
685 		fc_lport_enter_reset(lport);
686 
687 	mutex_unlock(&lport->lp_mutex);
688 
689 	return rc;
690 }
691 EXPORT_SYMBOL(fc_set_mfs);
692 
693 /**
694  * fc_lport_disc_callback() - Callback for discovery events
695  * @lport: The local port receiving the event
696  * @event: The discovery event
697  */
698 void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
699 {
700 	switch (event) {
701 	case DISC_EV_SUCCESS:
702 		FC_LPORT_DBG(lport, "Discovery succeeded\n");
703 		break;
704 	case DISC_EV_FAILED:
705 		printk(KERN_ERR "host%d: libfc: "
706 		       "Discovery failed for port (%6x)\n",
707 		       lport->host->host_no, fc_host_port_id(lport->host));
708 		mutex_lock(&lport->lp_mutex);
709 		fc_lport_enter_reset(lport);
710 		mutex_unlock(&lport->lp_mutex);
711 		break;
712 	case DISC_EV_NONE:
713 		WARN_ON(1);
714 		break;
715 	}
716 }
717 
718 /**
719  * fc_rport_enter_ready() - Enter the ready state and start discovery
720  * @lport: The local port that is ready
721  *
722  * Locking Note: The lport lock is expected to be held before calling
723  * this routine.
724  */
725 static void fc_lport_enter_ready(struct fc_lport *lport)
726 {
727 	FC_LPORT_DBG(lport, "Entered READY from state %s\n",
728 		     fc_lport_state(lport));
729 
730 	fc_lport_state_enter(lport, LPORT_ST_READY);
731 	if (lport->vport)
732 		fc_vport_set_state(lport->vport, FC_VPORT_ACTIVE);
733 	fc_vports_linkchange(lport);
734 
735 	if (!lport->ptp_rdata)
736 		lport->tt.disc_start(fc_lport_disc_callback, lport);
737 }
738 
739 /**
740  * fc_lport_set_port_id() - set the local port Port ID
741  * @lport: The local port which will have its Port ID set.
742  * @port_id: The new port ID.
743  * @fp: The frame containing the incoming request, or NULL.
744  *
745  * Locking Note: The lport lock is expected to be held before calling
746  * this function.
747  */
748 static void fc_lport_set_port_id(struct fc_lport *lport, u32 port_id,
749 				 struct fc_frame *fp)
750 {
751 	if (port_id)
752 		printk(KERN_INFO "host%d: Assigned Port ID %6x\n",
753 		       lport->host->host_no, port_id);
754 
755 	fc_host_port_id(lport->host) = port_id;
756 	if (lport->tt.lport_set_port_id)
757 		lport->tt.lport_set_port_id(lport, port_id, fp);
758 }
759 
760 /**
761  * fc_lport_recv_flogi_req() - Receive a FLOGI request
762  * @sp_in: The sequence the FLOGI is on
763  * @rx_fp: The FLOGI frame
764  * @lport: The local port that recieved the request
765  *
766  * A received FLOGI request indicates a point-to-point connection.
767  * Accept it with the common service parameters indicating our N port.
768  * Set up to do a PLOGI if we have the higher-number WWPN.
769  *
770  * Locking Note: The lport lock is expected to be held before calling
771  * this function.
772  */
773 static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
774 				    struct fc_frame *rx_fp,
775 				    struct fc_lport *lport)
776 {
777 	struct fc_frame *fp;
778 	struct fc_frame_header *fh;
779 	struct fc_seq *sp;
780 	struct fc_exch *ep;
781 	struct fc_els_flogi *flp;
782 	struct fc_els_flogi *new_flp;
783 	u64 remote_wwpn;
784 	u32 remote_fid;
785 	u32 local_fid;
786 	u32 f_ctl;
787 
788 	FC_LPORT_DBG(lport, "Received FLOGI request while in state %s\n",
789 		     fc_lport_state(lport));
790 
791 	fh = fc_frame_header_get(rx_fp);
792 	remote_fid = ntoh24(fh->fh_s_id);
793 	flp = fc_frame_payload_get(rx_fp, sizeof(*flp));
794 	if (!flp)
795 		goto out;
796 	remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
797 	if (remote_wwpn == lport->wwpn) {
798 		printk(KERN_WARNING "host%d: libfc: Received FLOGI from port "
799 		       "with same WWPN %llx\n",
800 		       lport->host->host_no, remote_wwpn);
801 		goto out;
802 	}
803 	FC_LPORT_DBG(lport, "FLOGI from port WWPN %llx\n", remote_wwpn);
804 
805 	/*
806 	 * XXX what is the right thing to do for FIDs?
807 	 * The originator might expect our S_ID to be 0xfffffe.
808 	 * But if so, both of us could end up with the same FID.
809 	 */
810 	local_fid = FC_LOCAL_PTP_FID_LO;
811 	if (remote_wwpn < lport->wwpn) {
812 		local_fid = FC_LOCAL_PTP_FID_HI;
813 		if (!remote_fid || remote_fid == local_fid)
814 			remote_fid = FC_LOCAL_PTP_FID_LO;
815 	} else if (!remote_fid) {
816 		remote_fid = FC_LOCAL_PTP_FID_HI;
817 	}
818 
819 	fc_lport_set_port_id(lport, local_fid, rx_fp);
820 
821 	fp = fc_frame_alloc(lport, sizeof(*flp));
822 	if (fp) {
823 		sp = lport->tt.seq_start_next(fr_seq(rx_fp));
824 		new_flp = fc_frame_payload_get(fp, sizeof(*flp));
825 		fc_lport_flogi_fill(lport, new_flp, ELS_FLOGI);
826 		new_flp->fl_cmd = (u8) ELS_LS_ACC;
827 
828 		/*
829 		 * Send the response.  If this fails, the originator should
830 		 * repeat the sequence.
831 		 */
832 		f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
833 		ep = fc_seq_exch(sp);
834 		fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
835 			       FC_TYPE_ELS, f_ctl, 0);
836 		lport->tt.seq_send(lport, sp, fp);
837 
838 	} else {
839 		fc_lport_error(lport, fp);
840 	}
841 	fc_lport_ptp_setup(lport, remote_fid, remote_wwpn,
842 			   get_unaligned_be64(&flp->fl_wwnn));
843 
844 out:
845 	sp = fr_seq(rx_fp);
846 	fc_frame_free(rx_fp);
847 }
848 
849 /**
850  * fc_lport_recv_req() - The generic lport request handler
851  * @lport: The local port that received the request
852  * @sp:	   The sequence the request is on
853  * @fp:	   The request frame
854  *
855  * This function will see if the lport handles the request or
856  * if an rport should handle the request.
857  *
858  * Locking Note: This function should not be called with the lport
859  *		 lock held becuase it will grab the lock.
860  */
861 static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,
862 			      struct fc_frame *fp)
863 {
864 	struct fc_frame_header *fh = fc_frame_header_get(fp);
865 	void (*recv) (struct fc_seq *, struct fc_frame *, struct fc_lport *);
866 
867 	mutex_lock(&lport->lp_mutex);
868 
869 	/*
870 	 * Handle special ELS cases like FLOGI, LOGO, and
871 	 * RSCN here.  These don't require a session.
872 	 * Even if we had a session, it might not be ready.
873 	 */
874 	if (!lport->link_up)
875 		fc_frame_free(fp);
876 	else if (fh->fh_type == FC_TYPE_ELS &&
877 		 fh->fh_r_ctl == FC_RCTL_ELS_REQ) {
878 		/*
879 		 * Check opcode.
880 		 */
881 		recv = lport->tt.rport_recv_req;
882 		switch (fc_frame_payload_op(fp)) {
883 		case ELS_FLOGI:
884 			recv = fc_lport_recv_flogi_req;
885 			break;
886 		case ELS_LOGO:
887 			fh = fc_frame_header_get(fp);
888 			if (ntoh24(fh->fh_s_id) == FC_FID_FLOGI)
889 				recv = fc_lport_recv_logo_req;
890 			break;
891 		case ELS_RSCN:
892 			recv = lport->tt.disc_recv_req;
893 			break;
894 		case ELS_ECHO:
895 			recv = fc_lport_recv_echo_req;
896 			break;
897 		case ELS_RLIR:
898 			recv = fc_lport_recv_rlir_req;
899 			break;
900 		case ELS_RNID:
901 			recv = fc_lport_recv_rnid_req;
902 			break;
903 		}
904 
905 		recv(sp, fp, lport);
906 	} else {
907 		FC_LPORT_DBG(lport, "dropping invalid frame (eof %x)\n",
908 			     fr_eof(fp));
909 		fc_frame_free(fp);
910 	}
911 	mutex_unlock(&lport->lp_mutex);
912 
913 	/*
914 	 *  The common exch_done for all request may not be good
915 	 *  if any request requires longer hold on exhange. XXX
916 	 */
917 	lport->tt.exch_done(sp);
918 }
919 
920 /**
921  * fc_lport_reset() - Reset a local port
922  * @lport: The local port which should be reset
923  *
924  * Locking Note: This functions should not be called with the
925  *		 lport lock held.
926  */
927 int fc_lport_reset(struct fc_lport *lport)
928 {
929 	cancel_delayed_work_sync(&lport->retry_work);
930 	mutex_lock(&lport->lp_mutex);
931 	fc_lport_enter_reset(lport);
932 	mutex_unlock(&lport->lp_mutex);
933 	return 0;
934 }
935 EXPORT_SYMBOL(fc_lport_reset);
936 
937 /**
938  * fc_lport_reset_locked() - Reset the local port w/ the lport lock held
939  * @lport: The local port to be reset
940  *
941  * Locking Note: The lport lock is expected to be held before calling
942  * this routine.
943  */
944 static void fc_lport_reset_locked(struct fc_lport *lport)
945 {
946 	if (lport->dns_rdata)
947 		lport->tt.rport_logoff(lport->dns_rdata);
948 
949 	lport->ptp_rdata = NULL;
950 
951 	lport->tt.disc_stop(lport);
952 
953 	lport->tt.exch_mgr_reset(lport, 0, 0);
954 	fc_host_fabric_name(lport->host) = 0;
955 
956 	if (fc_host_port_id(lport->host))
957 		fc_lport_set_port_id(lport, 0, NULL);
958 }
959 
960 /**
961  * fc_lport_enter_reset() - Reset the local port
962  * @lport: The local port to be reset
963  *
964  * Locking Note: The lport lock is expected to be held before calling
965  * this routine.
966  */
967 static void fc_lport_enter_reset(struct fc_lport *lport)
968 {
969 	FC_LPORT_DBG(lport, "Entered RESET state from %s state\n",
970 		     fc_lport_state(lport));
971 
972 	if (lport->state == LPORT_ST_DISABLED || lport->state == LPORT_ST_LOGO)
973 		return;
974 
975 	if (lport->vport) {
976 		if (lport->link_up)
977 			fc_vport_set_state(lport->vport, FC_VPORT_INITIALIZING);
978 		else
979 			fc_vport_set_state(lport->vport, FC_VPORT_LINKDOWN);
980 	}
981 	fc_lport_state_enter(lport, LPORT_ST_RESET);
982 	fc_vports_linkchange(lport);
983 	fc_lport_reset_locked(lport);
984 	if (lport->link_up)
985 		fc_lport_enter_flogi(lport);
986 }
987 
988 /**
989  * fc_lport_enter_disabled() - Disable the local port
990  * @lport: The local port to be reset
991  *
992  * Locking Note: The lport lock is expected to be held before calling
993  * this routine.
994  */
995 static void fc_lport_enter_disabled(struct fc_lport *lport)
996 {
997 	FC_LPORT_DBG(lport, "Entered disabled state from %s state\n",
998 		     fc_lport_state(lport));
999 
1000 	fc_lport_state_enter(lport, LPORT_ST_DISABLED);
1001 	fc_vports_linkchange(lport);
1002 	fc_lport_reset_locked(lport);
1003 }
1004 
1005 /**
1006  * fc_lport_error() - Handler for any errors
1007  * @lport: The local port that the error was on
1008  * @fp:	   The error code encoded in a frame pointer
1009  *
1010  * If the error was caused by a resource allocation failure
1011  * then wait for half a second and retry, otherwise retry
1012  * after the e_d_tov time.
1013  */
1014 static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
1015 {
1016 	unsigned long delay = 0;
1017 	FC_LPORT_DBG(lport, "Error %ld in state %s, retries %d\n",
1018 		     PTR_ERR(fp), fc_lport_state(lport),
1019 		     lport->retry_count);
1020 
1021 	if (!fp || PTR_ERR(fp) == -FC_EX_TIMEOUT) {
1022 		/*
1023 		 * Memory allocation failure, or the exchange timed out.
1024 		 *  Retry after delay
1025 		 */
1026 		if (lport->retry_count < lport->max_retry_count) {
1027 			lport->retry_count++;
1028 			if (!fp)
1029 				delay = msecs_to_jiffies(500);
1030 			else
1031 				delay =	msecs_to_jiffies(lport->e_d_tov);
1032 
1033 			schedule_delayed_work(&lport->retry_work, delay);
1034 		} else {
1035 			switch (lport->state) {
1036 			case LPORT_ST_DISABLED:
1037 			case LPORT_ST_READY:
1038 			case LPORT_ST_RESET:
1039 			case LPORT_ST_RNN_ID:
1040 			case LPORT_ST_RSNN_NN:
1041 			case LPORT_ST_RSPN_ID:
1042 			case LPORT_ST_RFT_ID:
1043 			case LPORT_ST_RFF_ID:
1044 			case LPORT_ST_SCR:
1045 			case LPORT_ST_DNS:
1046 			case LPORT_ST_FLOGI:
1047 			case LPORT_ST_LOGO:
1048 				fc_lport_enter_reset(lport);
1049 				break;
1050 			}
1051 		}
1052 	}
1053 }
1054 
1055 /**
1056  * fc_lport_ns_resp() - Handle response to a name server
1057  *			registration exchange
1058  * @sp:	    current sequence in exchange
1059  * @fp:	    response frame
1060  * @lp_arg: Fibre Channel host port instance
1061  *
1062  * Locking Note: This function will be called without the lport lock
1063  * held, but it will lock, call an _enter_* function or fc_lport_error()
1064  * and then unlock the lport.
1065  */
1066 static void fc_lport_ns_resp(struct fc_seq *sp, struct fc_frame *fp,
1067 			     void *lp_arg)
1068 {
1069 	struct fc_lport *lport = lp_arg;
1070 	struct fc_frame_header *fh;
1071 	struct fc_ct_hdr *ct;
1072 
1073 	FC_LPORT_DBG(lport, "Received a ns %s\n", fc_els_resp_type(fp));
1074 
1075 	if (fp == ERR_PTR(-FC_EX_CLOSED))
1076 		return;
1077 
1078 	mutex_lock(&lport->lp_mutex);
1079 
1080 	if (lport->state < LPORT_ST_RNN_ID || lport->state > LPORT_ST_RFF_ID) {
1081 		FC_LPORT_DBG(lport, "Received a name server response, "
1082 			     "but in state %s\n", fc_lport_state(lport));
1083 		if (IS_ERR(fp))
1084 			goto err;
1085 		goto out;
1086 	}
1087 
1088 	if (IS_ERR(fp)) {
1089 		fc_lport_error(lport, fp);
1090 		goto err;
1091 	}
1092 
1093 	fh = fc_frame_header_get(fp);
1094 	ct = fc_frame_payload_get(fp, sizeof(*ct));
1095 
1096 	if (fh && ct && fh->fh_type == FC_TYPE_CT &&
1097 	    ct->ct_fs_type == FC_FST_DIR &&
1098 	    ct->ct_fs_subtype == FC_NS_SUBTYPE &&
1099 	    ntohs(ct->ct_cmd) == FC_FS_ACC)
1100 		switch (lport->state) {
1101 		case LPORT_ST_RNN_ID:
1102 			fc_lport_enter_ns(lport, LPORT_ST_RSNN_NN);
1103 			break;
1104 		case LPORT_ST_RSNN_NN:
1105 			fc_lport_enter_ns(lport, LPORT_ST_RSPN_ID);
1106 			break;
1107 		case LPORT_ST_RSPN_ID:
1108 			fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1109 			break;
1110 		case LPORT_ST_RFT_ID:
1111 			fc_lport_enter_ns(lport, LPORT_ST_RFF_ID);
1112 			break;
1113 		case LPORT_ST_RFF_ID:
1114 			fc_lport_enter_scr(lport);
1115 			break;
1116 		default:
1117 			/* should have already been caught by state checks */
1118 			break;
1119 		}
1120 	else
1121 		fc_lport_error(lport, fp);
1122 out:
1123 	fc_frame_free(fp);
1124 err:
1125 	mutex_unlock(&lport->lp_mutex);
1126 }
1127 
1128 /**
1129  * fc_lport_scr_resp() - Handle response to State Change Register (SCR) request
1130  * @sp:	    current sequence in SCR exchange
1131  * @fp:	    response frame
1132  * @lp_arg: Fibre Channel lport port instance that sent the registration request
1133  *
1134  * Locking Note: This function will be called without the lport lock
1135  * held, but it will lock, call an _enter_* function or fc_lport_error
1136  * and then unlock the lport.
1137  */
1138 static void fc_lport_scr_resp(struct fc_seq *sp, struct fc_frame *fp,
1139 			      void *lp_arg)
1140 {
1141 	struct fc_lport *lport = lp_arg;
1142 	u8 op;
1143 
1144 	FC_LPORT_DBG(lport, "Received a SCR %s\n", fc_els_resp_type(fp));
1145 
1146 	if (fp == ERR_PTR(-FC_EX_CLOSED))
1147 		return;
1148 
1149 	mutex_lock(&lport->lp_mutex);
1150 
1151 	if (lport->state != LPORT_ST_SCR) {
1152 		FC_LPORT_DBG(lport, "Received a SCR response, but in state "
1153 			     "%s\n", fc_lport_state(lport));
1154 		if (IS_ERR(fp))
1155 			goto err;
1156 		goto out;
1157 	}
1158 
1159 	if (IS_ERR(fp)) {
1160 		fc_lport_error(lport, fp);
1161 		goto err;
1162 	}
1163 
1164 	op = fc_frame_payload_op(fp);
1165 	if (op == ELS_LS_ACC)
1166 		fc_lport_enter_ready(lport);
1167 	else
1168 		fc_lport_error(lport, fp);
1169 
1170 out:
1171 	fc_frame_free(fp);
1172 err:
1173 	mutex_unlock(&lport->lp_mutex);
1174 }
1175 
1176 /**
1177  * fc_lport_enter_scr() - Send a SCR (State Change Register) request
1178  * @lport: The local port to register for state changes
1179  *
1180  * Locking Note: The lport lock is expected to be held before calling
1181  * this routine.
1182  */
1183 static void fc_lport_enter_scr(struct fc_lport *lport)
1184 {
1185 	struct fc_frame *fp;
1186 
1187 	FC_LPORT_DBG(lport, "Entered SCR state from %s state\n",
1188 		     fc_lport_state(lport));
1189 
1190 	fc_lport_state_enter(lport, LPORT_ST_SCR);
1191 
1192 	fp = fc_frame_alloc(lport, sizeof(struct fc_els_scr));
1193 	if (!fp) {
1194 		fc_lport_error(lport, fp);
1195 		return;
1196 	}
1197 
1198 	if (!lport->tt.elsct_send(lport, FC_FID_FCTRL, fp, ELS_SCR,
1199 				  fc_lport_scr_resp, lport,
1200 				  2 * lport->r_a_tov))
1201 		fc_lport_error(lport, NULL);
1202 }
1203 
1204 /**
1205  * fc_lport_enter_ns() - register some object with the name server
1206  * @lport: Fibre Channel local port to register
1207  *
1208  * Locking Note: The lport lock is expected to be held before calling
1209  * this routine.
1210  */
1211 static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state)
1212 {
1213 	struct fc_frame *fp;
1214 	enum fc_ns_req cmd;
1215 	int size = sizeof(struct fc_ct_hdr);
1216 	size_t len;
1217 
1218 	FC_LPORT_DBG(lport, "Entered %s state from %s state\n",
1219 		     fc_lport_state_names[state],
1220 		     fc_lport_state(lport));
1221 
1222 	fc_lport_state_enter(lport, state);
1223 
1224 	switch (state) {
1225 	case LPORT_ST_RNN_ID:
1226 		cmd = FC_NS_RNN_ID;
1227 		size += sizeof(struct fc_ns_rn_id);
1228 		break;
1229 	case LPORT_ST_RSNN_NN:
1230 		len = strnlen(fc_host_symbolic_name(lport->host), 255);
1231 		/* if there is no symbolic name, skip to RFT_ID */
1232 		if (!len)
1233 			return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1234 		cmd = FC_NS_RSNN_NN;
1235 		size += sizeof(struct fc_ns_rsnn) + len;
1236 		break;
1237 	case LPORT_ST_RSPN_ID:
1238 		len = strnlen(fc_host_symbolic_name(lport->host), 255);
1239 		/* if there is no symbolic name, skip to RFT_ID */
1240 		if (!len)
1241 			return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1242 		cmd = FC_NS_RSPN_ID;
1243 		size += sizeof(struct fc_ns_rspn) + len;
1244 		break;
1245 	case LPORT_ST_RFT_ID:
1246 		cmd = FC_NS_RFT_ID;
1247 		size += sizeof(struct fc_ns_rft);
1248 		break;
1249 	case LPORT_ST_RFF_ID:
1250 		cmd = FC_NS_RFF_ID;
1251 		size += sizeof(struct fc_ns_rff_id);
1252 		break;
1253 	default:
1254 		fc_lport_error(lport, NULL);
1255 		return;
1256 	}
1257 
1258 	fp = fc_frame_alloc(lport, size);
1259 	if (!fp) {
1260 		fc_lport_error(lport, fp);
1261 		return;
1262 	}
1263 
1264 	if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, cmd,
1265 				  fc_lport_ns_resp,
1266 				  lport, 3 * lport->r_a_tov))
1267 		fc_lport_error(lport, fp);
1268 }
1269 
1270 static struct fc_rport_operations fc_lport_rport_ops = {
1271 	.event_callback = fc_lport_rport_callback,
1272 };
1273 
1274 /**
1275  * fc_rport_enter_dns() - Create a fc_rport for the name server
1276  * @lport: The local port requesting a remote port for the name server
1277  *
1278  * Locking Note: The lport lock is expected to be held before calling
1279  * this routine.
1280  */
1281 static void fc_lport_enter_dns(struct fc_lport *lport)
1282 {
1283 	struct fc_rport_priv *rdata;
1284 
1285 	FC_LPORT_DBG(lport, "Entered DNS state from %s state\n",
1286 		     fc_lport_state(lport));
1287 
1288 	fc_lport_state_enter(lport, LPORT_ST_DNS);
1289 
1290 	mutex_lock(&lport->disc.disc_mutex);
1291 	rdata = lport->tt.rport_create(lport, FC_FID_DIR_SERV);
1292 	mutex_unlock(&lport->disc.disc_mutex);
1293 	if (!rdata)
1294 		goto err;
1295 
1296 	rdata->ops = &fc_lport_rport_ops;
1297 	lport->tt.rport_login(rdata);
1298 	return;
1299 
1300 err:
1301 	fc_lport_error(lport, NULL);
1302 }
1303 
1304 /**
1305  * fc_lport_timeout() - Handler for the retry_work timer
1306  * @work: The work struct of the local port
1307  */
1308 static void fc_lport_timeout(struct work_struct *work)
1309 {
1310 	struct fc_lport *lport =
1311 		container_of(work, struct fc_lport,
1312 			     retry_work.work);
1313 
1314 	mutex_lock(&lport->lp_mutex);
1315 
1316 	switch (lport->state) {
1317 	case LPORT_ST_DISABLED:
1318 		WARN_ON(1);
1319 		break;
1320 	case LPORT_ST_READY:
1321 		WARN_ON(1);
1322 		break;
1323 	case LPORT_ST_RESET:
1324 		break;
1325 	case LPORT_ST_FLOGI:
1326 		fc_lport_enter_flogi(lport);
1327 		break;
1328 	case LPORT_ST_DNS:
1329 		fc_lport_enter_dns(lport);
1330 		break;
1331 	case LPORT_ST_RNN_ID:
1332 	case LPORT_ST_RSNN_NN:
1333 	case LPORT_ST_RSPN_ID:
1334 	case LPORT_ST_RFT_ID:
1335 	case LPORT_ST_RFF_ID:
1336 		fc_lport_enter_ns(lport, lport->state);
1337 		break;
1338 	case LPORT_ST_SCR:
1339 		fc_lport_enter_scr(lport);
1340 		break;
1341 	case LPORT_ST_LOGO:
1342 		fc_lport_enter_logo(lport);
1343 		break;
1344 	}
1345 
1346 	mutex_unlock(&lport->lp_mutex);
1347 }
1348 
1349 /**
1350  * fc_lport_logo_resp() - Handle response to LOGO request
1351  * @sp:	    The sequence that the LOGO was on
1352  * @fp:	    The LOGO frame
1353  * @lp_arg: The lport port that received the LOGO request
1354  *
1355  * Locking Note: This function will be called without the lport lock
1356  * held, but it will lock, call an _enter_* function or fc_lport_error()
1357  * and then unlock the lport.
1358  */
1359 void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
1360 			void *lp_arg)
1361 {
1362 	struct fc_lport *lport = lp_arg;
1363 	u8 op;
1364 
1365 	FC_LPORT_DBG(lport, "Received a LOGO %s\n", fc_els_resp_type(fp));
1366 
1367 	if (fp == ERR_PTR(-FC_EX_CLOSED))
1368 		return;
1369 
1370 	mutex_lock(&lport->lp_mutex);
1371 
1372 	if (lport->state != LPORT_ST_LOGO) {
1373 		FC_LPORT_DBG(lport, "Received a LOGO response, but in state "
1374 			     "%s\n", fc_lport_state(lport));
1375 		if (IS_ERR(fp))
1376 			goto err;
1377 		goto out;
1378 	}
1379 
1380 	if (IS_ERR(fp)) {
1381 		fc_lport_error(lport, fp);
1382 		goto err;
1383 	}
1384 
1385 	op = fc_frame_payload_op(fp);
1386 	if (op == ELS_LS_ACC)
1387 		fc_lport_enter_disabled(lport);
1388 	else
1389 		fc_lport_error(lport, fp);
1390 
1391 out:
1392 	fc_frame_free(fp);
1393 err:
1394 	mutex_unlock(&lport->lp_mutex);
1395 }
1396 EXPORT_SYMBOL(fc_lport_logo_resp);
1397 
1398 /**
1399  * fc_rport_enter_logo() - Logout of the fabric
1400  * @lport: The local port to be logged out
1401  *
1402  * Locking Note: The lport lock is expected to be held before calling
1403  * this routine.
1404  */
1405 static void fc_lport_enter_logo(struct fc_lport *lport)
1406 {
1407 	struct fc_frame *fp;
1408 	struct fc_els_logo *logo;
1409 
1410 	FC_LPORT_DBG(lport, "Entered LOGO state from %s state\n",
1411 		     fc_lport_state(lport));
1412 
1413 	fc_lport_state_enter(lport, LPORT_ST_LOGO);
1414 	fc_vports_linkchange(lport);
1415 
1416 	fp = fc_frame_alloc(lport, sizeof(*logo));
1417 	if (!fp) {
1418 		fc_lport_error(lport, fp);
1419 		return;
1420 	}
1421 
1422 	if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_LOGO,
1423 				  fc_lport_logo_resp, lport,
1424 				  2 * lport->r_a_tov))
1425 		fc_lport_error(lport, NULL);
1426 }
1427 
1428 /**
1429  * fc_lport_flogi_resp() - Handle response to FLOGI request
1430  * @sp:	    The sequence that the FLOGI was on
1431  * @fp:	    The FLOGI response frame
1432  * @lp_arg: The lport port that received the FLOGI response
1433  *
1434  * Locking Note: This function will be called without the lport lock
1435  * held, but it will lock, call an _enter_* function or fc_lport_error()
1436  * and then unlock the lport.
1437  */
1438 void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
1439 			 void *lp_arg)
1440 {
1441 	struct fc_lport *lport = lp_arg;
1442 	struct fc_frame_header *fh;
1443 	struct fc_els_flogi *flp;
1444 	u32 did;
1445 	u16 csp_flags;
1446 	unsigned int r_a_tov;
1447 	unsigned int e_d_tov;
1448 	u16 mfs;
1449 
1450 	FC_LPORT_DBG(lport, "Received a FLOGI %s\n", fc_els_resp_type(fp));
1451 
1452 	if (fp == ERR_PTR(-FC_EX_CLOSED))
1453 		return;
1454 
1455 	mutex_lock(&lport->lp_mutex);
1456 
1457 	if (lport->state != LPORT_ST_FLOGI) {
1458 		FC_LPORT_DBG(lport, "Received a FLOGI response, but in state "
1459 			     "%s\n", fc_lport_state(lport));
1460 		if (IS_ERR(fp))
1461 			goto err;
1462 		goto out;
1463 	}
1464 
1465 	if (IS_ERR(fp)) {
1466 		fc_lport_error(lport, fp);
1467 		goto err;
1468 	}
1469 
1470 	fh = fc_frame_header_get(fp);
1471 	did = ntoh24(fh->fh_d_id);
1472 	if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) {
1473 		flp = fc_frame_payload_get(fp, sizeof(*flp));
1474 		if (flp) {
1475 			mfs = ntohs(flp->fl_csp.sp_bb_data) &
1476 				FC_SP_BB_DATA_MASK;
1477 			if (mfs >= FC_SP_MIN_MAX_PAYLOAD &&
1478 			    mfs < lport->mfs)
1479 				lport->mfs = mfs;
1480 			csp_flags = ntohs(flp->fl_csp.sp_features);
1481 			r_a_tov = ntohl(flp->fl_csp.sp_r_a_tov);
1482 			e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);
1483 			if (csp_flags & FC_SP_FT_EDTR)
1484 				e_d_tov /= 1000000;
1485 
1486 			lport->npiv_enabled = !!(csp_flags & FC_SP_FT_NPIV_ACC);
1487 
1488 			if ((csp_flags & FC_SP_FT_FPORT) == 0) {
1489 				if (e_d_tov > lport->e_d_tov)
1490 					lport->e_d_tov = e_d_tov;
1491 				lport->r_a_tov = 2 * e_d_tov;
1492 				fc_lport_set_port_id(lport, did, fp);
1493 				printk(KERN_INFO "host%d: libfc: "
1494 				       "Port (%6x) entered "
1495 				       "point-to-point mode\n",
1496 				       lport->host->host_no, did);
1497 				fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id),
1498 						   get_unaligned_be64(
1499 							   &flp->fl_wwpn),
1500 						   get_unaligned_be64(
1501 							   &flp->fl_wwnn));
1502 			} else {
1503 				lport->e_d_tov = e_d_tov;
1504 				lport->r_a_tov = r_a_tov;
1505 				fc_host_fabric_name(lport->host) =
1506 					get_unaligned_be64(&flp->fl_wwnn);
1507 				fc_lport_set_port_id(lport, did, fp);
1508 				fc_lport_enter_dns(lport);
1509 			}
1510 		}
1511 	} else {
1512 		FC_LPORT_DBG(lport, "Bad FLOGI response\n");
1513 	}
1514 
1515 out:
1516 	fc_frame_free(fp);
1517 err:
1518 	mutex_unlock(&lport->lp_mutex);
1519 }
1520 EXPORT_SYMBOL(fc_lport_flogi_resp);
1521 
1522 /**
1523  * fc_rport_enter_flogi() - Send a FLOGI request to the fabric manager
1524  * @lport: Fibre Channel local port to be logged in to the fabric
1525  *
1526  * Locking Note: The lport lock is expected to be held before calling
1527  * this routine.
1528  */
1529 void fc_lport_enter_flogi(struct fc_lport *lport)
1530 {
1531 	struct fc_frame *fp;
1532 
1533 	FC_LPORT_DBG(lport, "Entered FLOGI state from %s state\n",
1534 		     fc_lport_state(lport));
1535 
1536 	fc_lport_state_enter(lport, LPORT_ST_FLOGI);
1537 
1538 	fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
1539 	if (!fp)
1540 		return fc_lport_error(lport, fp);
1541 
1542 	if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,
1543 				  lport->vport ? ELS_FDISC : ELS_FLOGI,
1544 				  fc_lport_flogi_resp, lport,
1545 				  lport->vport ? 2 * lport->r_a_tov :
1546 				  lport->e_d_tov))
1547 		fc_lport_error(lport, NULL);
1548 }
1549 
1550 /**
1551  * fc_lport_config() - Configure a fc_lport
1552  * @lport: The local port to be configured
1553  */
1554 int fc_lport_config(struct fc_lport *lport)
1555 {
1556 	INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
1557 	mutex_init(&lport->lp_mutex);
1558 
1559 	fc_lport_state_enter(lport, LPORT_ST_DISABLED);
1560 
1561 	fc_lport_add_fc4_type(lport, FC_TYPE_FCP);
1562 	fc_lport_add_fc4_type(lport, FC_TYPE_CT);
1563 
1564 	return 0;
1565 }
1566 EXPORT_SYMBOL(fc_lport_config);
1567 
1568 /**
1569  * fc_lport_init() - Initialize the lport layer for a local port
1570  * @lport: The local port to initialize the exchange layer for
1571  */
1572 int fc_lport_init(struct fc_lport *lport)
1573 {
1574 	if (!lport->tt.lport_recv)
1575 		lport->tt.lport_recv = fc_lport_recv_req;
1576 
1577 	if (!lport->tt.lport_reset)
1578 		lport->tt.lport_reset = fc_lport_reset;
1579 
1580 	fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
1581 	fc_host_node_name(lport->host) = lport->wwnn;
1582 	fc_host_port_name(lport->host) = lport->wwpn;
1583 	fc_host_supported_classes(lport->host) = FC_COS_CLASS3;
1584 	memset(fc_host_supported_fc4s(lport->host), 0,
1585 	       sizeof(fc_host_supported_fc4s(lport->host)));
1586 	fc_host_supported_fc4s(lport->host)[2] = 1;
1587 	fc_host_supported_fc4s(lport->host)[7] = 1;
1588 
1589 	/* This value is also unchanging */
1590 	memset(fc_host_active_fc4s(lport->host), 0,
1591 	       sizeof(fc_host_active_fc4s(lport->host)));
1592 	fc_host_active_fc4s(lport->host)[2] = 1;
1593 	fc_host_active_fc4s(lport->host)[7] = 1;
1594 	fc_host_maxframe_size(lport->host) = lport->mfs;
1595 	fc_host_supported_speeds(lport->host) = 0;
1596 	if (lport->link_supported_speeds & FC_PORTSPEED_1GBIT)
1597 		fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_1GBIT;
1598 	if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT)
1599 		fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT;
1600 
1601 	return 0;
1602 }
1603 EXPORT_SYMBOL(fc_lport_init);
1604 
1605 /**
1606  * fc_lport_bsg_resp() - The common response handler for FC Passthrough requests
1607  * @sp:	      The sequence for the FC Passthrough response
1608  * @fp:	      The response frame
1609  * @info_arg: The BSG info that the response is for
1610  */
1611 static void fc_lport_bsg_resp(struct fc_seq *sp, struct fc_frame *fp,
1612 			      void *info_arg)
1613 {
1614 	struct fc_bsg_info *info = info_arg;
1615 	struct fc_bsg_job *job = info->job;
1616 	struct fc_lport *lport = info->lport;
1617 	struct fc_frame_header *fh;
1618 	size_t len;
1619 	void *buf;
1620 
1621 	if (IS_ERR(fp)) {
1622 		job->reply->result = (PTR_ERR(fp) == -FC_EX_CLOSED) ?
1623 			-ECONNABORTED : -ETIMEDOUT;
1624 		job->reply_len = sizeof(uint32_t);
1625 		job->state_flags |= FC_RQST_STATE_DONE;
1626 		job->job_done(job);
1627 		kfree(info);
1628 		return;
1629 	}
1630 
1631 	mutex_lock(&lport->lp_mutex);
1632 	fh = fc_frame_header_get(fp);
1633 	len = fr_len(fp) - sizeof(*fh);
1634 	buf = fc_frame_payload_get(fp, 0);
1635 
1636 	if (fr_sof(fp) == FC_SOF_I3 && !ntohs(fh->fh_seq_cnt)) {
1637 		/* Get the response code from the first frame payload */
1638 		unsigned short cmd = (info->rsp_code == FC_FS_ACC) ?
1639 			ntohs(((struct fc_ct_hdr *)buf)->ct_cmd) :
1640 			(unsigned short)fc_frame_payload_op(fp);
1641 
1642 		/* Save the reply status of the job */
1643 		job->reply->reply_data.ctels_reply.status =
1644 			(cmd == info->rsp_code) ?
1645 			FC_CTELS_STATUS_OK : FC_CTELS_STATUS_REJECT;
1646 	}
1647 
1648 	job->reply->reply_payload_rcv_len +=
1649 		fc_copy_buffer_to_sglist(buf, len, info->sg, &info->nents,
1650 					 &info->offset, KM_BIO_SRC_IRQ, NULL);
1651 
1652 	if (fr_eof(fp) == FC_EOF_T &&
1653 	    (ntoh24(fh->fh_f_ctl) & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
1654 	    (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) {
1655 		if (job->reply->reply_payload_rcv_len >
1656 		    job->reply_payload.payload_len)
1657 			job->reply->reply_payload_rcv_len =
1658 				job->reply_payload.payload_len;
1659 		job->reply->result = 0;
1660 		job->state_flags |= FC_RQST_STATE_DONE;
1661 		job->job_done(job);
1662 		kfree(info);
1663 	}
1664 	fc_frame_free(fp);
1665 	mutex_unlock(&lport->lp_mutex);
1666 }
1667 
1668 /**
1669  * fc_lport_els_request() - Send ELS passthrough request
1670  * @job:   The BSG Passthrough job
1671  * @lport: The local port sending the request
1672  * @did:   The destination port id
1673  *
1674  * Locking Note: The lport lock is expected to be held before calling
1675  * this routine.
1676  */
1677 static int fc_lport_els_request(struct fc_bsg_job *job,
1678 				struct fc_lport *lport,
1679 				u32 did, u32 tov)
1680 {
1681 	struct fc_bsg_info *info;
1682 	struct fc_frame *fp;
1683 	struct fc_frame_header *fh;
1684 	char *pp;
1685 	int len;
1686 
1687 	fp = fc_frame_alloc(lport, job->request_payload.payload_len);
1688 	if (!fp)
1689 		return -ENOMEM;
1690 
1691 	len = job->request_payload.payload_len;
1692 	pp = fc_frame_payload_get(fp, len);
1693 
1694 	sg_copy_to_buffer(job->request_payload.sg_list,
1695 			  job->request_payload.sg_cnt,
1696 			  pp, len);
1697 
1698 	fh = fc_frame_header_get(fp);
1699 	fh->fh_r_ctl = FC_RCTL_ELS_REQ;
1700 	hton24(fh->fh_d_id, did);
1701 	hton24(fh->fh_s_id, fc_host_port_id(lport->host));
1702 	fh->fh_type = FC_TYPE_ELS;
1703 	hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ |
1704 	       FC_FC_END_SEQ | FC_FC_SEQ_INIT);
1705 	fh->fh_cs_ctl = 0;
1706 	fh->fh_df_ctl = 0;
1707 	fh->fh_parm_offset = 0;
1708 
1709 	info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
1710 	if (!info) {
1711 		fc_frame_free(fp);
1712 		return -ENOMEM;
1713 	}
1714 
1715 	info->job = job;
1716 	info->lport = lport;
1717 	info->rsp_code = ELS_LS_ACC;
1718 	info->nents = job->reply_payload.sg_cnt;
1719 	info->sg = job->reply_payload.sg_list;
1720 
1721 	if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
1722 				     NULL, info, tov))
1723 		return -ECOMM;
1724 	return 0;
1725 }
1726 
1727 /**
1728  * fc_lport_ct_request() - Send CT Passthrough request
1729  * @job:   The BSG Passthrough job
1730  * @lport: The local port sending the request
1731  * @did:   The destination FC-ID
1732  * @tov:   The timeout period to wait for the response
1733  *
1734  * Locking Note: The lport lock is expected to be held before calling
1735  * this routine.
1736  */
1737 static int fc_lport_ct_request(struct fc_bsg_job *job,
1738 			       struct fc_lport *lport, u32 did, u32 tov)
1739 {
1740 	struct fc_bsg_info *info;
1741 	struct fc_frame *fp;
1742 	struct fc_frame_header *fh;
1743 	struct fc_ct_req *ct;
1744 	size_t len;
1745 
1746 	fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
1747 			    job->request_payload.payload_len);
1748 	if (!fp)
1749 		return -ENOMEM;
1750 
1751 	len = job->request_payload.payload_len;
1752 	ct = fc_frame_payload_get(fp, len);
1753 
1754 	sg_copy_to_buffer(job->request_payload.sg_list,
1755 			  job->request_payload.sg_cnt,
1756 			  ct, len);
1757 
1758 	fh = fc_frame_header_get(fp);
1759 	fh->fh_r_ctl = FC_RCTL_DD_UNSOL_CTL;
1760 	hton24(fh->fh_d_id, did);
1761 	hton24(fh->fh_s_id, fc_host_port_id(lport->host));
1762 	fh->fh_type = FC_TYPE_CT;
1763 	hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ |
1764 	       FC_FC_END_SEQ | FC_FC_SEQ_INIT);
1765 	fh->fh_cs_ctl = 0;
1766 	fh->fh_df_ctl = 0;
1767 	fh->fh_parm_offset = 0;
1768 
1769 	info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
1770 	if (!info) {
1771 		fc_frame_free(fp);
1772 		return -ENOMEM;
1773 	}
1774 
1775 	info->job = job;
1776 	info->lport = lport;
1777 	info->rsp_code = FC_FS_ACC;
1778 	info->nents = job->reply_payload.sg_cnt;
1779 	info->sg = job->reply_payload.sg_list;
1780 
1781 	if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
1782 				     NULL, info, tov))
1783 		return -ECOMM;
1784 	return 0;
1785 }
1786 
1787 /**
1788  * fc_lport_bsg_request() - The common entry point for sending
1789  *			    FC Passthrough requests
1790  * @job: The BSG passthrough job
1791  */
1792 int fc_lport_bsg_request(struct fc_bsg_job *job)
1793 {
1794 	struct request *rsp = job->req->next_rq;
1795 	struct Scsi_Host *shost = job->shost;
1796 	struct fc_lport *lport = shost_priv(shost);
1797 	struct fc_rport *rport;
1798 	struct fc_rport_priv *rdata;
1799 	int rc = -EINVAL;
1800 	u32 did;
1801 
1802 	job->reply->reply_payload_rcv_len = 0;
1803 	if (rsp)
1804 		rsp->resid_len = job->reply_payload.payload_len;
1805 
1806 	mutex_lock(&lport->lp_mutex);
1807 
1808 	switch (job->request->msgcode) {
1809 	case FC_BSG_RPT_ELS:
1810 		rport = job->rport;
1811 		if (!rport)
1812 			break;
1813 
1814 		rdata = rport->dd_data;
1815 		rc = fc_lport_els_request(job, lport, rport->port_id,
1816 					  rdata->e_d_tov);
1817 		break;
1818 
1819 	case FC_BSG_RPT_CT:
1820 		rport = job->rport;
1821 		if (!rport)
1822 			break;
1823 
1824 		rdata = rport->dd_data;
1825 		rc = fc_lport_ct_request(job, lport, rport->port_id,
1826 					 rdata->e_d_tov);
1827 		break;
1828 
1829 	case FC_BSG_HST_CT:
1830 		did = ntoh24(job->request->rqst_data.h_ct.port_id);
1831 		if (did == FC_FID_DIR_SERV)
1832 			rdata = lport->dns_rdata;
1833 		else
1834 			rdata = lport->tt.rport_lookup(lport, did);
1835 
1836 		if (!rdata)
1837 			break;
1838 
1839 		rc = fc_lport_ct_request(job, lport, did, rdata->e_d_tov);
1840 		break;
1841 
1842 	case FC_BSG_HST_ELS_NOLOGIN:
1843 		did = ntoh24(job->request->rqst_data.h_els.port_id);
1844 		rc = fc_lport_els_request(job, lport, did, lport->e_d_tov);
1845 		break;
1846 	}
1847 
1848 	mutex_unlock(&lport->lp_mutex);
1849 	return rc;
1850 }
1851 EXPORT_SYMBOL(fc_lport_bsg_request);
1852