?  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_rnode.c
blobe9c3b045f587509ffc92d01fd91d7c455a7e47a7
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/string.h>
36 #include <scsi/scsi_device.h>
37 #include <scsi/scsi_transport_fc.h>
38 #include <scsi/fc/fc_els.h>
39 #include <scsi/fc/fc_fs.h>
40
41 #include "csio_hw.h"
42 #include "csio_lnode.h"
43 #include "csio_rnode.h"
44
45 static int csio_rnode_init(struct csio_rnode *, struct csio_lnode *);
46 static void csio_rnode_exit(struct csio_rnode *);
47
48 /* Static machine forward declarations */
49 static void csio_rns_uninit(struct csio_rnode *, enum csio_rn_ev);
50 static void csio_rns_ready(struct csio_rnode *, enum csio_rn_ev);
51 static void csio_rns_offline(struct csio_rnode *, enum csio_rn_ev);
52 static void csio_rns_disappeared(struct csio_rnode *, enum csio_rn_ev);
53
54 /* RNF event mapping */
55 static enum csio_rn_ev fwevt_to_rnevt[] = {
56 CSIO_RNFE_NONE, /* None */
57 CSIO_RNFE_LOGGED_IN, /* PLOGI_ACC_RCVD */
58 CSIO_RNFE_NONE, /* PLOGI_RJT_RCVD */
59 CSIO_RNFE_PLOGI_RECV, /* PLOGI_RCVD */
60 CSIO_RNFE_LOGO_RECV, /* PLOGO_RCVD */
61 CSIO_RNFE_PRLI_DONE, /* PRLI_ACC_RCVD */
62 CSIO_RNFE_NONE, /* PRLI_RJT_RCVD */
63 CSIO_RNFE_PRLI_RECV, /* PRLI_RCVD */
64 CSIO_RNFE_PRLO_RECV, /* PRLO_RCVD */
65 CSIO_RNFE_NONE, /* NPORT_ID_CHGD */
66 CSIO_RNFE_LOGO_RECV, /* FLOGO_RCVD */
67 CSIO_RNFE_NONE, /* CLR_VIRT_LNK_RCVD */
68 CSIO_RNFE_LOGGED_IN, /* FLOGI_ACC_RCVD */
69 CSIO_RNFE_NONE, /* FLOGI_RJT_RCVD */
70 CSIO_RNFE_LOGGED_IN, /* FDISC_ACC_RCVD */
71 CSIO_RNFE_NONE, /* FDISC_RJT_RCVD */
72 CSIO_RNFE_NONE, /* FLOGI_TMO_MAX_RETRY */
73 CSIO_RNFE_NONE, /* IMPL_LOGO_ADISC_ACC */
74 CSIO_RNFE_NONE, /* IMPL_LOGO_ADISC_RJT */
75 CSIO_RNFE_NONE, /* IMPL_LOGO_ADISC_CNFLT */
76 CSIO_RNFE_NONE, /* PRLI_TMO */
77 CSIO_RNFE_NONE, /* ADISC_TMO */
78 CSIO_RNFE_NAME_MISSING, /* RSCN_DEV_LOST */
79 CSIO_RNFE_NONE, /* SCR_ACC_RCVD */
80 CSIO_RNFE_NONE, /* ADISC_RJT_RCVD */
81 CSIO_RNFE_NONE, /* LOGO_SNT */
82 CSIO_RNFE_LOGO_RECV, /* PROTO_ERR_IMPL_LOGO */
83 };
84
85 #define CSIO_FWE_TO_RNFE(_evt) ((_evt > PROTO_ERR_IMPL_LOGO) ? \
86 CSIO_RNFE_NONE : \
87 fwevt_to_rnevt[_evt])
88 int
89 csio_is_rnode_ready(struct csio_rnode *rn)
90 {
91 return csio_match_state(rn, csio_rns_ready);
92 }
93
94 static int
95 csio_is_rnode_uninit(struct csio_rnode *rn)
96 {
97 return csio_match_state(rn, csio_rns_uninit);
98 }
99
100 static int
101 csio_is_rnode_wka(uint8_t rport_type)
102 {
103 if ((rport_type == FLOGI_VFPORT) ||
104 (rport_type == FDISC_VFPORT) ||
105 (rport_type == NS_VNPORT) ||
106 (rport_type == FDMI_VNPORT))
107 return 1;
108
109 return 0;
110 }
111
112 /*
113 * csio_rn_lookup - Finds the rnode with the given flowid
114 * @ln - lnode
115 * @flowid - flowid.
116 *
117 * Does the rnode lookup on the given lnode and flowid.If no matching entry
118 * found, NULL is returned.
119 */
120 static struct csio_rnode *
121 csio_rn_lookup(struct csio_lnode *ln, uint32_t flowid)
122 {
123 struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;
124 struct list_head *tmp;
125 struct csio_rnode *rn;
126
127 list_for_each(tmp, &rnhead->sm.sm_list) {
128 rn = (struct csio_rnode *) tmp;
129 if (rn->flowid == flowid)
130 return rn;
131 }
132
133 return NULL;
134 }
135
136 /*
137 * csio_rn_lookup_wwpn - Finds the rnode with the given wwpn
138 * @ln: lnode
139 * @wwpn: wwpn
140 *
141 * Does the rnode lookup on the given lnode and wwpn. If no matching entry
142 * found, NULL is returned.
143 */
144 static struct csio_rnode *
145 csio_rn_lookup_wwpn(struct csio_lnode *ln, uint8_t *wwpn)
146 {
147 struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;
148 struct list_head *tmp;
149 struct csio_rnode *rn;
150
151 list_for_each(tmp, &rnhead->sm.sm_list) {
152 rn = (struct csio_rnode *) tmp;
153 if (!memcmp(csio_rn_wwpn(rn), wwpn, 8))
154 return rn;
155 }
156
157 return NULL;
158 }
159
160 /**
161 * csio_rnode_lookup_portid - Finds the rnode with the given portid
162 * @ln: lnode
163 * @portid: port id
164 *
165 * Lookup the rnode list for a given portid. If no matching entry
166 * found, NULL is returned.
167 */
168 struct csio_rnode *
169 csio_rnode_lookup_portid(struct csio_lnode *ln, uint32_t portid)
170 {
171 struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;
172 struct list_head *tmp;
173 struct csio_rnode *rn;
174
175 list_for_each(tmp, &rnhead->sm.sm_list) {
176 rn = (struct csio_rnode *) tmp;
177 if (rn->nport_id == portid)
178 return rn;
179 }
180
181 return NULL;
182 }
183
184 static int
185 csio_rn_dup_flowid(struct csio_lnode *ln, uint32_t rdev_flowid,
186 uint32_t *vnp_flowid)
187 {
188 struct csio_rnode *rnhead;
189 struct list_head *tmp, *tmp1;
190 struct csio_rnode *rn;
191 struct csio_lnode *ln_tmp;
192 struct csio_hw *hw = csio_lnode_to_hw(ln);
193
194 list_for_each(tmp1, &hw->sln_head) {
195 ln_tmp = (struct csio_lnode *) tmp1;
196 if (ln_tmp == ln)
197 continue;
198
199 rnhead = (struct csio_rnode *)&ln_tmp->rnhead;
200 list_for_each(tmp, &rnhead->sm.sm_list) {
201
202 rn = (struct csio_rnode *) tmp;
203 if (csio_is_rnode_ready(rn)) {
204 if (rn->flowid == rdev_flowid) {
205 *vnp_flowid = csio_ln_flowid(ln_tmp);
206 return 1;
207 }
208 }
209 }
210 }
211
212 return 0;
213 }
214
215 static struct csio_rnode *
216 csio_alloc_rnode(struct csio_lnode *ln)
217 {
218 struct csio_hw *hw = csio_lnode_to_hw(ln);
219
220 struct csio_rnode *rn = mempool_alloc(hw->rnode_mempool, GFP_ATOMIC);
221 if (!rn)
222 goto err;
223
224 memset(rn, 0, sizeof(struct csio_rnode));
225 if (csio_rnode_init(rn, ln))
226 goto err_free;
227
228 CSIO_INC_STATS(ln, n_rnode_alloc);
229
230 return rn;
231
232 err_free:
233 mempool_free(rn, hw->rnode_mempool);
234 err:
235 CSIO_INC_STATS(ln, n_rnode_nomem);
236 return NULL;
237 }
238
239 static void
240 csio_free_rnode(struct csio_rnode *rn)
241 {
242 struct csio_hw *hw = csio_lnode_to_hw(csio_rnode_to_lnode(rn));
243
244 csio_rnode_exit(rn);
245 CSIO_INC_STATS(rn->lnp, n_rnode_free);
246 mempool_free(rn, hw->rnode_mempool);
247 }
248
249 /*
250 * csio_get_rnode - Gets rnode with the given flowid
251 * @ln - lnode
252 * @flowid - flow id.
253 *
254 * Does the rnode lookup on the given lnode and flowid. If no matching
255 * rnode found, then new rnode with given npid is allocated and returned.
256 */
257 static struct csio_rnode *
258 csio_get_rnode(struct csio_lnode *ln, uint32_t flowid)
259 {
260 struct csio_rnode *rn;
261
262 rn = csio_rn_lookup(ln, flowid);
263 if (!rn) {
264 rn = csio_alloc_rnode(ln);
265 if (!rn)
266 return NULL;
267
268 rn->flowid = flowid;
269 }
270
271 return rn;
272 }
273
274 /*
275 * csio_put_rnode - Frees the given rnode
276 * @ln - lnode
277 * @flowid - flow id.
278 *
279 * Does the rnode lookup on the given lnode and flowid. If no matching
280 * rnode found, then new rnode with given npid is allocated and returned.
281 */
282 void
283 csio_put_rnode(struct csio_lnode *ln, struct csio_rnode *rn)
284 {
285 CSIO_DB_ASSERT(csio_is_rnode_uninit(rn) != 0);
286 csio_free_rnode(rn);
287 }
288
289 /*
290 * csio_confirm_rnode - confirms rnode based on wwpn.
291 * @ln: lnode
292 * @rdev_flowid: remote device flowid
293 * @rdevp: remote device params
294 * This routines searches other rnode in list having same wwpn of new rnode.
295 * If there is a match, then matched rnode is returned and otherwise new rnode
296 * is returned.
297 * returns rnode.
298 */
299 struct csio_rnode *
300 csio_confirm_rnode(struct csio_lnode *ln, uint32_t rdev_flowid,
301 struct fcoe_rdev_entry *rdevp)
302 {
303 uint8_t rport_type;
304 struct csio_rnode *rn, *match_rn;
305 uint32_t vnp_flowid = 0;
306 __be32 *port_id;
307
308 port_id = (__be32 *)&rdevp->r_id[0];
309 rport_type =
310 FW_RDEV_WR_RPORT_TYPE_GET(rdevp->rd_xfer_rdy_to_rport_type);
311
312 /* Drop rdev event for cntrl port */
313 if (rport_type == FAB_CTLR_VNPORT) {
314 csio_ln_dbg(ln,
315 "Unhandled rport_type:%d recv in rdev evt "
316 "ssni:x%x\n", rport_type, rdev_flowid);
317 return NULL;
318 }
319
320 /* Lookup on flowid */
321 rn = csio_rn_lookup(ln, rdev_flowid);
322 if (!rn) {
323
324 /* Drop events with duplicate flowid */
325 if (csio_rn_dup_flowid(ln, rdev_flowid, &vnp_flowid)) {
326 csio_ln_warn(ln,
327 "ssni:%x already active on vnpi:%x",
328 rdev_flowid, vnp_flowid);
329 return NULL;
330 }
331
332 /* Lookup on wwpn for NPORTs */
333 rn = csio_rn_lookup_wwpn(ln, rdevp->wwpn);
334 if (!rn)
335 goto alloc_rnode;
336
337 } else {
338 /* Lookup well-known ports with nport id */
339 if (csio_is_rnode_wka(rport_type)) {
340 match_rn = csio_rnode_lookup_portid(ln,
341 ((ntohl(*port_id) >> 8) & CSIO_DID_MASK));
342 if (match_rn == NULL) {
343 csio_rn_flowid(rn) = CSIO_INVALID_IDX;
344 goto alloc_rnode;
345 }
346
347 /*
348 * Now compare the wwpn to confirm that
349 * same port relogged in. If so update the matched rn.
350 * Else, go ahead and alloc a new rnode.
351 */
352 if (!memcmp(csio_rn_wwpn(match_rn), rdevp->wwpn, 8)) {
353 if (rn == match_rn)
354 goto found_rnode;
355 csio_ln_dbg(ln,
356 "nport_id:x%x and wwpn:%llx"
357 " match for ssni:x%x\n",
358 rn->nport_id,
359 wwn_to_u64(rdevp->wwpn),
360 rdev_flowid);
361 if (csio_is_rnode_ready(rn)) {
362 csio_ln_warn(ln,
363 "rnode is already"
364 "active ssni:x%x\n",
365 rdev_flowid);
366 CSIO_ASSERT(0);
367 }
368 csio_rn_flowid(rn) = CSIO_INVALID_IDX;
369 rn = match_rn;
370
371 /* Update rn */
372 goto found_rnode;
373 }
374 csio_rn_flowid(rn) = CSIO_INVALID_IDX;
375 goto alloc_rnode;
376 }
377
378 /* wwpn match */
379 if (!memcmp(csio_rn_wwpn(rn), rdevp->wwpn, 8))
380 goto found_rnode;
381
382 /* Search for rnode that have same wwpn */
383 match_rn = csio_rn_lookup_wwpn(ln, rdevp->wwpn);
384 if (match_rn != NULL) {
385 csio_ln_dbg(ln,
386 "ssni:x%x changed for rport name(wwpn):%llx "
387 "did:x%x\n", rdev_flowid,
388 wwn_to_u64(rdevp->wwpn),
389 match_rn->nport_id);
390 csio_rn_flowid(rn) = CSIO_INVALID_IDX;
391 rn = match_rn;
392 } else {
393 csio_ln_dbg(ln,
394 "rnode wwpn mismatch found ssni:x%x "
395 "name(wwpn):%llx\n",
396 rdev_flowid,
397 wwn_to_u64(csio_rn_wwpn(rn)));
398 if (csio_is_rnode_ready(rn)) {
399 csio_ln_warn(ln,
400 "rnode is already active "
401 "wwpn:%llx ssni:x%x\n",
402 wwn_to_u64(csio_rn_wwpn(rn)),
403 rdev_flowid);
404 CSIO_ASSERT(0);
405 }
406 csio_rn_flowid(rn) = CSIO_INVALID_IDX;
407 goto alloc_rnode;
408 }
409 }
410
411 found_rnode:
412 csio_ln_dbg(ln, "found rnode:%p ssni:x%x name(wwpn):%llx\n",
413 rn, rdev_flowid, wwn_to_u64(rdevp->wwpn));
414
415 /* Update flowid */
416 csio_rn_flowid(rn) = rdev_flowid;
417
418 /* update rdev entry */
419 rn->rdev_entry = rdevp;
420 CSIO_INC_STATS(ln, n_rnode_match);
421 return rn;
422
423 alloc_rnode:
424 rn = csio_get_rnode(ln, rdev_flowid);
425 if (!rn)
426 return NULL;
427
428 csio_ln_dbg(ln, "alloc rnode:%p ssni:x%x name(wwpn):%llx\n",
429 rn, rdev_flowid, wwn_to_u64(rdevp->wwpn));
430
431 /* update rdev entry */
432 rn->rdev_entry = rdevp;
433 return rn;
434 }
435
436 /*
437 * csio_rn_verify_rparams - verify rparams.
438 * @ln: lnode
439 * @rn: rnode
440 * @rdevp: remote device params
441 * returns success if rparams are verified.
442 */
443 static int
444 csio_rn_verify_rparams(struct csio_lnode *ln, struct csio_rnode *rn,
445 struct fcoe_rdev_entry *rdevp)
446 {
447 uint8_t null[8];
448 uint8_t rport_type;
449 uint8_t fc_class;
450 __be32 *did;
451
452 did = (__be32 *) &rdevp->r_id[0];
453 rport_type =
454 FW_RDEV_WR_RPORT_TYPE_GET(rdevp->rd_xfer_rdy_to_rport_type);
455 switch (rport_type) {
456 case FLOGI_VFPORT:
457 rn->role = CSIO_RNFR_FABRIC;
458 if (((ntohl(*did) >> 8) & CSIO_DID_MASK) != FC_FID_FLOGI) {
459 csio_ln_err(ln, "ssni:x%x invalid fabric portid\n",
460 csio_rn_flowid(rn));
461 return -EINVAL;
462 }
463 /* NPIV support */
464 if (FW_RDEV_WR_NPIV_GET(rdevp->vft_to_qos))
465 ln->flags |= CSIO_LNF_NPIVSUPP;
466
467 break;
468
469 case NS_VNPORT:
470 rn->role = CSIO_RNFR_NS;
471 if (((ntohl(*did) >> 8) & CSIO_DID_MASK) != FC_FID_DIR_SERV) {
472 csio_ln_err(ln, "ssni:x%x invalid fabric portid\n",
473 csio_rn_flowid(rn));
474 return -EINVAL;
475 }
476 break;
477
478 case REG_FC4_VNPORT:
479 case REG_VNPORT:
480 rn->role = CSIO_RNFR_NPORT;
481 if (rdevp->event_cause == PRLI_ACC_RCVD ||
482 rdevp->event_cause == PRLI_RCVD) {
483 if (FW_RDEV_WR_TASK_RETRY_ID_GET(
484 rdevp->enh_disc_to_tgt))
485 rn->fcp_flags |= FCP_SPPF_OVLY_ALLOW;
486
487 if (FW_RDEV_WR_RETRY_GET(rdevp->enh_disc_to_tgt))
488 rn->fcp_flags |= FCP_SPPF_RETRY;
489
490 if (FW_RDEV_WR_CONF_CMPL_GET(rdevp->enh_disc_to_tgt))
491 rn->fcp_flags |= FCP_SPPF_CONF_COMPL;
492
493 if (FW_RDEV_WR_TGT_GET(rdevp->enh_disc_to_tgt))
494 rn->role |= CSIO_RNFR_TARGET;
495
496 if (FW_RDEV_WR_INI_GET(rdevp->enh_disc_to_tgt))
497 rn->role |= CSIO_RNFR_INITIATOR;
498 }
499
500 break;
501
502 case FDMI_VNPORT:
503 case FAB_CTLR_VNPORT:
504 rn->role = 0;
505 break;
506
507 default:
508 csio_ln_err(ln, "ssni:x%x invalid rport type recv x%x\n",
509 csio_rn_flowid(rn), rport_type);
510 return -EINVAL;
511 }
512
513 /* validate wwpn/wwnn for Name server/remote port */
514 if (rport_type == REG_VNPORT || rport_type == NS_VNPORT) {
515 memset(null, 0, 8);
516 if (!memcmp(rdevp->wwnn, null, 8)) {
517 csio_ln_err(ln,
518 "ssni:x%x invalid wwnn received from"
519 " rport did:x%x\n",
520 csio_rn_flowid(rn),
521 (ntohl(*did) & CSIO_DID_MASK));
522 return -EINVAL;
523 }
524
525 if (!memcmp(rdevp->wwpn, null, 8)) {
526 csio_ln_err(ln,
527 "ssni:x%x invalid wwpn received from"
528 " rport did:x%x\n",
529 csio_rn_flowid(rn),
530 (ntohl(*did) & CSIO_DID_MASK));
531 return -EINVAL;
532 }
533
534 }
535
536 /* Copy wwnn, wwpn and nport id */
537 rn->nport_id = (ntohl(*did) >> 8) & CSIO_DID_MASK;
538 memcpy(csio_rn_wwnn(rn), rdevp->wwnn, 8);
539 memcpy(csio_rn_wwpn(rn), rdevp->wwpn, 8);
540 rn->rn_sparm.csp.sp_bb_data = rdevp->rcv_fr_sz;
541 fc_class = FW_RDEV_WR_CLASS_GET(rdevp->vft_to_qos);
542 rn->rn_sparm.clsp[fc_class - 1].cp_class = htons(FC_CPC_VALID);
543
544 return 0;
545 }
546
547 static void
548 __csio_reg_rnode(struct csio_rnode *rn)
549 {
550 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
551 struct csio_hw *hw = csio_lnode_to_hw(ln);
552
553 spin_unlock_irq(&hw->lock);
554 csio_reg_rnode(rn);
555 spin_lock_irq(&hw->lock);
556
557 if (rn->role & CSIO_RNFR_TARGET)
558 ln->n_scsi_tgts++;
559
560 if (rn->nport_id == FC_FID_MGMT_SERV)
561 csio_ln_fdmi_start(ln, (void *) rn);
562 }
563
564 static void
565 __csio_unreg_rnode(struct csio_rnode *rn)
566 {
567 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
568 struct csio_hw *hw = csio_lnode_to_hw(ln);
569 LIST_HEAD(tmp_q);
570 int cmpl = 0;
571
572 if (!list_empty(&rn->host_cmpl_q)) {
573 csio_dbg(hw, "Returning completion queue I/Os\n");
574 list_splice_tail_init(&rn->host_cmpl_q, &tmp_q);
575 cmpl = 1;
576 }
577
578 if (rn->role & CSIO_RNFR_TARGET) {
579 ln->n_scsi_tgts--;
580 ln->last_scan_ntgts--;
581 }
582
583 spin_unlock_irq(&hw->lock);
584 csio_unreg_rnode(rn);
585 spin_lock_irq(&hw->lock);
586
587 /* Cleanup I/Os that were waiting for rnode to unregister */
588 if (cmpl)
589 csio_scsi_cleanup_io_q(csio_hw_to_scsim(hw), &tmp_q);
590
591 }
592
593 /*****************************************************************************/
594 /* START: Rnode SM */
595 /*****************************************************************************/
596
597 /*
598 * csio_rns_uninit -
599 * @rn - rnode
600 * @evt - SM event.
601 *
602 */
603 static void
604 csio_rns_uninit(struct csio_rnode *rn, enum csio_rn_ev evt)
605 {
606 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
607 int ret = 0;
608
609 CSIO_INC_STATS(rn, n_evt_sm[evt]);
610
611 switch (evt) {
612 case CSIO_RNFE_LOGGED_IN:
613 case CSIO_RNFE_PLOGI_RECV:
614 ret = csio_rn_verify_rparams(ln, rn, rn->rdev_entry);
615 if (!ret) {
616 csio_set_state(&rn->sm, csio_rns_ready);
617 __csio_reg_rnode(rn);
618 } else {
619 CSIO_INC_STATS(rn, n_err_inval);
620 }
621 break;
622 case CSIO_RNFE_LOGO_RECV:
623 csio_ln_dbg(ln,
624 "ssni:x%x Ignoring event %d recv "
625 "in rn state[uninit]\n", csio_rn_flowid(rn), evt);
626 CSIO_INC_STATS(rn, n_evt_drop);
627 break;
628 default:
629 csio_ln_dbg(ln,
630 "ssni:x%x unexp event %d recv "
631 "in rn state[uninit]\n", csio_rn_flowid(rn), evt);
632 CSIO_INC_STATS(rn, n_evt_unexp);
633 break;
634 }
635 }
636
637 /*
638 * csio_rns_ready -
639 * @rn - rnode
640 * @evt - SM event.
641 *
642 */
643 static void
644 csio_rns_ready(struct csio_rnode *rn, enum csio_rn_ev evt)
645 {
646 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
647 int ret = 0;
648
649 CSIO_INC_STATS(rn, n_evt_sm[evt]);
650
651 switch (evt) {
652 case CSIO_RNFE_LOGGED_IN:
653 case CSIO_RNFE_PLOGI_RECV:
654 csio_ln_dbg(ln,
655 "ssni:x%x Ignoring event %d recv from did:x%x "
656 "in rn state[ready]\n", csio_rn_flowid(rn), evt,
657 rn->nport_id);
658 CSIO_INC_STATS(rn, n_evt_drop);
659 break;
660
661 case CSIO_RNFE_PRLI_DONE:
662 case CSIO_RNFE_PRLI_RECV:
663 ret = csio_rn_verify_rparams(ln, rn, rn->rdev_entry);
664 if (!ret)
665 __csio_reg_rnode(rn);
666 else
667 CSIO_INC_STATS(rn, n_err_inval);
668
669 break;
670 case CSIO_RNFE_DOWN:
671 csio_set_state(&rn->sm, csio_rns_offline);
672 __csio_unreg_rnode(rn);
673
674 /* FW expected to internally aborted outstanding SCSI WRs
675 * and return all SCSI WRs to host with status "ABORTED".
676 */
677 break;
678
679 case CSIO_RNFE_LOGO_RECV:
680 csio_set_state(&rn->sm, csio_rns_offline);
681
682 __csio_unreg_rnode(rn);
683
684 /* FW expected to internally aborted outstanding SCSI WRs
685 * and return all SCSI WRs to host with status "ABORTED".
686 */
687 break;
688
689 case CSIO_RNFE_CLOSE:
690 /*
691 * Each rnode receives CLOSE event when driver is removed or
692 * device is reset
693 * Note: All outstanding IOs on remote port need to returned
694 * to uppper layer with appropriate error before sending
695 * CLOSE event
696 */
697 csio_set_state(&rn->sm, csio_rns_uninit);
698 __csio_unreg_rnode(rn);
699 break;
700
701 case CSIO_RNFE_NAME_MISSING:
702 csio_set_state(&rn->sm, csio_rns_disappeared);
703 __csio_unreg_rnode(rn);
704
705 /*
706 * FW expected to internally aborted outstanding SCSI WRs
707 * and return all SCSI WRs to host with status "ABORTED".
708 */
709
710 break;
711
712 default:
713 csio_ln_dbg(ln,
714 "ssni:x%x unexp event %d recv from did:x%x "
715 "in rn state[uninit]\n", csio_rn_flowid(rn), evt,
716 rn->nport_id);
717 CSIO_INC_STATS(rn, n_evt_unexp);
718 break;
719 }
720 }
721
722 /*
723 * csio_rns_offline -
724 * @rn - rnode
725 * @evt - SM event.
726 *
727 */
728 static void
729 csio_rns_offline(struct csio_rnode *rn, enum csio_rn_ev evt)
730 {
731 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
732 int ret = 0;
733
734 CSIO_INC_STATS(rn, n_evt_sm[evt]);
735
736 switch (evt) {
737 case CSIO_RNFE_LOGGED_IN:
738 case CSIO_RNFE_PLOGI_RECV:
739 ret = csio_rn_verify_rparams(ln, rn, rn->rdev_entry);
740 if (!ret) {
741 csio_set_state(&rn->sm, csio_rns_ready);
742 __csio_reg_rnode(rn);
743 } else {
744 CSIO_INC_STATS(rn, n_err_inval);
745 csio_post_event(&rn->sm, CSIO_RNFE_CLOSE);
746 }
747 break;
748
749 case CSIO_RNFE_DOWN:
750 csio_ln_dbg(ln,
751 "ssni:x%x Ignoring event %d recv from did:x%x "
752 "in rn state[offline]\n", csio_rn_flowid(rn), evt,
753 rn->nport_id);
754 CSIO_INC_STATS(rn, n_evt_drop);
755 break;
756
757 case CSIO_RNFE_CLOSE:
758 /* Each rnode receives CLOSE event when driver is removed or
759 * device is reset
760 * Note: All outstanding IOs on remote port need to returned
761 * to uppper layer with appropriate error before sending
762 * CLOSE event
763 */
764 csio_set_state(&rn->sm, csio_rns_uninit);
765 break;
766
767 case CSIO_RNFE_NAME_MISSING:
768 csio_set_state(&rn->sm, csio_rns_disappeared);
769 break;
770
771 default:
772 csio_ln_dbg(ln,
773 "ssni:x%x unexp event %d recv from did:x%x "
774 "in rn state[offline]\n", csio_rn_flowid(rn), evt,
775 rn->nport_id);
776 CSIO_INC_STATS(rn, n_evt_unexp);
777 break;
778 }
779 }
780
781 /*
782 * csio_rns_disappeared -
783 * @rn - rnode
784 * @evt - SM event.
785 *
786 */
787 static void
788 csio_rns_disappeared(struct csio_rnode *rn, enum csio_rn_ev evt)
789 {
790 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
791 int ret = 0;
792
793 CSIO_INC_STATS(rn, n_evt_sm[evt]);
794
795 switch (evt) {
796 case CSIO_RNFE_LOGGED_IN:
797 case CSIO_RNFE_PLOGI_RECV:
798 ret = csio_rn_verify_rparams(ln, rn, rn->rdev_entry);
799 if (!ret) {
800 csio_set_state(&rn->sm, csio_rns_ready);
801 __csio_reg_rnode(rn);
802 } else {
803 CSIO_INC_STATS(rn, n_err_inval);
804 csio_post_event(&rn->sm, CSIO_RNFE_CLOSE);
805 }
806 break;
807
808 case CSIO_RNFE_CLOSE:
809 /* Each rnode receives CLOSE event when driver is removed or
810 * device is reset.
811 * Note: All outstanding IOs on remote port need to returned
812 * to uppper layer with appropriate error before sending
813 * CLOSE event
814 */
815 csio_set_state(&rn->sm, csio_rns_uninit);
816 break;
817
818 case CSIO_RNFE_DOWN:
819 case CSIO_RNFE_NAME_MISSING:
820 csio_ln_dbg(ln,
821 "ssni:x%x Ignoring event %d recv from did x%x"
822 "in rn state[disappeared]\n", csio_rn_flowid(rn),
823 evt, rn->nport_id);
824 break;
825
826 default:
827 csio_ln_dbg(ln,
828 "ssni:x%x unexp event %d recv from did x%x"
829 "in rn state[disappeared]\n", csio_rn_flowid(rn),
830 evt, rn->nport_id);
831 CSIO_INC_STATS(rn, n_evt_unexp);
832 break;
833 }
834 }
835
836 /*****************************************************************************/
837 /* END: Rnode SM */
838 /*****************************************************************************/
839
840 /*
841 * csio_rnode_devloss_handler - Device loss event handler
842 * @rn: rnode
843 *
844 * Post event to close rnode SM and free rnode.
845 */
846 void
847 csio_rnode_devloss_handler(struct csio_rnode *rn)
848 {
849 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
850
851 /* ignore if same rnode came back as online */
852 if (csio_is_rnode_ready(rn))
853 return;
854
855 csio_post_event(&rn->sm, CSIO_RNFE_CLOSE);
856
857 /* Free rn if in uninit state */
858 if (csio_is_rnode_uninit(rn))
859 csio_put_rnode(ln, rn);
860 }
861
862 /**
863 * csio_rnode_fwevt_handler - Event handler for firmware rnode events.
864 * @rn: rnode
865 *
866 */
867 void
868 csio_rnode_fwevt_handler(struct csio_rnode *rn, uint8_t fwevt)
869 {
870 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
871 enum csio_rn_ev evt;
872
873 evt = CSIO_FWE_TO_RNFE(fwevt);
874 if (!evt) {
875 csio_ln_err(ln, "ssni:x%x Unhandled FW Rdev event: %d\n",
876 csio_rn_flowid(rn), fwevt);
877 CSIO_INC_STATS(rn, n_evt_unexp);
878 return;
879 }
880 CSIO_INC_STATS(rn, n_evt_fw[fwevt]);
881
882 /* Track previous & current events for debugging */
883 rn->prev_evt = rn->cur_evt;
884 rn->cur_evt = fwevt;
885
886 /* Post event to rnode SM */
887 csio_post_event(&rn->sm, evt);
888
889 /* Free rn if in uninit state */
890 if (csio_is_rnode_uninit(rn))
891 csio_put_rnode(ln, rn);
892 }
893
894 /*
895 * csio_rnode_init - Initialize rnode.
896 * @rn: RNode
897 * @ln: Associated lnode
898 *
899 * Caller is responsible for holding the lock. The lock is required
900 * to be held for inserting the rnode in ln->rnhead list.
901 */
902 static int
903 csio_rnode_init(struct csio_rnode *rn, struct csio_lnode *ln)
904 {
905 csio_rnode_to_lnode(rn) = ln;
906 csio_init_state(&rn->sm, csio_rns_uninit);
907 INIT_LIST_HEAD(&rn->host_cmpl_q);
908 csio_rn_flowid(rn) = CSIO_INVALID_IDX;
909
910 /* Add rnode to list of lnodes->rnhead */
911 list_add_tail(&rn->sm.sm_list, &ln->rnhead);
912
913 return 0;
914 }
915
916 static void
917 csio_rnode_exit(struct csio_rnode *rn)
918 {
919 list_del_init(&rn->sm.sm_list);
920 CSIO_DB_ASSERT(list_empty(&rn->host_cmpl_q));
921 }
Linux with added FPC-III support