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