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