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