1 /*
2  * This file is part of the Chelsio FCoE driver for Linux.
3  *
4  * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved.
5  *
6  * This software is available to you under a choice of one of two
7  * licenses.  You may choose to be licensed under the terms of the GNU
8  * General Public License (GPL) Version 2, available from the file
9  * COPYING in the main directory of this source tree, or the
10  * OpenIB.org BSD license below:
11  *
12  *     Redistribution and use in source and binary forms, with or
13  *     without modification, are permitted provided that the following
14  *     conditions are met:
15  *
16  *      - Redistributions of source code must retain the above
17  *        copyright notice, this list of conditions and the following
18  *        disclaimer.
19  *
20  *      - Redistributions in binary form must reproduce the above
21  *        copyright notice, this list of conditions and the following
22  *        disclaimer in the documentation and/or other materials
23  *        provided with the distribution.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32  * SOFTWARE.
33  */
34 
35 #include <linux/kernel.h>
36 #include <linux/delay.h>
37 #include <linux/slab.h>
38 #include <linux/utsname.h>
39 #include <scsi/scsi_device.h>
40 #include <scsi/scsi_transport_fc.h>
41 #include <asm/unaligned.h>
42 #include <scsi/fc/fc_els.h>
43 #include <scsi/fc/fc_fs.h>
44 #include <scsi/fc/fc_gs.h>
45 #include <scsi/fc/fc_ms.h>
46 
47 #include "csio_hw.h"
48 #include "csio_mb.h"
49 #include "csio_lnode.h"
50 #include "csio_rnode.h"
51 
52 int csio_fcoe_rnodes = 1024;
53 int csio_fdmi_enable = 1;
54 
55 #define PORT_ID_PTR(_x)         ((uint8_t *)(&_x) + 1)
56 
57 /* Lnode SM declarations */
58 static void csio_lns_uninit(struct csio_lnode *, enum csio_ln_ev);
59 static void csio_lns_online(struct csio_lnode *, enum csio_ln_ev);
60 static void csio_lns_ready(struct csio_lnode *, enum csio_ln_ev);
61 static void csio_lns_offline(struct csio_lnode *, enum csio_ln_ev);
62 
63 static int csio_ln_mgmt_submit_req(struct csio_ioreq *,
64 		void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *),
65 		enum fcoe_cmn_type, struct csio_dma_buf *, uint32_t);
66 
67 /* LN event mapping */
68 static enum csio_ln_ev fwevt_to_lnevt[] = {
69 	CSIO_LNE_NONE,		/* None */
70 	CSIO_LNE_NONE,		/* PLOGI_ACC_RCVD  */
71 	CSIO_LNE_NONE,		/* PLOGI_RJT_RCVD  */
72 	CSIO_LNE_NONE,		/* PLOGI_RCVD	   */
73 	CSIO_LNE_NONE,		/* PLOGO_RCVD	   */
74 	CSIO_LNE_NONE,		/* PRLI_ACC_RCVD   */
75 	CSIO_LNE_NONE,		/* PRLI_RJT_RCVD   */
76 	CSIO_LNE_NONE,		/* PRLI_RCVD	   */
77 	CSIO_LNE_NONE,		/* PRLO_RCVD	   */
78 	CSIO_LNE_NONE,		/* NPORT_ID_CHGD   */
79 	CSIO_LNE_LOGO,		/* FLOGO_RCVD	   */
80 	CSIO_LNE_LOGO,		/* CLR_VIRT_LNK_RCVD */
81 	CSIO_LNE_FAB_INIT_DONE,/* FLOGI_ACC_RCVD   */
82 	CSIO_LNE_NONE,		/* FLOGI_RJT_RCVD   */
83 	CSIO_LNE_FAB_INIT_DONE,/* FDISC_ACC_RCVD   */
84 	CSIO_LNE_NONE,		/* FDISC_RJT_RCVD   */
85 	CSIO_LNE_NONE,		/* FLOGI_TMO_MAX_RETRY */
86 	CSIO_LNE_NONE,		/* IMPL_LOGO_ADISC_ACC */
87 	CSIO_LNE_NONE,		/* IMPL_LOGO_ADISC_RJT */
88 	CSIO_LNE_NONE,		/* IMPL_LOGO_ADISC_CNFLT */
89 	CSIO_LNE_NONE,		/* PRLI_TMO		*/
90 	CSIO_LNE_NONE,		/* ADISC_TMO		*/
91 	CSIO_LNE_NONE,		/* RSCN_DEV_LOST */
92 	CSIO_LNE_NONE,		/* SCR_ACC_RCVD */
93 	CSIO_LNE_NONE,		/* ADISC_RJT_RCVD */
94 	CSIO_LNE_NONE,		/* LOGO_SNT */
95 	CSIO_LNE_NONE,		/* PROTO_ERR_IMPL_LOGO */
96 };
97 
98 #define CSIO_FWE_TO_LNE(_evt)	((_evt > PROTO_ERR_IMPL_LOGO) ?		\
99 						CSIO_LNE_NONE :	\
100 						fwevt_to_lnevt[_evt])
101 
102 #define csio_ct_rsp(cp)		(((struct fc_ct_hdr *)cp)->ct_cmd)
103 #define csio_ct_reason(cp)	(((struct fc_ct_hdr *)cp)->ct_reason)
104 #define csio_ct_expl(cp)	(((struct fc_ct_hdr *)cp)->ct_explan)
105 #define csio_ct_get_pld(cp)	((void *)(((uint8_t *)cp) + FC_CT_HDR_LEN))
106 
107 /*
108  * csio_ln_match_by_portid - lookup lnode using given portid.
109  * @hw: HW module
110  * @portid: port-id.
111  *
112  * If found, returns lnode matching given portid otherwise returns NULL.
113  */
114 static struct csio_lnode *
115 csio_ln_lookup_by_portid(struct csio_hw *hw, uint8_t portid)
116 {
117 	struct csio_lnode *ln;
118 	struct list_head *tmp;
119 
120 	/* Match siblings lnode with portid */
121 	list_for_each(tmp, &hw->sln_head) {
122 		ln = (struct csio_lnode *) tmp;
123 		if (ln->portid == portid)
124 			return ln;
125 	}
126 
127 	return NULL;
128 }
129 
130 /*
131  * csio_ln_lookup_by_vnpi - Lookup lnode using given vnp id.
132  * @hw - HW module
133  * @vnpi - vnp index.
134  * Returns - If found, returns lnode matching given vnp id
135  * otherwise returns NULL.
136  */
137 static struct csio_lnode *
138 csio_ln_lookup_by_vnpi(struct csio_hw *hw, uint32_t vnp_id)
139 {
140 	struct list_head *tmp1, *tmp2;
141 	struct csio_lnode *sln = NULL, *cln = NULL;
142 
143 	if (list_empty(&hw->sln_head)) {
144 		CSIO_INC_STATS(hw, n_lnlkup_miss);
145 		return NULL;
146 	}
147 	/* Traverse sibling lnodes */
148 	list_for_each(tmp1, &hw->sln_head) {
149 		sln = (struct csio_lnode *) tmp1;
150 
151 		/* Match sibling lnode */
152 		if (sln->vnp_flowid == vnp_id)
153 			return sln;
154 
155 		if (list_empty(&sln->cln_head))
156 			continue;
157 
158 		/* Traverse children lnodes */
159 		list_for_each(tmp2, &sln->cln_head) {
160 			cln = (struct csio_lnode *) tmp2;
161 
162 			if (cln->vnp_flowid == vnp_id)
163 				return cln;
164 		}
165 	}
166 	CSIO_INC_STATS(hw, n_lnlkup_miss);
167 	return NULL;
168 }
169 
170 /**
171  * csio_lnode_lookup_by_wwpn - Lookup lnode using given wwpn.
172  * @hw:		HW module.
173  * @wwpn:	WWPN.
174  *
175  * If found, returns lnode matching given wwpn, returns NULL otherwise.
176  */
177 struct csio_lnode *
178 csio_lnode_lookup_by_wwpn(struct csio_hw *hw, uint8_t *wwpn)
179 {
180 	struct list_head *tmp1, *tmp2;
181 	struct csio_lnode *sln = NULL, *cln = NULL;
182 
183 	if (list_empty(&hw->sln_head)) {
184 		CSIO_INC_STATS(hw, n_lnlkup_miss);
185 		return NULL;
186 	}
187 	/* Traverse sibling lnodes */
188 	list_for_each(tmp1, &hw->sln_head) {
189 		sln = (struct csio_lnode *) tmp1;
190 
191 		/* Match sibling lnode */
192 		if (!memcmp(csio_ln_wwpn(sln), wwpn, 8))
193 			return sln;
194 
195 		if (list_empty(&sln->cln_head))
196 			continue;
197 
198 		/* Traverse children lnodes */
199 		list_for_each(tmp2, &sln->cln_head) {
200 			cln = (struct csio_lnode *) tmp2;
201 
202 			if (!memcmp(csio_ln_wwpn(cln), wwpn, 8))
203 				return cln;
204 		}
205 	}
206 	return NULL;
207 }
208 
209 /* FDMI */
210 static void
211 csio_fill_ct_iu(void *buf, uint8_t type, uint8_t sub_type, uint16_t op)
212 {
213 	struct fc_ct_hdr *cmd = (struct fc_ct_hdr *)buf;
214 	cmd->ct_rev = FC_CT_REV;
215 	cmd->ct_fs_type = type;
216 	cmd->ct_fs_subtype = sub_type;
217 	cmd->ct_cmd = htons(op);
218 }
219 
220 static int
221 csio_hostname(uint8_t *buf, size_t buf_len)
222 {
223 	if (snprintf(buf, buf_len, "%s", init_utsname()->nodename) > 0)
224 		return 0;
225 	return -1;
226 }
227 
228 static int
229 csio_osname(uint8_t *buf, size_t buf_len)
230 {
231 	if (snprintf(buf, buf_len, "%s %s %s",
232 		     init_utsname()->sysname,
233 		     init_utsname()->release,
234 		     init_utsname()->version) > 0)
235 		return 0;
236 
237 	return -1;
238 }
239 
240 static inline void
241 csio_append_attrib(uint8_t **ptr, uint16_t type, void *val, size_t val_len)
242 {
243 	uint16_t len;
244 	struct fc_fdmi_attr_entry *ae = (struct fc_fdmi_attr_entry *)*ptr;
245 
246 	if (WARN_ON(val_len > U16_MAX))
247 		return;
248 
249 	len = val_len;
250 
251 	ae->type = htons(type);
252 	len += 4;		/* includes attribute type and length */
253 	len = (len + 3) & ~3;	/* should be multiple of 4 bytes */
254 	ae->len = htons(len);
255 	memcpy(ae->value, val, val_len);
256 	if (len > val_len)
257 		memset(ae->value + val_len, 0, len - val_len);
258 	*ptr += len;
259 }
260 
261 /*
262  * csio_ln_fdmi_done - FDMI registeration completion
263  * @hw: HW context
264  * @fdmi_req: fdmi request
265  */
266 static void
267 csio_ln_fdmi_done(struct csio_hw *hw, struct csio_ioreq *fdmi_req)
268 {
269 	void *cmd;
270 	struct csio_lnode *ln = fdmi_req->lnode;
271 
272 	if (fdmi_req->wr_status != FW_SUCCESS) {
273 		csio_ln_dbg(ln, "WR error:%x in processing fdmi rpa cmd\n",
274 			    fdmi_req->wr_status);
275 		CSIO_INC_STATS(ln, n_fdmi_err);
276 	}
277 
278 	cmd = fdmi_req->dma_buf.vaddr;
279 	if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) {
280 		csio_ln_dbg(ln, "fdmi rpa cmd rejected reason %x expl %x\n",
281 			    csio_ct_reason(cmd), csio_ct_expl(cmd));
282 	}
283 }
284 
285 /*
286  * csio_ln_fdmi_rhba_cbfn - RHBA completion
287  * @hw: HW context
288  * @fdmi_req: fdmi request
289  */
290 static void
291 csio_ln_fdmi_rhba_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req)
292 {
293 	void *cmd;
294 	uint8_t *pld;
295 	uint32_t len = 0;
296 	__be32 val;
297 	__be16 mfs;
298 	uint32_t numattrs = 0;
299 	struct csio_lnode *ln = fdmi_req->lnode;
300 	struct fs_fdmi_attrs *attrib_blk;
301 	struct fc_fdmi_port_name *port_name;
302 	uint8_t buf[64];
303 	uint8_t *fc4_type;
304 	unsigned long flags;
305 
306 	if (fdmi_req->wr_status != FW_SUCCESS) {
307 		csio_ln_dbg(ln, "WR error:%x in processing fdmi rhba cmd\n",
308 			    fdmi_req->wr_status);
309 		CSIO_INC_STATS(ln, n_fdmi_err);
310 	}
311 
312 	cmd = fdmi_req->dma_buf.vaddr;
313 	if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) {
314 		csio_ln_dbg(ln, "fdmi rhba cmd rejected reason %x expl %x\n",
315 			    csio_ct_reason(cmd), csio_ct_expl(cmd));
316 	}
317 
318 	if (!csio_is_rnode_ready(fdmi_req->rnode)) {
319 		CSIO_INC_STATS(ln, n_fdmi_err);
320 		return;
321 	}
322 
323 	/* Prepare CT hdr for RPA cmd */
324 	memset(cmd, 0, FC_CT_HDR_LEN);
325 	csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_RPA);
326 
327 	/* Prepare RPA payload */
328 	pld = (uint8_t *)csio_ct_get_pld(cmd);
329 	port_name = (struct fc_fdmi_port_name *)pld;
330 	memcpy(&port_name->portname, csio_ln_wwpn(ln), 8);
331 	pld += sizeof(*port_name);
332 
333 	/* Start appending Port attributes */
334 	attrib_blk = (struct fs_fdmi_attrs *)pld;
335 	attrib_blk->numattrs = 0;
336 	len += sizeof(attrib_blk->numattrs);
337 	pld += sizeof(attrib_blk->numattrs);
338 
339 	fc4_type = &buf[0];
340 	memset(fc4_type, 0, FC_FDMI_PORT_ATTR_FC4TYPES_LEN);
341 	fc4_type[2] = 1;
342 	fc4_type[7] = 1;
343 	csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_FC4TYPES,
344 			   fc4_type, FC_FDMI_PORT_ATTR_FC4TYPES_LEN);
345 	numattrs++;
346 	val = htonl(FC_PORTSPEED_1GBIT | FC_PORTSPEED_10GBIT);
347 	csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_SUPPORTEDSPEED,
348 			   &val,
349 			   FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN);
350 	numattrs++;
351 
352 	if (hw->pport[ln->portid].link_speed == FW_PORT_CAP_SPEED_1G)
353 		val = htonl(FC_PORTSPEED_1GBIT);
354 	else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP_SPEED_10G)
355 		val = htonl(FC_PORTSPEED_10GBIT);
356 	else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP32_SPEED_25G)
357 		val = htonl(FC_PORTSPEED_25GBIT);
358 	else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP32_SPEED_40G)
359 		val = htonl(FC_PORTSPEED_40GBIT);
360 	else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP32_SPEED_50G)
361 		val = htonl(FC_PORTSPEED_50GBIT);
362 	else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP32_SPEED_100G)
363 		val = htonl(FC_PORTSPEED_100GBIT);
364 	else
365 		val = htonl(CSIO_HBA_PORTSPEED_UNKNOWN);
366 	csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_CURRENTPORTSPEED,
367 			   &val, FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN);
368 	numattrs++;
369 
370 	mfs = ln->ln_sparm.csp.sp_bb_data;
371 	csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_MAXFRAMESIZE,
372 			   &mfs, sizeof(mfs));
373 	numattrs++;
374 
375 	strcpy(buf, "csiostor");
376 	csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_OSDEVICENAME, buf,
377 			   strlen(buf));
378 	numattrs++;
379 
380 	if (!csio_hostname(buf, sizeof(buf))) {
381 		csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_HOSTNAME,
382 				   buf, strlen(buf));
383 		numattrs++;
384 	}
385 	attrib_blk->numattrs = htonl(numattrs);
386 	len = (uint32_t)(pld - (uint8_t *)cmd);
387 
388 	/* Submit FDMI RPA request */
389 	spin_lock_irqsave(&hw->lock, flags);
390 	if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_done,
391 				FCOE_CT, &fdmi_req->dma_buf, len)) {
392 		CSIO_INC_STATS(ln, n_fdmi_err);
393 		csio_ln_dbg(ln, "Failed to issue fdmi rpa req\n");
394 	}
395 	spin_unlock_irqrestore(&hw->lock, flags);
396 }
397 
398 /*
399  * csio_ln_fdmi_dprt_cbfn - DPRT completion
400  * @hw: HW context
401  * @fdmi_req: fdmi request
402  */
403 static void
404 csio_ln_fdmi_dprt_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req)
405 {
406 	void *cmd;
407 	uint8_t *pld;
408 	uint32_t len = 0;
409 	uint32_t numattrs = 0;
410 	__be32  maxpayload = htonl(65536);
411 	struct fc_fdmi_hba_identifier *hbaid;
412 	struct csio_lnode *ln = fdmi_req->lnode;
413 	struct fc_fdmi_rpl *reg_pl;
414 	struct fs_fdmi_attrs *attrib_blk;
415 	uint8_t buf[64];
416 	unsigned long flags;
417 
418 	if (fdmi_req->wr_status != FW_SUCCESS) {
419 		csio_ln_dbg(ln, "WR error:%x in processing fdmi dprt cmd\n",
420 			    fdmi_req->wr_status);
421 		CSIO_INC_STATS(ln, n_fdmi_err);
422 	}
423 
424 	if (!csio_is_rnode_ready(fdmi_req->rnode)) {
425 		CSIO_INC_STATS(ln, n_fdmi_err);
426 		return;
427 	}
428 	cmd = fdmi_req->dma_buf.vaddr;
429 	if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) {
430 		csio_ln_dbg(ln, "fdmi dprt cmd rejected reason %x expl %x\n",
431 			    csio_ct_reason(cmd), csio_ct_expl(cmd));
432 	}
433 
434 	/* Prepare CT hdr for RHBA cmd */
435 	memset(cmd, 0, FC_CT_HDR_LEN);
436 	csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_RHBA);
437 	len = FC_CT_HDR_LEN;
438 
439 	/* Prepare RHBA payload */
440 	pld = (uint8_t *)csio_ct_get_pld(cmd);
441 	hbaid = (struct fc_fdmi_hba_identifier *)pld;
442 	memcpy(&hbaid->id, csio_ln_wwpn(ln), 8); /* HBA identifer */
443 	pld += sizeof(*hbaid);
444 
445 	/* Register one port per hba */
446 	reg_pl = (struct fc_fdmi_rpl *)pld;
447 	reg_pl->numport = htonl(1);
448 	memcpy(&reg_pl->port[0].portname, csio_ln_wwpn(ln), 8);
449 	pld += sizeof(*reg_pl);
450 
451 	/* Start appending HBA attributes hba */
452 	attrib_blk = (struct fs_fdmi_attrs *)pld;
453 	attrib_blk->numattrs = 0;
454 	len += sizeof(attrib_blk->numattrs);
455 	pld += sizeof(attrib_blk->numattrs);
456 
457 	csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_NODENAME, csio_ln_wwnn(ln),
458 			   FC_FDMI_HBA_ATTR_NODENAME_LEN);
459 	numattrs++;
460 
461 	memset(buf, 0, sizeof(buf));
462 
463 	strcpy(buf, "Chelsio Communications");
464 	csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MANUFACTURER, buf,
465 			   strlen(buf));
466 	numattrs++;
467 	csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_SERIALNUMBER,
468 			   hw->vpd.sn, sizeof(hw->vpd.sn));
469 	numattrs++;
470 	csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MODEL, hw->vpd.id,
471 			   sizeof(hw->vpd.id));
472 	numattrs++;
473 	csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MODELDESCRIPTION,
474 			   hw->model_desc, strlen(hw->model_desc));
475 	numattrs++;
476 	csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_HARDWAREVERSION,
477 			   hw->hw_ver, sizeof(hw->hw_ver));
478 	numattrs++;
479 	csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_FIRMWAREVERSION,
480 			   hw->fwrev_str, strlen(hw->fwrev_str));
481 	numattrs++;
482 
483 	if (!csio_osname(buf, sizeof(buf))) {
484 		csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_OSNAMEVERSION,
485 				   buf, strlen(buf));
486 		numattrs++;
487 	}
488 
489 	csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MAXCTPAYLOAD,
490 			   &maxpayload, FC_FDMI_HBA_ATTR_MAXCTPAYLOAD_LEN);
491 	len = (uint32_t)(pld - (uint8_t *)cmd);
492 	numattrs++;
493 	attrib_blk->numattrs = htonl(numattrs);
494 
495 	/* Submit FDMI RHBA request */
496 	spin_lock_irqsave(&hw->lock, flags);
497 	if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_rhba_cbfn,
498 				FCOE_CT, &fdmi_req->dma_buf, len)) {
499 		CSIO_INC_STATS(ln, n_fdmi_err);
500 		csio_ln_dbg(ln, "Failed to issue fdmi rhba req\n");
501 	}
502 	spin_unlock_irqrestore(&hw->lock, flags);
503 }
504 
505 /*
506  * csio_ln_fdmi_dhba_cbfn - DHBA completion
507  * @hw: HW context
508  * @fdmi_req: fdmi request
509  */
510 static void
511 csio_ln_fdmi_dhba_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req)
512 {
513 	struct csio_lnode *ln = fdmi_req->lnode;
514 	void *cmd;
515 	struct fc_fdmi_port_name *port_name;
516 	uint32_t len;
517 	unsigned long flags;
518 
519 	if (fdmi_req->wr_status != FW_SUCCESS) {
520 		csio_ln_dbg(ln, "WR error:%x in processing fdmi dhba cmd\n",
521 			    fdmi_req->wr_status);
522 		CSIO_INC_STATS(ln, n_fdmi_err);
523 	}
524 
525 	if (!csio_is_rnode_ready(fdmi_req->rnode)) {
526 		CSIO_INC_STATS(ln, n_fdmi_err);
527 		return;
528 	}
529 	cmd = fdmi_req->dma_buf.vaddr;
530 	if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) {
531 		csio_ln_dbg(ln, "fdmi dhba cmd rejected reason %x expl %x\n",
532 			    csio_ct_reason(cmd), csio_ct_expl(cmd));
533 	}
534 
535 	/* Send FDMI cmd to de-register any Port attributes if registered
536 	 * before
537 	 */
538 
539 	/* Prepare FDMI DPRT cmd */
540 	memset(cmd, 0, FC_CT_HDR_LEN);
541 	csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_DPRT);
542 	len = FC_CT_HDR_LEN;
543 	port_name = (struct fc_fdmi_port_name *)csio_ct_get_pld(cmd);
544 	memcpy(&port_name->portname, csio_ln_wwpn(ln), 8);
545 	len += sizeof(*port_name);
546 
547 	/* Submit FDMI request */
548 	spin_lock_irqsave(&hw->lock, flags);
549 	if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_dprt_cbfn,
550 				FCOE_CT, &fdmi_req->dma_buf, len)) {
551 		CSIO_INC_STATS(ln, n_fdmi_err);
552 		csio_ln_dbg(ln, "Failed to issue fdmi dprt req\n");
553 	}
554 	spin_unlock_irqrestore(&hw->lock, flags);
555 }
556 
557 /**
558  * csio_ln_fdmi_start - Start an FDMI request.
559  * @ln:		lnode
560  * @context:	session context
561  *
562  * Issued with lock held.
563  */
564 int
565 csio_ln_fdmi_start(struct csio_lnode *ln, void *context)
566 {
567 	struct csio_ioreq *fdmi_req;
568 	struct csio_rnode *fdmi_rn = (struct csio_rnode *)context;
569 	void *cmd;
570 	struct fc_fdmi_hba_identifier *hbaid;
571 	uint32_t len;
572 
573 	if (!(ln->flags & CSIO_LNF_FDMI_ENABLE))
574 		return -EPROTONOSUPPORT;
575 
576 	if (!csio_is_rnode_ready(fdmi_rn))
577 		CSIO_INC_STATS(ln, n_fdmi_err);
578 
579 	/* Send FDMI cmd to de-register any HBA attributes if registered
580 	 * before
581 	 */
582 
583 	fdmi_req = ln->mgmt_req;
584 	fdmi_req->lnode = ln;
585 	fdmi_req->rnode = fdmi_rn;
586 
587 	/* Prepare FDMI DHBA cmd */
588 	cmd = fdmi_req->dma_buf.vaddr;
589 	memset(cmd, 0, FC_CT_HDR_LEN);
590 	csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_DHBA);
591 	len = FC_CT_HDR_LEN;
592 
593 	hbaid = (struct fc_fdmi_hba_identifier *)csio_ct_get_pld(cmd);
594 	memcpy(&hbaid->id, csio_ln_wwpn(ln), 8);
595 	len += sizeof(*hbaid);
596 
597 	/* Submit FDMI request */
598 	if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_dhba_cbfn,
599 					FCOE_CT, &fdmi_req->dma_buf, len)) {
600 		CSIO_INC_STATS(ln, n_fdmi_err);
601 		csio_ln_dbg(ln, "Failed to issue fdmi dhba req\n");
602 	}
603 
604 	return 0;
605 }
606 
607 /*
608  * csio_ln_vnp_read_cbfn - vnp read completion handler.
609  * @hw: HW lnode
610  * @cbfn: Completion handler.
611  *
612  * Reads vnp response and updates ln parameters.
613  */
614 static void
615 csio_ln_vnp_read_cbfn(struct csio_hw *hw, struct csio_mb *mbp)
616 {
617 	struct csio_lnode *ln = ((struct csio_lnode *)mbp->priv);
618 	struct fw_fcoe_vnp_cmd *rsp = (struct fw_fcoe_vnp_cmd *)(mbp->mb);
619 	struct fc_els_csp *csp;
620 	struct fc_els_cssp *clsp;
621 	enum fw_retval retval;
622 	__be32 nport_id;
623 
624 	retval = FW_CMD_RETVAL_G(ntohl(rsp->alloc_to_len16));
625 	if (retval != FW_SUCCESS) {
626 		csio_err(hw, "FCOE VNP read cmd returned error:0x%x\n", retval);
627 		mempool_free(mbp, hw->mb_mempool);
628 		return;
629 	}
630 
631 	spin_lock_irq(&hw->lock);
632 
633 	memcpy(ln->mac, rsp->vnport_mac, sizeof(ln->mac));
634 	memcpy(&nport_id, &rsp->vnport_mac[3], sizeof(uint8_t)*3);
635 	ln->nport_id = ntohl(nport_id);
636 	ln->nport_id = ln->nport_id >> 8;
637 
638 	/* Update WWNs */
639 	/*
640 	 * This may look like a duplication of what csio_fcoe_enable_link()
641 	 * does, but is absolutely necessary if the vnpi changes between
642 	 * a FCOE LINK UP and FCOE LINK DOWN.
643 	 */
644 	memcpy(csio_ln_wwnn(ln), rsp->vnport_wwnn, 8);
645 	memcpy(csio_ln_wwpn(ln), rsp->vnport_wwpn, 8);
646 
647 	/* Copy common sparam */
648 	csp = (struct fc_els_csp *)rsp->cmn_srv_parms;
649 	ln->ln_sparm.csp.sp_hi_ver = csp->sp_hi_ver;
650 	ln->ln_sparm.csp.sp_lo_ver = csp->sp_lo_ver;
651 	ln->ln_sparm.csp.sp_bb_cred = csp->sp_bb_cred;
652 	ln->ln_sparm.csp.sp_features = csp->sp_features;
653 	ln->ln_sparm.csp.sp_bb_data = csp->sp_bb_data;
654 	ln->ln_sparm.csp.sp_r_a_tov = csp->sp_r_a_tov;
655 	ln->ln_sparm.csp.sp_e_d_tov = csp->sp_e_d_tov;
656 
657 	/* Copy word 0 & word 1 of class sparam */
658 	clsp = (struct fc_els_cssp *)rsp->clsp_word_0_1;
659 	ln->ln_sparm.clsp[2].cp_class = clsp->cp_class;
660 	ln->ln_sparm.clsp[2].cp_init = clsp->cp_init;
661 	ln->ln_sparm.clsp[2].cp_recip = clsp->cp_recip;
662 	ln->ln_sparm.clsp[2].cp_rdfs = clsp->cp_rdfs;
663 
664 	spin_unlock_irq(&hw->lock);
665 
666 	mempool_free(mbp, hw->mb_mempool);
667 
668 	/* Send an event to update local attribs */
669 	csio_lnode_async_event(ln, CSIO_LN_FC_ATTRIB_UPDATE);
670 }
671 
672 /*
673  * csio_ln_vnp_read - Read vnp params.
674  * @ln: lnode
675  * @cbfn: Completion handler.
676  *
677  * Issued with lock held.
678  */
679 static int
680 csio_ln_vnp_read(struct csio_lnode *ln,
681 		void (*cbfn) (struct csio_hw *, struct csio_mb *))
682 {
683 	struct csio_hw *hw = ln->hwp;
684 	struct csio_mb  *mbp;
685 
686 	/* Allocate Mbox request */
687 	mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
688 	if (!mbp) {
689 		CSIO_INC_STATS(hw, n_err_nomem);
690 		return -ENOMEM;
691 	}
692 
693 	/* Prepare VNP Command */
694 	csio_fcoe_vnp_read_init_mb(ln, mbp,
695 				    CSIO_MB_DEFAULT_TMO,
696 				    ln->fcf_flowid,
697 				    ln->vnp_flowid,
698 				    cbfn);
699 
700 	/* Issue MBOX cmd */
701 	if (csio_mb_issue(hw, mbp)) {
702 		csio_err(hw, "Failed to issue mbox FCoE VNP command\n");
703 		mempool_free(mbp, hw->mb_mempool);
704 		return -EINVAL;
705 	}
706 
707 	return 0;
708 }
709 
710 /*
711  * csio_fcoe_enable_link - Enable fcoe link.
712  * @ln: lnode
713  * @enable: enable/disable
714  * Issued with lock held.
715  * Issues mbox cmd to bring up FCOE link on port associated with given ln.
716  */
717 static int
718 csio_fcoe_enable_link(struct csio_lnode *ln, bool enable)
719 {
720 	struct csio_hw *hw = ln->hwp;
721 	struct csio_mb  *mbp;
722 	enum fw_retval retval;
723 	uint8_t portid;
724 	uint8_t sub_op;
725 	struct fw_fcoe_link_cmd *lcmd;
726 	int i;
727 
728 	mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
729 	if (!mbp) {
730 		CSIO_INC_STATS(hw, n_err_nomem);
731 		return -ENOMEM;
732 	}
733 
734 	portid = ln->portid;
735 	sub_op = enable ? FCOE_LINK_UP : FCOE_LINK_DOWN;
736 
737 	csio_dbg(hw, "bringing FCOE LINK %s on Port:%d\n",
738 		 sub_op ? "UP" : "DOWN", portid);
739 
740 	csio_write_fcoe_link_cond_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO,
741 					  portid, sub_op, 0, 0, 0, NULL);
742 
743 	if (csio_mb_issue(hw, mbp)) {
744 		csio_err(hw, "failed to issue FCOE LINK cmd on port[%d]\n",
745 			portid);
746 		mempool_free(mbp, hw->mb_mempool);
747 		return -EINVAL;
748 	}
749 
750 	retval = csio_mb_fw_retval(mbp);
751 	if (retval != FW_SUCCESS) {
752 		csio_err(hw,
753 			 "FCOE LINK %s cmd on port[%d] failed with "
754 			 "ret:x%x\n", sub_op ? "UP" : "DOWN", portid, retval);
755 		mempool_free(mbp, hw->mb_mempool);
756 		return -EINVAL;
757 	}
758 
759 	if (!enable)
760 		goto out;
761 
762 	lcmd = (struct fw_fcoe_link_cmd *)mbp->mb;
763 
764 	memcpy(csio_ln_wwnn(ln), lcmd->vnport_wwnn, 8);
765 	memcpy(csio_ln_wwpn(ln), lcmd->vnport_wwpn, 8);
766 
767 	for (i = 0; i < CSIO_MAX_PPORTS; i++)
768 		if (hw->pport[i].portid == portid)
769 			memcpy(hw->pport[i].mac, lcmd->phy_mac, 6);
770 
771 out:
772 	mempool_free(mbp, hw->mb_mempool);
773 	return 0;
774 }
775 
776 /*
777  * csio_ln_read_fcf_cbfn - Read fcf parameters
778  * @ln: lnode
779  *
780  * read fcf response and Update ln fcf information.
781  */
782 static void
783 csio_ln_read_fcf_cbfn(struct csio_hw *hw, struct csio_mb *mbp)
784 {
785 	struct csio_lnode *ln = (struct csio_lnode *)mbp->priv;
786 	struct csio_fcf_info	*fcf_info;
787 	struct fw_fcoe_fcf_cmd *rsp =
788 				(struct fw_fcoe_fcf_cmd *)(mbp->mb);
789 	enum fw_retval retval;
790 
791 	retval = FW_CMD_RETVAL_G(ntohl(rsp->retval_len16));
792 	if (retval != FW_SUCCESS) {
793 		csio_ln_err(ln, "FCOE FCF cmd failed with ret x%x\n",
794 				retval);
795 		mempool_free(mbp, hw->mb_mempool);
796 		return;
797 	}
798 
799 	spin_lock_irq(&hw->lock);
800 	fcf_info = ln->fcfinfo;
801 	fcf_info->priority = FW_FCOE_FCF_CMD_PRIORITY_GET(
802 					ntohs(rsp->priority_pkd));
803 	fcf_info->vf_id = ntohs(rsp->vf_id);
804 	fcf_info->vlan_id = rsp->vlan_id;
805 	fcf_info->max_fcoe_size = ntohs(rsp->max_fcoe_size);
806 	fcf_info->fka_adv = be32_to_cpu(rsp->fka_adv);
807 	fcf_info->fcfi = FW_FCOE_FCF_CMD_FCFI_GET(ntohl(rsp->op_to_fcfi));
808 	fcf_info->fpma = FW_FCOE_FCF_CMD_FPMA_GET(rsp->fpma_to_portid);
809 	fcf_info->spma = FW_FCOE_FCF_CMD_SPMA_GET(rsp->fpma_to_portid);
810 	fcf_info->login = FW_FCOE_FCF_CMD_LOGIN_GET(rsp->fpma_to_portid);
811 	fcf_info->portid = FW_FCOE_FCF_CMD_PORTID_GET(rsp->fpma_to_portid);
812 	memcpy(fcf_info->fc_map, rsp->fc_map, sizeof(fcf_info->fc_map));
813 	memcpy(fcf_info->mac, rsp->mac, sizeof(fcf_info->mac));
814 	memcpy(fcf_info->name_id, rsp->name_id, sizeof(fcf_info->name_id));
815 	memcpy(fcf_info->fabric, rsp->fabric, sizeof(fcf_info->fabric));
816 	memcpy(fcf_info->spma_mac, rsp->spma_mac, sizeof(fcf_info->spma_mac));
817 
818 	spin_unlock_irq(&hw->lock);
819 
820 	mempool_free(mbp, hw->mb_mempool);
821 }
822 
823 /*
824  * csio_ln_read_fcf_entry - Read fcf entry.
825  * @ln: lnode
826  * @cbfn: Completion handler.
827  *
828  * Issued with lock held.
829  */
830 static int
831 csio_ln_read_fcf_entry(struct csio_lnode *ln,
832 			void (*cbfn) (struct csio_hw *, struct csio_mb *))
833 {
834 	struct csio_hw *hw = ln->hwp;
835 	struct csio_mb  *mbp;
836 
837 	mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
838 	if (!mbp) {
839 		CSIO_INC_STATS(hw, n_err_nomem);
840 		return -ENOMEM;
841 	}
842 
843 	/* Get FCoE FCF information */
844 	csio_fcoe_read_fcf_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO,
845 				      ln->portid, ln->fcf_flowid, cbfn);
846 
847 	if (csio_mb_issue(hw, mbp)) {
848 		csio_err(hw, "failed to issue FCOE FCF cmd\n");
849 		mempool_free(mbp, hw->mb_mempool);
850 		return -EINVAL;
851 	}
852 
853 	return 0;
854 }
855 
856 /*
857  * csio_handle_link_up - Logical Linkup event.
858  * @hw - HW module.
859  * @portid - Physical port number
860  * @fcfi - FCF index.
861  * @vnpi - VNP index.
862  * Returns - none.
863  *
864  * This event is received from FW, when virtual link is established between
865  * Physical port[ENode] and FCF. If its new vnpi, then local node object is
866  * created on this FCF and set to [ONLINE] state.
867  * Lnode waits for FW_RDEV_CMD event to be received indicating that
868  * Fabric login is completed and lnode moves to [READY] state.
869  *
870  * This called with hw lock held
871  */
872 static void
873 csio_handle_link_up(struct csio_hw *hw, uint8_t portid, uint32_t fcfi,
874 		    uint32_t vnpi)
875 {
876 	struct csio_lnode *ln = NULL;
877 
878 	/* Lookup lnode based on vnpi */
879 	ln = csio_ln_lookup_by_vnpi(hw, vnpi);
880 	if (!ln) {
881 		/* Pick lnode based on portid */
882 		ln = csio_ln_lookup_by_portid(hw, portid);
883 		if (!ln) {
884 			csio_err(hw, "failed to lookup fcoe lnode on port:%d\n",
885 				portid);
886 			CSIO_DB_ASSERT(0);
887 			return;
888 		}
889 
890 		/* Check if lnode has valid vnp flowid */
891 		if (ln->vnp_flowid != CSIO_INVALID_IDX) {
892 			/* New VN-Port */
893 			spin_unlock_irq(&hw->lock);
894 			csio_lnode_alloc(hw);
895 			spin_lock_irq(&hw->lock);
896 			if (!ln) {
897 				csio_err(hw,
898 					 "failed to allocate fcoe lnode"
899 					 "for port:%d vnpi:x%x\n",
900 					 portid, vnpi);
901 				CSIO_DB_ASSERT(0);
902 				return;
903 			}
904 			ln->portid = portid;
905 		}
906 		ln->vnp_flowid = vnpi;
907 		ln->dev_num &= ~0xFFFF;
908 		ln->dev_num |= vnpi;
909 	}
910 
911 	/*Initialize fcfi */
912 	ln->fcf_flowid = fcfi;
913 
914 	csio_info(hw, "Port:%d - FCOE LINK UP\n", portid);
915 
916 	CSIO_INC_STATS(ln, n_link_up);
917 
918 	/* Send LINKUP event to SM */
919 	csio_post_event(&ln->sm, CSIO_LNE_LINKUP);
920 }
921 
922 /*
923  * csio_post_event_rns
924  * @ln - FCOE lnode
925  * @evt - Given rnode event
926  * Returns - none
927  *
928  * Posts given rnode event to all FCOE rnodes connected with given Lnode.
929  * This routine is invoked when lnode receives LINK_DOWN/DOWN_LINK/CLOSE
930  * event.
931  *
932  * This called with hw lock held
933  */
934 static void
935 csio_post_event_rns(struct csio_lnode *ln, enum csio_rn_ev evt)
936 {
937 	struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;
938 	struct list_head *tmp, *next;
939 	struct csio_rnode *rn;
940 
941 	list_for_each_safe(tmp, next, &rnhead->sm.sm_list) {
942 		rn = (struct csio_rnode *) tmp;
943 		csio_post_event(&rn->sm, evt);
944 	}
945 }
946 
947 /*
948  * csio_cleanup_rns
949  * @ln - FCOE lnode
950  * Returns - none
951  *
952  * Frees all FCOE rnodes connected with given Lnode.
953  *
954  * This called with hw lock held
955  */
956 static void
957 csio_cleanup_rns(struct csio_lnode *ln)
958 {
959 	struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;
960 	struct list_head *tmp, *next_rn;
961 	struct csio_rnode *rn;
962 
963 	list_for_each_safe(tmp, next_rn, &rnhead->sm.sm_list) {
964 		rn = (struct csio_rnode *) tmp;
965 		csio_put_rnode(ln, rn);
966 	}
967 
968 }
969 
970 /*
971  * csio_post_event_lns
972  * @ln - FCOE lnode
973  * @evt - Given lnode event
974  * Returns - none
975  *
976  * Posts given lnode event to all FCOE lnodes connected with given Lnode.
977  * This routine is invoked when lnode receives LINK_DOWN/DOWN_LINK/CLOSE
978  * event.
979  *
980  * This called with hw lock held
981  */
982 static void
983 csio_post_event_lns(struct csio_lnode *ln, enum csio_ln_ev evt)
984 {
985 	struct list_head *tmp;
986 	struct csio_lnode *cln, *sln;
987 
988 	/* If NPIV lnode, send evt only to that and return */
989 	if (csio_is_npiv_ln(ln)) {
990 		csio_post_event(&ln->sm, evt);
991 		return;
992 	}
993 
994 	sln = ln;
995 	/* Traverse children lnodes list and send evt */
996 	list_for_each(tmp, &sln->cln_head) {
997 		cln = (struct csio_lnode *) tmp;
998 		csio_post_event(&cln->sm, evt);
999 	}
1000 
1001 	/* Send evt to parent lnode */
1002 	csio_post_event(&ln->sm, evt);
1003 }
1004 
1005 /*
1006  * csio_ln_down - Lcoal nport is down
1007  * @ln - FCOE Lnode
1008  * Returns - none
1009  *
1010  * Sends LINK_DOWN events to Lnode and its associated NPIVs lnodes.
1011  *
1012  * This called with hw lock held
1013  */
1014 static void
1015 csio_ln_down(struct csio_lnode *ln)
1016 {
1017 	csio_post_event_lns(ln, CSIO_LNE_LINK_DOWN);
1018 }
1019 
1020 /*
1021  * csio_handle_link_down - Logical Linkdown event.
1022  * @hw - HW module.
1023  * @portid - Physical port number
1024  * @fcfi - FCF index.
1025  * @vnpi - VNP index.
1026  * Returns - none
1027  *
1028  * This event is received from FW, when virtual link goes down between
1029  * Physical port[ENode] and FCF. Lnode and its associated NPIVs lnode hosted on
1030  * this vnpi[VN-Port] will be de-instantiated.
1031  *
1032  * This called with hw lock held
1033  */
1034 static void
1035 csio_handle_link_down(struct csio_hw *hw, uint8_t portid, uint32_t fcfi,
1036 		      uint32_t vnpi)
1037 {
1038 	struct csio_fcf_info *fp;
1039 	struct csio_lnode *ln;
1040 
1041 	/* Lookup lnode based on vnpi */
1042 	ln = csio_ln_lookup_by_vnpi(hw, vnpi);
1043 	if (ln) {
1044 		fp = ln->fcfinfo;
1045 		CSIO_INC_STATS(ln, n_link_down);
1046 
1047 		/*Warn if linkdown received if lnode is not in ready state */
1048 		if (!csio_is_lnode_ready(ln)) {
1049 			csio_ln_warn(ln,
1050 				"warn: FCOE link is already in offline "
1051 				"Ignoring Fcoe linkdown event on portid %d\n",
1052 				 portid);
1053 			CSIO_INC_STATS(ln, n_evt_drop);
1054 			return;
1055 		}
1056 
1057 		/* Verify portid */
1058 		if (fp->portid != portid) {
1059 			csio_ln_warn(ln,
1060 				"warn: FCOE linkdown recv with "
1061 				"invalid port %d\n", portid);
1062 			CSIO_INC_STATS(ln, n_evt_drop);
1063 			return;
1064 		}
1065 
1066 		/* verify fcfi */
1067 		if (ln->fcf_flowid != fcfi) {
1068 			csio_ln_warn(ln,
1069 				"warn: FCOE linkdown recv with "
1070 				"invalid fcfi x%x\n", fcfi);
1071 			CSIO_INC_STATS(ln, n_evt_drop);
1072 			return;
1073 		}
1074 
1075 		csio_info(hw, "Port:%d - FCOE LINK DOWN\n", portid);
1076 
1077 		/* Send LINK_DOWN event to lnode s/m */
1078 		csio_ln_down(ln);
1079 
1080 		return;
1081 	} else {
1082 		csio_warn(hw,
1083 			  "warn: FCOE linkdown recv with invalid vnpi x%x\n",
1084 			  vnpi);
1085 		CSIO_INC_STATS(hw, n_evt_drop);
1086 	}
1087 }
1088 
1089 /*
1090  * csio_is_lnode_ready - Checks FCOE lnode is in ready state.
1091  * @ln: Lnode module
1092  *
1093  * Returns True if FCOE lnode is in ready state.
1094  */
1095 int
1096 csio_is_lnode_ready(struct csio_lnode *ln)
1097 {
1098 	return (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_ready));
1099 }
1100 
1101 /*****************************************************************************/
1102 /* START: Lnode SM                                                           */
1103 /*****************************************************************************/
1104 /*
1105  * csio_lns_uninit - The request in uninit state.
1106  * @ln - FCOE lnode.
1107  * @evt - Event to be processed.
1108  *
1109  * Process the given lnode event which is currently in "uninit" state.
1110  * Invoked with HW lock held.
1111  * Return - none.
1112  */
1113 static void
1114 csio_lns_uninit(struct csio_lnode *ln, enum csio_ln_ev evt)
1115 {
1116 	struct csio_hw *hw = csio_lnode_to_hw(ln);
1117 	struct csio_lnode *rln = hw->rln;
1118 	int rv;
1119 
1120 	CSIO_INC_STATS(ln, n_evt_sm[evt]);
1121 	switch (evt) {
1122 	case CSIO_LNE_LINKUP:
1123 		csio_set_state(&ln->sm, csio_lns_online);
1124 		/* Read FCF only for physical lnode */
1125 		if (csio_is_phys_ln(ln)) {
1126 			rv = csio_ln_read_fcf_entry(ln,
1127 					csio_ln_read_fcf_cbfn);
1128 			if (rv != 0) {
1129 				/* TODO: Send HW RESET event */
1130 				CSIO_INC_STATS(ln, n_err);
1131 				break;
1132 			}
1133 
1134 			/* Add FCF record */
1135 			list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead);
1136 		}
1137 
1138 		rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn);
1139 		if (rv != 0) {
1140 			/* TODO: Send HW RESET event */
1141 			CSIO_INC_STATS(ln, n_err);
1142 		}
1143 		break;
1144 
1145 	case CSIO_LNE_DOWN_LINK:
1146 		break;
1147 
1148 	default:
1149 		csio_ln_dbg(ln,
1150 			    "unexp ln event %d recv from did:x%x in "
1151 			    "ln state[uninit].\n", evt, ln->nport_id);
1152 		CSIO_INC_STATS(ln, n_evt_unexp);
1153 		break;
1154 	} /* switch event */
1155 }
1156 
1157 /*
1158  * csio_lns_online - The request in online state.
1159  * @ln - FCOE lnode.
1160  * @evt - Event to be processed.
1161  *
1162  * Process the given lnode event which is currently in "online" state.
1163  * Invoked with HW lock held.
1164  * Return - none.
1165  */
1166 static void
1167 csio_lns_online(struct csio_lnode *ln, enum csio_ln_ev evt)
1168 {
1169 	struct csio_hw *hw = csio_lnode_to_hw(ln);
1170 
1171 	CSIO_INC_STATS(ln, n_evt_sm[evt]);
1172 	switch (evt) {
1173 	case CSIO_LNE_LINKUP:
1174 		csio_ln_warn(ln,
1175 			     "warn: FCOE link is up already "
1176 			     "Ignoring linkup on port:%d\n", ln->portid);
1177 		CSIO_INC_STATS(ln, n_evt_drop);
1178 		break;
1179 
1180 	case CSIO_LNE_FAB_INIT_DONE:
1181 		csio_set_state(&ln->sm, csio_lns_ready);
1182 
1183 		spin_unlock_irq(&hw->lock);
1184 		csio_lnode_async_event(ln, CSIO_LN_FC_LINKUP);
1185 		spin_lock_irq(&hw->lock);
1186 
1187 		break;
1188 
1189 	case CSIO_LNE_LINK_DOWN:
1190 	case CSIO_LNE_DOWN_LINK:
1191 		csio_set_state(&ln->sm, csio_lns_uninit);
1192 		if (csio_is_phys_ln(ln)) {
1193 			/* Remove FCF entry */
1194 			list_del_init(&ln->fcfinfo->list);
1195 		}
1196 		break;
1197 
1198 	default:
1199 		csio_ln_dbg(ln,
1200 			    "unexp ln event %d recv from did:x%x in "
1201 			    "ln state[uninit].\n", evt, ln->nport_id);
1202 		CSIO_INC_STATS(ln, n_evt_unexp);
1203 
1204 		break;
1205 	} /* switch event */
1206 }
1207 
1208 /*
1209  * csio_lns_ready - The request in ready state.
1210  * @ln - FCOE lnode.
1211  * @evt - Event to be processed.
1212  *
1213  * Process the given lnode event which is currently in "ready" state.
1214  * Invoked with HW lock held.
1215  * Return - none.
1216  */
1217 static void
1218 csio_lns_ready(struct csio_lnode *ln, enum csio_ln_ev evt)
1219 {
1220 	struct csio_hw *hw = csio_lnode_to_hw(ln);
1221 
1222 	CSIO_INC_STATS(ln, n_evt_sm[evt]);
1223 	switch (evt) {
1224 	case CSIO_LNE_FAB_INIT_DONE:
1225 		csio_ln_dbg(ln,
1226 			    "ignoring event %d recv from did x%x"
1227 			    "in ln state[ready].\n", evt, ln->nport_id);
1228 		CSIO_INC_STATS(ln, n_evt_drop);
1229 		break;
1230 
1231 	case CSIO_LNE_LINK_DOWN:
1232 		csio_set_state(&ln->sm, csio_lns_offline);
1233 		csio_post_event_rns(ln, CSIO_RNFE_DOWN);
1234 
1235 		spin_unlock_irq(&hw->lock);
1236 		csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN);
1237 		spin_lock_irq(&hw->lock);
1238 
1239 		if (csio_is_phys_ln(ln)) {
1240 			/* Remove FCF entry */
1241 			list_del_init(&ln->fcfinfo->list);
1242 		}
1243 		break;
1244 
1245 	case CSIO_LNE_DOWN_LINK:
1246 		csio_set_state(&ln->sm, csio_lns_offline);
1247 		csio_post_event_rns(ln, CSIO_RNFE_DOWN);
1248 
1249 		/* Host need to issue aborts in case if FW has not returned
1250 		 * WRs with status "ABORTED"
1251 		 */
1252 		spin_unlock_irq(&hw->lock);
1253 		csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN);
1254 		spin_lock_irq(&hw->lock);
1255 
1256 		if (csio_is_phys_ln(ln)) {
1257 			/* Remove FCF entry */
1258 			list_del_init(&ln->fcfinfo->list);
1259 		}
1260 		break;
1261 
1262 	case CSIO_LNE_CLOSE:
1263 		csio_set_state(&ln->sm, csio_lns_uninit);
1264 		csio_post_event_rns(ln, CSIO_RNFE_CLOSE);
1265 		break;
1266 
1267 	case CSIO_LNE_LOGO:
1268 		csio_set_state(&ln->sm, csio_lns_offline);
1269 		csio_post_event_rns(ln, CSIO_RNFE_DOWN);
1270 		break;
1271 
1272 	default:
1273 		csio_ln_dbg(ln,
1274 			    "unexp ln event %d recv from did:x%x in "
1275 			    "ln state[uninit].\n", evt, ln->nport_id);
1276 		CSIO_INC_STATS(ln, n_evt_unexp);
1277 		CSIO_DB_ASSERT(0);
1278 		break;
1279 	} /* switch event */
1280 }
1281 
1282 /*
1283  * csio_lns_offline - The request in offline state.
1284  * @ln - FCOE lnode.
1285  * @evt - Event to be processed.
1286  *
1287  * Process the given lnode event which is currently in "offline" state.
1288  * Invoked with HW lock held.
1289  * Return - none.
1290  */
1291 static void
1292 csio_lns_offline(struct csio_lnode *ln, enum csio_ln_ev evt)
1293 {
1294 	struct csio_hw *hw = csio_lnode_to_hw(ln);
1295 	struct csio_lnode *rln = hw->rln;
1296 	int rv;
1297 
1298 	CSIO_INC_STATS(ln, n_evt_sm[evt]);
1299 	switch (evt) {
1300 	case CSIO_LNE_LINKUP:
1301 		csio_set_state(&ln->sm, csio_lns_online);
1302 		/* Read FCF only for physical lnode */
1303 		if (csio_is_phys_ln(ln)) {
1304 			rv = csio_ln_read_fcf_entry(ln,
1305 					csio_ln_read_fcf_cbfn);
1306 			if (rv != 0) {
1307 				/* TODO: Send HW RESET event */
1308 				CSIO_INC_STATS(ln, n_err);
1309 				break;
1310 			}
1311 
1312 			/* Add FCF record */
1313 			list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead);
1314 		}
1315 
1316 		rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn);
1317 		if (rv != 0) {
1318 			/* TODO: Send HW RESET event */
1319 			CSIO_INC_STATS(ln, n_err);
1320 		}
1321 		break;
1322 
1323 	case CSIO_LNE_LINK_DOWN:
1324 	case CSIO_LNE_DOWN_LINK:
1325 	case CSIO_LNE_LOGO:
1326 		csio_ln_dbg(ln,
1327 			    "ignoring event %d recv from did x%x"
1328 			    "in ln state[offline].\n", evt, ln->nport_id);
1329 		CSIO_INC_STATS(ln, n_evt_drop);
1330 		break;
1331 
1332 	case CSIO_LNE_CLOSE:
1333 		csio_set_state(&ln->sm, csio_lns_uninit);
1334 		csio_post_event_rns(ln, CSIO_RNFE_CLOSE);
1335 		break;
1336 
1337 	default:
1338 		csio_ln_dbg(ln,
1339 			    "unexp ln event %d recv from did:x%x in "
1340 			    "ln state[offline]\n", evt, ln->nport_id);
1341 		CSIO_INC_STATS(ln, n_evt_unexp);
1342 		CSIO_DB_ASSERT(0);
1343 		break;
1344 	} /* switch event */
1345 }
1346 
1347 /*****************************************************************************/
1348 /* END: Lnode SM                                                             */
1349 /*****************************************************************************/
1350 
1351 static void
1352 csio_free_fcfinfo(struct kref *kref)
1353 {
1354 	struct csio_fcf_info *fcfinfo = container_of(kref,
1355 						struct csio_fcf_info, kref);
1356 	kfree(fcfinfo);
1357 }
1358 
1359 /* Helper routines for attributes  */
1360 /*
1361  * csio_lnode_state_to_str - Get current state of FCOE lnode.
1362  * @ln - lnode
1363  * @str - state of lnode.
1364  *
1365  */
1366 void
1367 csio_lnode_state_to_str(struct csio_lnode *ln, int8_t *str)
1368 {
1369 	if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_uninit)) {
1370 		strcpy(str, "UNINIT");
1371 		return;
1372 	}
1373 	if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_ready)) {
1374 		strcpy(str, "READY");
1375 		return;
1376 	}
1377 	if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_offline)) {
1378 		strcpy(str, "OFFLINE");
1379 		return;
1380 	}
1381 	strcpy(str, "UNKNOWN");
1382 } /* csio_lnode_state_to_str */
1383 
1384 
1385 int
1386 csio_get_phy_port_stats(struct csio_hw *hw, uint8_t portid,
1387 			struct fw_fcoe_port_stats *port_stats)
1388 {
1389 	struct csio_mb  *mbp;
1390 	struct fw_fcoe_port_cmd_params portparams;
1391 	enum fw_retval retval;
1392 	int idx;
1393 
1394 	mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1395 	if (!mbp) {
1396 		csio_err(hw, "FCoE FCF PARAMS command out of memory!\n");
1397 		return -EINVAL;
1398 	}
1399 	portparams.portid = portid;
1400 
1401 	for (idx = 1; idx <= 3; idx++) {
1402 		portparams.idx = (idx-1)*6 + 1;
1403 		portparams.nstats = 6;
1404 		if (idx == 3)
1405 			portparams.nstats = 4;
1406 		csio_fcoe_read_portparams_init_mb(hw, mbp, CSIO_MB_DEFAULT_TMO,
1407 							&portparams, NULL);
1408 		if (csio_mb_issue(hw, mbp)) {
1409 			csio_err(hw, "Issue of FCoE port params failed!\n");
1410 			mempool_free(mbp, hw->mb_mempool);
1411 			return -EINVAL;
1412 		}
1413 		csio_mb_process_portparams_rsp(hw, mbp, &retval,
1414 						&portparams, port_stats);
1415 	}
1416 
1417 	mempool_free(mbp, hw->mb_mempool);
1418 	return 0;
1419 }
1420 
1421 /*
1422  * csio_ln_mgmt_wr_handler -Mgmt Work Request handler.
1423  * @wr - WR.
1424  * @len - WR len.
1425  * This handler is invoked when an outstanding mgmt WR is completed.
1426  * Its invoked in the context of FW event worker thread for every
1427  * mgmt event received.
1428  * Return - none.
1429  */
1430 
1431 static void
1432 csio_ln_mgmt_wr_handler(struct csio_hw *hw, void *wr, uint32_t len)
1433 {
1434 	struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw);
1435 	struct csio_ioreq *io_req = NULL;
1436 	struct fw_fcoe_els_ct_wr *wr_cmd;
1437 
1438 
1439 	wr_cmd = (struct fw_fcoe_els_ct_wr *) wr;
1440 
1441 	if (len < sizeof(struct fw_fcoe_els_ct_wr)) {
1442 		csio_err(mgmtm->hw,
1443 			 "Invalid ELS CT WR length recvd, len:%x\n", len);
1444 		mgmtm->stats.n_err++;
1445 		return;
1446 	}
1447 
1448 	io_req = (struct csio_ioreq *) ((uintptr_t) wr_cmd->cookie);
1449 	io_req->wr_status = csio_wr_status(wr_cmd);
1450 
1451 	/* lookup ioreq exists in our active Q */
1452 	spin_lock_irq(&hw->lock);
1453 	if (csio_mgmt_req_lookup(mgmtm, io_req) != 0) {
1454 		csio_err(mgmtm->hw,
1455 			"Error- Invalid IO handle recv in WR. handle: %p\n",
1456 			io_req);
1457 		mgmtm->stats.n_err++;
1458 		spin_unlock_irq(&hw->lock);
1459 		return;
1460 	}
1461 
1462 	mgmtm = csio_hw_to_mgmtm(hw);
1463 
1464 	/* Dequeue from active queue */
1465 	list_del_init(&io_req->sm.sm_list);
1466 	mgmtm->stats.n_active--;
1467 	spin_unlock_irq(&hw->lock);
1468 
1469 	/* io_req will be freed by completion handler */
1470 	if (io_req->io_cbfn)
1471 		io_req->io_cbfn(hw, io_req);
1472 }
1473 
1474 /**
1475  * csio_fcoe_fwevt_handler - Event handler for Firmware FCoE events.
1476  * @hw:		HW module
1477  * @cpl_op:	CPL opcode
1478  * @cmd:	FW cmd/WR.
1479  *
1480  * Process received FCoE cmd/WR event from FW.
1481  */
1482 void
1483 csio_fcoe_fwevt_handler(struct csio_hw *hw, __u8 cpl_op, __be64 *cmd)
1484 {
1485 	struct csio_lnode *ln;
1486 	struct csio_rnode *rn;
1487 	uint8_t portid, opcode = *(uint8_t *)cmd;
1488 	struct fw_fcoe_link_cmd *lcmd;
1489 	struct fw_wr_hdr *wr;
1490 	struct fw_rdev_wr *rdev_wr;
1491 	enum fw_fcoe_link_status lstatus;
1492 	uint32_t fcfi, rdev_flowid, vnpi;
1493 	enum csio_ln_ev evt;
1494 
1495 	if (cpl_op == CPL_FW6_MSG && opcode == FW_FCOE_LINK_CMD) {
1496 
1497 		lcmd = (struct fw_fcoe_link_cmd *)cmd;
1498 		lstatus = lcmd->lstatus;
1499 		portid = FW_FCOE_LINK_CMD_PORTID_GET(
1500 					ntohl(lcmd->op_to_portid));
1501 		fcfi = FW_FCOE_LINK_CMD_FCFI_GET(ntohl(lcmd->sub_opcode_fcfi));
1502 		vnpi = FW_FCOE_LINK_CMD_VNPI_GET(ntohl(lcmd->vnpi_pkd));
1503 
1504 		if (lstatus == FCOE_LINKUP) {
1505 
1506 			/* HW lock here */
1507 			spin_lock_irq(&hw->lock);
1508 			csio_handle_link_up(hw, portid, fcfi, vnpi);
1509 			spin_unlock_irq(&hw->lock);
1510 			/* HW un lock here */
1511 
1512 		} else if (lstatus == FCOE_LINKDOWN) {
1513 
1514 			/* HW lock here */
1515 			spin_lock_irq(&hw->lock);
1516 			csio_handle_link_down(hw, portid, fcfi, vnpi);
1517 			spin_unlock_irq(&hw->lock);
1518 			/* HW un lock here */
1519 		} else {
1520 			csio_warn(hw, "Unexpected FCOE LINK status:0x%x\n",
1521 				  lcmd->lstatus);
1522 			CSIO_INC_STATS(hw, n_cpl_unexp);
1523 		}
1524 	} else if (cpl_op == CPL_FW6_PLD) {
1525 		wr = (struct fw_wr_hdr *) (cmd + 4);
1526 		if (FW_WR_OP_G(be32_to_cpu(wr->hi))
1527 			== FW_RDEV_WR) {
1528 
1529 			rdev_wr = (struct fw_rdev_wr *) (cmd + 4);
1530 
1531 			rdev_flowid = FW_RDEV_WR_FLOWID_GET(
1532 					ntohl(rdev_wr->alloc_to_len16));
1533 			vnpi = FW_RDEV_WR_ASSOC_FLOWID_GET(
1534 				    ntohl(rdev_wr->flags_to_assoc_flowid));
1535 
1536 			csio_dbg(hw,
1537 				"FW_RDEV_WR: flowid:x%x ev_cause:x%x "
1538 				"vnpi:0x%x\n", rdev_flowid,
1539 				rdev_wr->event_cause, vnpi);
1540 
1541 			if (rdev_wr->protocol != PROT_FCOE) {
1542 				csio_err(hw,
1543 					"FW_RDEV_WR: invalid proto:x%x "
1544 					"received with flowid:x%x\n",
1545 					rdev_wr->protocol,
1546 					rdev_flowid);
1547 				CSIO_INC_STATS(hw, n_evt_drop);
1548 				return;
1549 			}
1550 
1551 			/* HW lock here */
1552 			spin_lock_irq(&hw->lock);
1553 			ln = csio_ln_lookup_by_vnpi(hw, vnpi);
1554 			if (!ln) {
1555 				csio_err(hw,
1556 					"FW_DEV_WR: invalid vnpi:x%x received "
1557 					"with flowid:x%x\n", vnpi, rdev_flowid);
1558 				CSIO_INC_STATS(hw, n_evt_drop);
1559 				goto out_pld;
1560 			}
1561 
1562 			rn = csio_confirm_rnode(ln, rdev_flowid,
1563 					&rdev_wr->u.fcoe_rdev);
1564 			if (!rn) {
1565 				csio_ln_dbg(ln,
1566 					"Failed to confirm rnode "
1567 					"for flowid:x%x\n", rdev_flowid);
1568 				CSIO_INC_STATS(hw, n_evt_drop);
1569 				goto out_pld;
1570 			}
1571 
1572 			/* save previous event for debugging */
1573 			ln->prev_evt = ln->cur_evt;
1574 			ln->cur_evt = rdev_wr->event_cause;
1575 			CSIO_INC_STATS(ln, n_evt_fw[rdev_wr->event_cause]);
1576 
1577 			/* Translate all the fabric events to lnode SM events */
1578 			evt = CSIO_FWE_TO_LNE(rdev_wr->event_cause);
1579 			if (evt) {
1580 				csio_ln_dbg(ln,
1581 					"Posting event to lnode event:%d "
1582 					"cause:%d flowid:x%x\n", evt,
1583 					rdev_wr->event_cause, rdev_flowid);
1584 				csio_post_event(&ln->sm, evt);
1585 			}
1586 
1587 			/* Handover event to rn SM here. */
1588 			csio_rnode_fwevt_handler(rn, rdev_wr->event_cause);
1589 out_pld:
1590 			spin_unlock_irq(&hw->lock);
1591 			return;
1592 		} else {
1593 			csio_warn(hw, "unexpected WR op(0x%x) recv\n",
1594 				  FW_WR_OP_G(be32_to_cpu((wr->hi))));
1595 			CSIO_INC_STATS(hw, n_cpl_unexp);
1596 		}
1597 	} else if (cpl_op == CPL_FW6_MSG) {
1598 		wr = (struct fw_wr_hdr *) (cmd);
1599 		if (FW_WR_OP_G(be32_to_cpu(wr->hi)) == FW_FCOE_ELS_CT_WR) {
1600 			csio_ln_mgmt_wr_handler(hw, wr,
1601 					sizeof(struct fw_fcoe_els_ct_wr));
1602 		} else {
1603 			csio_warn(hw, "unexpected WR op(0x%x) recv\n",
1604 				  FW_WR_OP_G(be32_to_cpu((wr->hi))));
1605 			CSIO_INC_STATS(hw, n_cpl_unexp);
1606 		}
1607 	} else {
1608 		csio_warn(hw, "unexpected CPL op(0x%x) recv\n", opcode);
1609 		CSIO_INC_STATS(hw, n_cpl_unexp);
1610 	}
1611 }
1612 
1613 /**
1614  * csio_lnode_start - Kickstart lnode discovery.
1615  * @ln:		lnode
1616  *
1617  * This routine kickstarts the discovery by issuing an FCOE_LINK (up) command.
1618  */
1619 int
1620 csio_lnode_start(struct csio_lnode *ln)
1621 {
1622 	int rv = 0;
1623 	if (csio_is_phys_ln(ln) && !(ln->flags & CSIO_LNF_LINK_ENABLE)) {
1624 		rv = csio_fcoe_enable_link(ln, 1);
1625 		ln->flags |= CSIO_LNF_LINK_ENABLE;
1626 	}
1627 
1628 	return rv;
1629 }
1630 
1631 /**
1632  * csio_lnode_stop - Stop the lnode.
1633  * @ln:		lnode
1634  *
1635  * This routine is invoked by HW module to stop lnode and its associated NPIV
1636  * lnodes.
1637  */
1638 void
1639 csio_lnode_stop(struct csio_lnode *ln)
1640 {
1641 	csio_post_event_lns(ln, CSIO_LNE_DOWN_LINK);
1642 	if (csio_is_phys_ln(ln) && (ln->flags & CSIO_LNF_LINK_ENABLE)) {
1643 		csio_fcoe_enable_link(ln, 0);
1644 		ln->flags &= ~CSIO_LNF_LINK_ENABLE;
1645 	}
1646 	csio_ln_dbg(ln, "stopping ln :%p\n", ln);
1647 }
1648 
1649 /**
1650  * csio_lnode_close - Close an lnode.
1651  * @ln:		lnode
1652  *
1653  * This routine is invoked by HW module to close an lnode and its
1654  * associated NPIV lnodes. Lnode and its associated NPIV lnodes are
1655  * set to uninitialized state.
1656  */
1657 void
1658 csio_lnode_close(struct csio_lnode *ln)
1659 {
1660 	csio_post_event_lns(ln, CSIO_LNE_CLOSE);
1661 	if (csio_is_phys_ln(ln))
1662 		ln->vnp_flowid = CSIO_INVALID_IDX;
1663 
1664 	csio_ln_dbg(ln, "closed ln :%p\n", ln);
1665 }
1666 
1667 /*
1668  * csio_ln_prep_ecwr - Prepare ELS/CT WR.
1669  * @io_req - IO request.
1670  * @wr_len - WR len
1671  * @immd_len - WR immediate data
1672  * @sub_op - Sub opcode
1673  * @sid - source portid.
1674  * @did - destination portid
1675  * @flow_id - flowid
1676  * @fw_wr - ELS/CT WR to be prepared.
1677  * Returns: 0 - on success
1678  */
1679 static int
1680 csio_ln_prep_ecwr(struct csio_ioreq *io_req, uint32_t wr_len,
1681 		      uint32_t immd_len, uint8_t sub_op, uint32_t sid,
1682 		      uint32_t did, uint32_t flow_id, uint8_t *fw_wr)
1683 {
1684 	struct fw_fcoe_els_ct_wr *wr;
1685 	__be32 port_id;
1686 
1687 	wr  = (struct fw_fcoe_els_ct_wr *)fw_wr;
1688 	wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_FCOE_ELS_CT_WR) |
1689 				     FW_FCOE_ELS_CT_WR_IMMDLEN(immd_len));
1690 
1691 	wr_len =  DIV_ROUND_UP(wr_len, 16);
1692 	wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(flow_id) |
1693 				       FW_WR_LEN16_V(wr_len));
1694 	wr->els_ct_type = sub_op;
1695 	wr->ctl_pri = 0;
1696 	wr->cp_en_class = 0;
1697 	wr->cookie = io_req->fw_handle;
1698 	wr->iqid = cpu_to_be16(csio_q_physiqid(
1699 					io_req->lnode->hwp, io_req->iq_idx));
1700 	wr->fl_to_sp =  FW_FCOE_ELS_CT_WR_SP(1);
1701 	wr->tmo_val = (uint8_t) io_req->tmo;
1702 	port_id = htonl(sid);
1703 	memcpy(wr->l_id, PORT_ID_PTR(port_id), 3);
1704 	port_id = htonl(did);
1705 	memcpy(wr->r_id, PORT_ID_PTR(port_id), 3);
1706 
1707 	/* Prepare RSP SGL */
1708 	wr->rsp_dmalen = cpu_to_be32(io_req->dma_buf.len);
1709 	wr->rsp_dmaaddr = cpu_to_be64(io_req->dma_buf.paddr);
1710 	return 0;
1711 }
1712 
1713 /*
1714  * csio_ln_mgmt_submit_wr - Post elsct work request.
1715  * @mgmtm - mgmtm
1716  * @io_req - io request.
1717  * @sub_op - ELS or CT request type
1718  * @pld - Dma Payload buffer
1719  * @pld_len - Payload len
1720  * Prepares ELSCT Work request and sents it to FW.
1721  * Returns: 0 - on success
1722  */
1723 static int
1724 csio_ln_mgmt_submit_wr(struct csio_mgmtm *mgmtm, struct csio_ioreq *io_req,
1725 		uint8_t sub_op, struct csio_dma_buf *pld,
1726 		uint32_t pld_len)
1727 {
1728 	struct csio_wr_pair wrp;
1729 	struct csio_lnode *ln = io_req->lnode;
1730 	struct csio_rnode *rn = io_req->rnode;
1731 	struct	csio_hw	*hw = mgmtm->hw;
1732 	uint8_t fw_wr[64];
1733 	struct ulptx_sgl dsgl;
1734 	uint32_t wr_size = 0;
1735 	uint8_t im_len = 0;
1736 	uint32_t wr_off = 0;
1737 
1738 	int ret = 0;
1739 
1740 	/* Calculate WR Size for this ELS REQ */
1741 	wr_size = sizeof(struct fw_fcoe_els_ct_wr);
1742 
1743 	/* Send as immediate data if pld < 256 */
1744 	if (pld_len < 256) {
1745 		wr_size += ALIGN(pld_len, 8);
1746 		im_len = (uint8_t)pld_len;
1747 	} else
1748 		wr_size += sizeof(struct ulptx_sgl);
1749 
1750 	/* Roundup WR size in units of 16 bytes */
1751 	wr_size = ALIGN(wr_size, 16);
1752 
1753 	/* Get WR to send ELS REQ */
1754 	ret = csio_wr_get(hw, mgmtm->eq_idx, wr_size, &wrp);
1755 	if (ret != 0) {
1756 		csio_err(hw, "Failed to get WR for ec_req %p ret:%d\n",
1757 			io_req, ret);
1758 		return ret;
1759 	}
1760 
1761 	/* Prepare Generic WR used by all ELS/CT cmd */
1762 	csio_ln_prep_ecwr(io_req, wr_size, im_len, sub_op,
1763 				ln->nport_id, rn->nport_id,
1764 				csio_rn_flowid(rn),
1765 				&fw_wr[0]);
1766 
1767 	/* Copy ELS/CT WR CMD */
1768 	csio_wr_copy_to_wrp(&fw_wr[0], &wrp, wr_off,
1769 			sizeof(struct fw_fcoe_els_ct_wr));
1770 	wr_off += sizeof(struct fw_fcoe_els_ct_wr);
1771 
1772 	/* Copy payload to Immediate section of WR */
1773 	if (im_len)
1774 		csio_wr_copy_to_wrp(pld->vaddr, &wrp, wr_off, im_len);
1775 	else {
1776 		/* Program DSGL to dma payload */
1777 		dsgl.cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) |
1778 					ULPTX_MORE_F | ULPTX_NSGE_V(1));
1779 		dsgl.len0 = cpu_to_be32(pld_len);
1780 		dsgl.addr0 = cpu_to_be64(pld->paddr);
1781 		csio_wr_copy_to_wrp(&dsgl, &wrp, ALIGN(wr_off, 8),
1782 				   sizeof(struct ulptx_sgl));
1783 	}
1784 
1785 	/* Issue work request to xmit ELS/CT req to FW */
1786 	csio_wr_issue(mgmtm->hw, mgmtm->eq_idx, false);
1787 	return ret;
1788 }
1789 
1790 /*
1791  * csio_ln_mgmt_submit_req - Submit FCOE Mgmt request.
1792  * @io_req - IO Request
1793  * @io_cbfn - Completion handler.
1794  * @req_type - ELS or CT request type
1795  * @pld - Dma Payload buffer
1796  * @pld_len - Payload len
1797  *
1798  *
1799  * This API used submit managment ELS/CT request.
1800  * This called with hw lock held
1801  * Returns: 0 - on success
1802  *	    -ENOMEM	- on error.
1803  */
1804 static int
1805 csio_ln_mgmt_submit_req(struct csio_ioreq *io_req,
1806 		void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *),
1807 		enum fcoe_cmn_type req_type, struct csio_dma_buf *pld,
1808 		uint32_t pld_len)
1809 {
1810 	struct csio_hw *hw = csio_lnode_to_hw(io_req->lnode);
1811 	struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw);
1812 	int rv;
1813 
1814 	BUG_ON(pld_len > pld->len);
1815 
1816 	io_req->io_cbfn = io_cbfn;	/* Upper layer callback handler */
1817 	io_req->fw_handle = (uintptr_t) (io_req);
1818 	io_req->eq_idx = mgmtm->eq_idx;
1819 	io_req->iq_idx = mgmtm->iq_idx;
1820 
1821 	rv = csio_ln_mgmt_submit_wr(mgmtm, io_req, req_type, pld, pld_len);
1822 	if (rv == 0) {
1823 		list_add_tail(&io_req->sm.sm_list, &mgmtm->active_q);
1824 		mgmtm->stats.n_active++;
1825 	}
1826 	return rv;
1827 }
1828 
1829 /*
1830  * csio_ln_fdmi_init - FDMI Init entry point.
1831  * @ln: lnode
1832  */
1833 static int
1834 csio_ln_fdmi_init(struct csio_lnode *ln)
1835 {
1836 	struct csio_hw *hw = csio_lnode_to_hw(ln);
1837 	struct csio_dma_buf	*dma_buf;
1838 
1839 	/* Allocate MGMT request required for FDMI */
1840 	ln->mgmt_req = kzalloc(sizeof(struct csio_ioreq), GFP_KERNEL);
1841 	if (!ln->mgmt_req) {
1842 		csio_ln_err(ln, "Failed to alloc ioreq for FDMI\n");
1843 		CSIO_INC_STATS(hw, n_err_nomem);
1844 		return -ENOMEM;
1845 	}
1846 
1847 	/* Allocate Dma buffers for FDMI response Payload */
1848 	dma_buf = &ln->mgmt_req->dma_buf;
1849 	dma_buf->len = 2048;
1850 	dma_buf->vaddr = dma_alloc_coherent(&hw->pdev->dev, dma_buf->len,
1851 						&dma_buf->paddr, GFP_KERNEL);
1852 	if (!dma_buf->vaddr) {
1853 		csio_err(hw, "Failed to alloc DMA buffer for FDMI!\n");
1854 		kfree(ln->mgmt_req);
1855 		ln->mgmt_req = NULL;
1856 		return -ENOMEM;
1857 	}
1858 
1859 	ln->flags |= CSIO_LNF_FDMI_ENABLE;
1860 	return 0;
1861 }
1862 
1863 /*
1864  * csio_ln_fdmi_exit - FDMI exit entry point.
1865  * @ln: lnode
1866  */
1867 static int
1868 csio_ln_fdmi_exit(struct csio_lnode *ln)
1869 {
1870 	struct csio_dma_buf *dma_buf;
1871 	struct csio_hw *hw = csio_lnode_to_hw(ln);
1872 
1873 	if (!ln->mgmt_req)
1874 		return 0;
1875 
1876 	dma_buf = &ln->mgmt_req->dma_buf;
1877 	if (dma_buf->vaddr)
1878 		dma_free_coherent(&hw->pdev->dev, dma_buf->len, dma_buf->vaddr,
1879 				    dma_buf->paddr);
1880 
1881 	kfree(ln->mgmt_req);
1882 	return 0;
1883 }
1884 
1885 int
1886 csio_scan_done(struct csio_lnode *ln, unsigned long ticks,
1887 		unsigned long time, unsigned long max_scan_ticks,
1888 		unsigned long delta_scan_ticks)
1889 {
1890 	int rv = 0;
1891 
1892 	if (time >= max_scan_ticks)
1893 		return 1;
1894 
1895 	if (!ln->tgt_scan_tick)
1896 		ln->tgt_scan_tick = ticks;
1897 
1898 	if (((ticks - ln->tgt_scan_tick) >= delta_scan_ticks)) {
1899 		if (!ln->last_scan_ntgts)
1900 			ln->last_scan_ntgts = ln->n_scsi_tgts;
1901 		else {
1902 			if (ln->last_scan_ntgts == ln->n_scsi_tgts)
1903 				return 1;
1904 
1905 			ln->last_scan_ntgts = ln->n_scsi_tgts;
1906 		}
1907 		ln->tgt_scan_tick = ticks;
1908 	}
1909 	return rv;
1910 }
1911 
1912 /*
1913  * csio_notify_lnodes:
1914  * @hw: HW module
1915  * @note: Notification
1916  *
1917  * Called from the HW SM to fan out notifications to the
1918  * Lnode SM. Since the HW SM is entered with lock held,
1919  * there is no need to hold locks here.
1920  *
1921  */
1922 void
1923 csio_notify_lnodes(struct csio_hw *hw, enum csio_ln_notify note)
1924 {
1925 	struct list_head *tmp;
1926 	struct csio_lnode *ln;
1927 
1928 	csio_dbg(hw, "Notifying all nodes of event %d\n", note);
1929 
1930 	/* Traverse children lnodes list and send evt */
1931 	list_for_each(tmp, &hw->sln_head) {
1932 		ln = (struct csio_lnode *) tmp;
1933 
1934 		switch (note) {
1935 		case CSIO_LN_NOTIFY_HWREADY:
1936 			csio_lnode_start(ln);
1937 			break;
1938 
1939 		case CSIO_LN_NOTIFY_HWRESET:
1940 		case CSIO_LN_NOTIFY_HWREMOVE:
1941 			csio_lnode_close(ln);
1942 			break;
1943 
1944 		case CSIO_LN_NOTIFY_HWSTOP:
1945 			csio_lnode_stop(ln);
1946 			break;
1947 
1948 		default:
1949 			break;
1950 
1951 		}
1952 	}
1953 }
1954 
1955 /*
1956  * csio_disable_lnodes:
1957  * @hw: HW module
1958  * @portid:port id
1959  * @disable: disable/enable flag.
1960  * If disable=1, disables all lnode hosted on given physical port.
1961  * otherwise enables all the lnodes on given phsysical port.
1962  * This routine need to called with hw lock held.
1963  */
1964 void
1965 csio_disable_lnodes(struct csio_hw *hw, uint8_t portid, bool disable)
1966 {
1967 	struct list_head *tmp;
1968 	struct csio_lnode *ln;
1969 
1970 	csio_dbg(hw, "Notifying event to all nodes of port:%d\n", portid);
1971 
1972 	/* Traverse sibling lnodes list and send evt */
1973 	list_for_each(tmp, &hw->sln_head) {
1974 		ln = (struct csio_lnode *) tmp;
1975 		if (ln->portid != portid)
1976 			continue;
1977 
1978 		if (disable)
1979 			csio_lnode_stop(ln);
1980 		else
1981 			csio_lnode_start(ln);
1982 	}
1983 }
1984 
1985 /*
1986  * csio_ln_init - Initialize an lnode.
1987  * @ln:		lnode
1988  *
1989  */
1990 static int
1991 csio_ln_init(struct csio_lnode *ln)
1992 {
1993 	int rv = -EINVAL;
1994 	struct csio_lnode *pln;
1995 	struct csio_hw *hw = csio_lnode_to_hw(ln);
1996 
1997 	csio_init_state(&ln->sm, csio_lns_uninit);
1998 	ln->vnp_flowid = CSIO_INVALID_IDX;
1999 	ln->fcf_flowid = CSIO_INVALID_IDX;
2000 
2001 	if (csio_is_root_ln(ln)) {
2002 
2003 		/* This is the lnode used during initialization */
2004 
2005 		ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info), GFP_KERNEL);
2006 		if (!ln->fcfinfo) {
2007 			csio_ln_err(ln, "Failed to alloc FCF record\n");
2008 			CSIO_INC_STATS(hw, n_err_nomem);
2009 			goto err;
2010 		}
2011 
2012 		INIT_LIST_HEAD(&ln->fcf_lsthead);
2013 		kref_init(&ln->fcfinfo->kref);
2014 
2015 		if (csio_fdmi_enable && csio_ln_fdmi_init(ln))
2016 			goto err;
2017 
2018 	} else { /* Either a non-root physical or a virtual lnode */
2019 
2020 		/*
2021 		 * THe rest is common for non-root physical and NPIV lnodes.
2022 		 * Just get references to all other modules
2023 		 */
2024 
2025 		if (csio_is_npiv_ln(ln)) {
2026 			/* NPIV */
2027 			pln = csio_parent_lnode(ln);
2028 			kref_get(&pln->fcfinfo->kref);
2029 			ln->fcfinfo = pln->fcfinfo;
2030 		} else {
2031 			/* Another non-root physical lnode (FCF) */
2032 			ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info),
2033 								GFP_KERNEL);
2034 			if (!ln->fcfinfo) {
2035 				csio_ln_err(ln, "Failed to alloc FCF info\n");
2036 				CSIO_INC_STATS(hw, n_err_nomem);
2037 				goto err;
2038 			}
2039 
2040 			kref_init(&ln->fcfinfo->kref);
2041 
2042 			if (csio_fdmi_enable && csio_ln_fdmi_init(ln))
2043 				goto err;
2044 		}
2045 
2046 	} /* if (!csio_is_root_ln(ln)) */
2047 
2048 	return 0;
2049 err:
2050 	return rv;
2051 }
2052 
2053 static void
2054 csio_ln_exit(struct csio_lnode *ln)
2055 {
2056 	struct csio_lnode *pln;
2057 
2058 	csio_cleanup_rns(ln);
2059 	if (csio_is_npiv_ln(ln)) {
2060 		pln = csio_parent_lnode(ln);
2061 		kref_put(&pln->fcfinfo->kref, csio_free_fcfinfo);
2062 	} else {
2063 		kref_put(&ln->fcfinfo->kref, csio_free_fcfinfo);
2064 		if (csio_fdmi_enable)
2065 			csio_ln_fdmi_exit(ln);
2066 	}
2067 	ln->fcfinfo = NULL;
2068 }
2069 
2070 /*
2071  * csio_lnode_init - Initialize the members of an lnode.
2072  * @ln:		lnode
2073  */
2074 int
2075 csio_lnode_init(struct csio_lnode *ln, struct csio_hw *hw,
2076 		struct csio_lnode *pln)
2077 {
2078 	int rv = -EINVAL;
2079 
2080 	/* Link this lnode to hw */
2081 	csio_lnode_to_hw(ln)	= hw;
2082 
2083 	/* Link child to parent if child lnode */
2084 	if (pln)
2085 		ln->pln = pln;
2086 	else
2087 		ln->pln = NULL;
2088 
2089 	/* Initialize scsi_tgt and timers to zero */
2090 	ln->n_scsi_tgts = 0;
2091 	ln->last_scan_ntgts = 0;
2092 	ln->tgt_scan_tick = 0;
2093 
2094 	/* Initialize rnode list */
2095 	INIT_LIST_HEAD(&ln->rnhead);
2096 	INIT_LIST_HEAD(&ln->cln_head);
2097 
2098 	/* Initialize log level for debug */
2099 	ln->params.log_level	= hw->params.log_level;
2100 
2101 	if (csio_ln_init(ln))
2102 		goto err;
2103 
2104 	/* Add lnode to list of sibling or children lnodes */
2105 	spin_lock_irq(&hw->lock);
2106 	list_add_tail(&ln->sm.sm_list, pln ? &pln->cln_head : &hw->sln_head);
2107 	if (pln)
2108 		pln->num_vports++;
2109 	spin_unlock_irq(&hw->lock);
2110 
2111 	hw->num_lns++;
2112 
2113 	return 0;
2114 err:
2115 	csio_lnode_to_hw(ln) = NULL;
2116 	return rv;
2117 }
2118 
2119 /**
2120  * csio_lnode_exit - De-instantiate an lnode.
2121  * @ln:		lnode
2122  *
2123  */
2124 void
2125 csio_lnode_exit(struct csio_lnode *ln)
2126 {
2127 	struct csio_hw *hw = csio_lnode_to_hw(ln);
2128 
2129 	csio_ln_exit(ln);
2130 
2131 	/* Remove this lnode from hw->sln_head */
2132 	spin_lock_irq(&hw->lock);
2133 
2134 	list_del_init(&ln->sm.sm_list);
2135 
2136 	/* If it is children lnode, decrement the
2137 	 * counter in its parent lnode
2138 	 */
2139 	if (ln->pln)
2140 		ln->pln->num_vports--;
2141 
2142 	/* Update root lnode pointer */
2143 	if (list_empty(&hw->sln_head))
2144 		hw->rln = NULL;
2145 	else
2146 		hw->rln = (struct csio_lnode *)csio_list_next(&hw->sln_head);
2147 
2148 	spin_unlock_irq(&hw->lock);
2149 
2150 	csio_lnode_to_hw(ln)	= NULL;
2151 	hw->num_lns--;
2152 }
2153