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/string.h>
37 #include <linux/delay.h>
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/pci.h>
41 #include <linux/mm.h>
42 #include <linux/jiffies.h>
43 #include <scsi/fc/fc_fs.h>
44
45 #include "csio_init.h"
46
47 static void
48 csio_vport_set_state(struct csio_lnode *ln);
49
50 /*
51 * csio_reg_rnode - Register a remote port with FC transport.
52 * @rn: Rnode representing remote port.
53 *
54 * Call fc_remote_port_add() to register this remote port with FC transport.
55 * If remote port is Initiator OR Target OR both, change the role appropriately.
56 *
57 */
58 void
csio_reg_rnode(struct csio_rnode * rn)59 csio_reg_rnode(struct csio_rnode *rn)
60 {
61 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
62 struct Scsi_Host *shost = csio_ln_to_shost(ln);
63 struct fc_rport_identifiers ids;
64 struct fc_rport *rport;
65 struct csio_service_parms *sp;
66
67 ids.node_name = wwn_to_u64(csio_rn_wwnn(rn));
68 ids.port_name = wwn_to_u64(csio_rn_wwpn(rn));
69 ids.port_id = rn->nport_id;
70 ids.roles = FC_RPORT_ROLE_UNKNOWN;
71
72 if (rn->role & CSIO_RNFR_INITIATOR || rn->role & CSIO_RNFR_TARGET) {
73 rport = rn->rport;
74 CSIO_ASSERT(rport != NULL);
75 goto update_role;
76 }
77
78 rn->rport = fc_remote_port_add(shost, 0, &ids);
79 if (!rn->rport) {
80 csio_ln_err(ln, "Failed to register rport = 0x%x.\n",
81 rn->nport_id);
82 return;
83 }
84
85 ln->num_reg_rnodes++;
86 rport = rn->rport;
87 spin_lock_irq(shost->host_lock);
88 *((struct csio_rnode **)rport->dd_data) = rn;
89 spin_unlock_irq(shost->host_lock);
90
91 sp = &rn->rn_sparm;
92 rport->maxframe_size = ntohs(sp->csp.sp_bb_data);
93 if (ntohs(sp->clsp[2].cp_class) & FC_CPC_VALID)
94 rport->supported_classes = FC_COS_CLASS3;
95 else
96 rport->supported_classes = FC_COS_UNSPECIFIED;
97 update_role:
98 if (rn->role & CSIO_RNFR_INITIATOR)
99 ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
100 if (rn->role & CSIO_RNFR_TARGET)
101 ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
102
103 if (ids.roles != FC_RPORT_ROLE_UNKNOWN)
104 fc_remote_port_rolechg(rport, ids.roles);
105
106 rn->scsi_id = rport->scsi_target_id;
107
108 csio_ln_dbg(ln, "Remote port x%x role 0x%x registered\n",
109 rn->nport_id, ids.roles);
110 }
111
112 /*
113 * csio_unreg_rnode - Unregister a remote port with FC transport.
114 * @rn: Rnode representing remote port.
115 *
116 * Call fc_remote_port_delete() to unregister this remote port with FC
117 * transport.
118 *
119 */
120 void
csio_unreg_rnode(struct csio_rnode * rn)121 csio_unreg_rnode(struct csio_rnode *rn)
122 {
123 struct csio_lnode *ln = csio_rnode_to_lnode(rn);
124 struct fc_rport *rport = rn->rport;
125
126 rn->role &= ~(CSIO_RNFR_INITIATOR | CSIO_RNFR_TARGET);
127 fc_remote_port_delete(rport);
128 ln->num_reg_rnodes--;
129
130 csio_ln_dbg(ln, "Remote port x%x un-registered\n", rn->nport_id);
131 }
132
133 /*
134 * csio_lnode_async_event - Async events from local port.
135 * @ln: lnode representing local port.
136 *
137 * Async events from local node that FC transport/SCSI ML
138 * should be made aware of (Eg: RSCN).
139 */
140 void
csio_lnode_async_event(struct csio_lnode * ln,enum csio_ln_fc_evt fc_evt)141 csio_lnode_async_event(struct csio_lnode *ln, enum csio_ln_fc_evt fc_evt)
142 {
143 switch (fc_evt) {
144 case CSIO_LN_FC_RSCN:
145 /* Get payload of rscn from ln */
146 /* For each RSCN entry */
147 /*
148 * fc_host_post_event(shost,
149 * fc_get_event_number(),
150 * FCH_EVT_RSCN,
151 * rscn_entry);
152 */
153 break;
154 case CSIO_LN_FC_LINKUP:
155 /* send fc_host_post_event */
156 /* set vport state */
157 if (csio_is_npiv_ln(ln))
158 csio_vport_set_state(ln);
159
160 break;
161 case CSIO_LN_FC_LINKDOWN:
162 /* send fc_host_post_event */
163 /* set vport state */
164 if (csio_is_npiv_ln(ln))
165 csio_vport_set_state(ln);
166
167 break;
168 case CSIO_LN_FC_ATTRIB_UPDATE:
169 csio_fchost_attr_init(ln);
170 break;
171 default:
172 break;
173 }
174 }
175
176 /*
177 * csio_fchost_attr_init - Initialize FC transport attributes
178 * @ln: Lnode.
179 *
180 */
181 void
csio_fchost_attr_init(struct csio_lnode * ln)182 csio_fchost_attr_init(struct csio_lnode *ln)
183 {
184 struct Scsi_Host *shost = csio_ln_to_shost(ln);
185
186 fc_host_node_name(shost) = wwn_to_u64(csio_ln_wwnn(ln));
187 fc_host_port_name(shost) = wwn_to_u64(csio_ln_wwpn(ln));
188
189 fc_host_supported_classes(shost) = FC_COS_CLASS3;
190 fc_host_max_npiv_vports(shost) =
191 (csio_lnode_to_hw(ln))->fres_info.max_vnps;
192 fc_host_supported_speeds(shost) = FC_PORTSPEED_10GBIT |
193 FC_PORTSPEED_1GBIT;
194
195 fc_host_maxframe_size(shost) = ntohs(ln->ln_sparm.csp.sp_bb_data);
196 memset(fc_host_supported_fc4s(shost), 0,
197 sizeof(fc_host_supported_fc4s(shost)));
198 fc_host_supported_fc4s(shost)[7] = 1;
199
200 memset(fc_host_active_fc4s(shost), 0,
201 sizeof(fc_host_active_fc4s(shost)));
202 fc_host_active_fc4s(shost)[7] = 1;
203 }
204
205 /*
206 * csio_get_host_port_id - sysfs entries for nport_id is
207 * populated/cached from this function
208 */
209 static void
csio_get_host_port_id(struct Scsi_Host * shost)210 csio_get_host_port_id(struct Scsi_Host *shost)
211 {
212 struct csio_lnode *ln = shost_priv(shost);
213 struct csio_hw *hw = csio_lnode_to_hw(ln);
214
215 spin_lock_irq(&hw->lock);
216 fc_host_port_id(shost) = ln->nport_id;
217 spin_unlock_irq(&hw->lock);
218 }
219
220 /*
221 * csio_get_port_type - Return FC local port type.
222 * @shost: scsi host.
223 *
224 */
225 static void
csio_get_host_port_type(struct Scsi_Host * shost)226 csio_get_host_port_type(struct Scsi_Host *shost)
227 {
228 struct csio_lnode *ln = shost_priv(shost);
229 struct csio_hw *hw = csio_lnode_to_hw(ln);
230
231 spin_lock_irq(&hw->lock);
232 if (csio_is_npiv_ln(ln))
233 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
234 else
235 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
236 spin_unlock_irq(&hw->lock);
237 }
238
239 /*
240 * csio_get_port_state - Return FC local port state.
241 * @shost: scsi host.
242 *
243 */
244 static void
csio_get_host_port_state(struct Scsi_Host * shost)245 csio_get_host_port_state(struct Scsi_Host *shost)
246 {
247 struct csio_lnode *ln = shost_priv(shost);
248 struct csio_hw *hw = csio_lnode_to_hw(ln);
249 char state[16];
250
251 spin_lock_irq(&hw->lock);
252
253 csio_lnode_state_to_str(ln, state);
254 if (!strcmp(state, "READY"))
255 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
256 else if (!strcmp(state, "OFFLINE"))
257 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
258 else
259 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
260
261 spin_unlock_irq(&hw->lock);
262 }
263
264 /*
265 * csio_get_host_speed - Return link speed to FC transport.
266 * @shost: scsi host.
267 *
268 */
269 static void
csio_get_host_speed(struct Scsi_Host * shost)270 csio_get_host_speed(struct Scsi_Host *shost)
271 {
272 struct csio_lnode *ln = shost_priv(shost);
273 struct csio_hw *hw = csio_lnode_to_hw(ln);
274
275 spin_lock_irq(&hw->lock);
276 switch (hw->pport[ln->portid].link_speed) {
277 case FW_PORT_CAP32_SPEED_1G:
278 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
279 break;
280 case FW_PORT_CAP32_SPEED_10G:
281 fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
282 break;
283 case FW_PORT_CAP32_SPEED_25G:
284 fc_host_speed(shost) = FC_PORTSPEED_25GBIT;
285 break;
286 case FW_PORT_CAP32_SPEED_40G:
287 fc_host_speed(shost) = FC_PORTSPEED_40GBIT;
288 break;
289 case FW_PORT_CAP32_SPEED_50G:
290 fc_host_speed(shost) = FC_PORTSPEED_50GBIT;
291 break;
292 case FW_PORT_CAP32_SPEED_100G:
293 fc_host_speed(shost) = FC_PORTSPEED_100GBIT;
294 break;
295 default:
296 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
297 break;
298 }
299 spin_unlock_irq(&hw->lock);
300 }
301
302 /*
303 * csio_get_host_fabric_name - Return fabric name
304 * @shost: scsi host.
305 *
306 */
307 static void
csio_get_host_fabric_name(struct Scsi_Host * shost)308 csio_get_host_fabric_name(struct Scsi_Host *shost)
309 {
310 struct csio_lnode *ln = shost_priv(shost);
311 struct csio_rnode *rn = NULL;
312 struct csio_hw *hw = csio_lnode_to_hw(ln);
313
314 spin_lock_irq(&hw->lock);
315 rn = csio_rnode_lookup_portid(ln, FC_FID_FLOGI);
316 if (rn)
317 fc_host_fabric_name(shost) = wwn_to_u64(csio_rn_wwnn(rn));
318 else
319 fc_host_fabric_name(shost) = 0;
320 spin_unlock_irq(&hw->lock);
321 }
322
323 /*
324 * csio_get_host_speed - Return FC transport statistics.
325 * @ln: Lnode.
326 *
327 */
328 static struct fc_host_statistics *
csio_get_stats(struct Scsi_Host * shost)329 csio_get_stats(struct Scsi_Host *shost)
330 {
331 struct csio_lnode *ln = shost_priv(shost);
332 struct csio_hw *hw = csio_lnode_to_hw(ln);
333 struct fc_host_statistics *fhs = &ln->fch_stats;
334 struct fw_fcoe_port_stats fcoe_port_stats;
335 uint64_t seconds;
336
337 memset(&fcoe_port_stats, 0, sizeof(struct fw_fcoe_port_stats));
338 csio_get_phy_port_stats(hw, ln->portid, &fcoe_port_stats);
339
340 fhs->tx_frames += (be64_to_cpu(fcoe_port_stats.tx_bcast_frames) +
341 be64_to_cpu(fcoe_port_stats.tx_mcast_frames) +
342 be64_to_cpu(fcoe_port_stats.tx_ucast_frames) +
343 be64_to_cpu(fcoe_port_stats.tx_offload_frames));
344 fhs->tx_words += (be64_to_cpu(fcoe_port_stats.tx_bcast_bytes) +
345 be64_to_cpu(fcoe_port_stats.tx_mcast_bytes) +
346 be64_to_cpu(fcoe_port_stats.tx_ucast_bytes) +
347 be64_to_cpu(fcoe_port_stats.tx_offload_bytes)) /
348 CSIO_WORD_TO_BYTE;
349 fhs->rx_frames += (be64_to_cpu(fcoe_port_stats.rx_bcast_frames) +
350 be64_to_cpu(fcoe_port_stats.rx_mcast_frames) +
351 be64_to_cpu(fcoe_port_stats.rx_ucast_frames));
352 fhs->rx_words += (be64_to_cpu(fcoe_port_stats.rx_bcast_bytes) +
353 be64_to_cpu(fcoe_port_stats.rx_mcast_bytes) +
354 be64_to_cpu(fcoe_port_stats.rx_ucast_bytes)) /
355 CSIO_WORD_TO_BYTE;
356 fhs->error_frames += be64_to_cpu(fcoe_port_stats.rx_err_frames);
357 fhs->fcp_input_requests += ln->stats.n_input_requests;
358 fhs->fcp_output_requests += ln->stats.n_output_requests;
359 fhs->fcp_control_requests += ln->stats.n_control_requests;
360 fhs->fcp_input_megabytes += ln->stats.n_input_bytes >> 20;
361 fhs->fcp_output_megabytes += ln->stats.n_output_bytes >> 20;
362 fhs->link_failure_count = ln->stats.n_link_down;
363 /* Reset stats for the device */
364 seconds = jiffies_to_msecs(jiffies) - hw->stats.n_reset_start;
365 do_div(seconds, 1000);
366 fhs->seconds_since_last_reset = seconds;
367
368 return fhs;
369 }
370
371 /*
372 * csio_set_rport_loss_tmo - Set the rport dev loss timeout
373 * @rport: fc rport.
374 * @timeout: new value for dev loss tmo.
375 *
376 * If timeout is non zero set the dev_loss_tmo to timeout, else set
377 * dev_loss_tmo to one.
378 */
379 static void
csio_set_rport_loss_tmo(struct fc_rport * rport,uint32_t timeout)380 csio_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
381 {
382 if (timeout)
383 rport->dev_loss_tmo = timeout;
384 else
385 rport->dev_loss_tmo = 1;
386 }
387
388 static void
csio_vport_set_state(struct csio_lnode * ln)389 csio_vport_set_state(struct csio_lnode *ln)
390 {
391 struct fc_vport *fc_vport = ln->fc_vport;
392 struct csio_lnode *pln = ln->pln;
393 char state[16];
394
395 /* Set fc vport state based on phyiscal lnode */
396 csio_lnode_state_to_str(pln, state);
397 if (strcmp(state, "READY")) {
398 fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
399 return;
400 }
401
402 if (!(pln->flags & CSIO_LNF_NPIVSUPP)) {
403 fc_vport_set_state(fc_vport, FC_VPORT_NO_FABRIC_SUPP);
404 return;
405 }
406
407 /* Set fc vport state based on virtual lnode */
408 csio_lnode_state_to_str(ln, state);
409 if (strcmp(state, "READY")) {
410 fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
411 return;
412 }
413 fc_vport_set_state(fc_vport, FC_VPORT_ACTIVE);
414 }
415
416 static int
csio_fcoe_alloc_vnp(struct csio_hw * hw,struct csio_lnode * ln)417 csio_fcoe_alloc_vnp(struct csio_hw *hw, struct csio_lnode *ln)
418 {
419 struct csio_lnode *pln;
420 struct csio_mb *mbp;
421 struct fw_fcoe_vnp_cmd *rsp;
422 int ret = 0;
423 int retry = 0;
424
425 /* Issue VNP cmd to alloc vport */
426 /* Allocate Mbox request */
427 spin_lock_irq(&hw->lock);
428 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
429 if (!mbp) {
430 CSIO_INC_STATS(hw, n_err_nomem);
431 ret = -ENOMEM;
432 goto out;
433 }
434
435 pln = ln->pln;
436 ln->fcf_flowid = pln->fcf_flowid;
437 ln->portid = pln->portid;
438
439 csio_fcoe_vnp_alloc_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO,
440 pln->fcf_flowid, pln->vnp_flowid, 0,
441 csio_ln_wwnn(ln), csio_ln_wwpn(ln), NULL);
442
443 for (retry = 0; retry < 3; retry++) {
444 /* FW is expected to complete vnp cmd in immediate mode
445 * without much delay.
446 * Otherwise, there will be increase in IO latency since HW
447 * lock is held till completion of vnp mbox cmd.
448 */
449 ret = csio_mb_issue(hw, mbp);
450 if (ret != -EBUSY)
451 break;
452
453 /* Retry if mbox returns busy */
454 spin_unlock_irq(&hw->lock);
455 msleep(2000);
456 spin_lock_irq(&hw->lock);
457 }
458
459 if (ret) {
460 csio_ln_err(ln, "Failed to issue mbox FCoE VNP command\n");
461 goto out_free;
462 }
463
464 /* Process Mbox response of VNP command */
465 rsp = (struct fw_fcoe_vnp_cmd *)(mbp->mb);
466 if (FW_CMD_RETVAL_G(ntohl(rsp->alloc_to_len16)) != FW_SUCCESS) {
467 csio_ln_err(ln, "FCOE VNP ALLOC cmd returned 0x%x!\n",
468 FW_CMD_RETVAL_G(ntohl(rsp->alloc_to_len16)));
469 ret = -EINVAL;
470 goto out_free;
471 }
472
473 ln->vnp_flowid = FW_FCOE_VNP_CMD_VNPI_GET(
474 ntohl(rsp->gen_wwn_to_vnpi));
475 memcpy(csio_ln_wwnn(ln), rsp->vnport_wwnn, 8);
476 memcpy(csio_ln_wwpn(ln), rsp->vnport_wwpn, 8);
477
478 csio_ln_dbg(ln, "FCOE VNPI: 0x%x\n", ln->vnp_flowid);
479 csio_ln_dbg(ln, "\tWWNN: %x%x%x%x%x%x%x%x\n",
480 ln->ln_sparm.wwnn[0], ln->ln_sparm.wwnn[1],
481 ln->ln_sparm.wwnn[2], ln->ln_sparm.wwnn[3],
482 ln->ln_sparm.wwnn[4], ln->ln_sparm.wwnn[5],
483 ln->ln_sparm.wwnn[6], ln->ln_sparm.wwnn[7]);
484 csio_ln_dbg(ln, "\tWWPN: %x%x%x%x%x%x%x%x\n",
485 ln->ln_sparm.wwpn[0], ln->ln_sparm.wwpn[1],
486 ln->ln_sparm.wwpn[2], ln->ln_sparm.wwpn[3],
487 ln->ln_sparm.wwpn[4], ln->ln_sparm.wwpn[5],
488 ln->ln_sparm.wwpn[6], ln->ln_sparm.wwpn[7]);
489
490 out_free:
491 mempool_free(mbp, hw->mb_mempool);
492 out:
493 spin_unlock_irq(&hw->lock);
494 return ret;
495 }
496
497 static int
csio_fcoe_free_vnp(struct csio_hw * hw,struct csio_lnode * ln)498 csio_fcoe_free_vnp(struct csio_hw *hw, struct csio_lnode *ln)
499 {
500 struct csio_mb *mbp;
501 struct fw_fcoe_vnp_cmd *rsp;
502 int ret = 0;
503 int retry = 0;
504
505 /* Issue VNP cmd to free vport */
506 /* Allocate Mbox request */
507
508 spin_lock_irq(&hw->lock);
509 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
510 if (!mbp) {
511 CSIO_INC_STATS(hw, n_err_nomem);
512 ret = -ENOMEM;
513 goto out;
514 }
515
516 csio_fcoe_vnp_free_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO,
517 ln->fcf_flowid, ln->vnp_flowid,
518 NULL);
519
520 for (retry = 0; retry < 3; retry++) {
521 ret = csio_mb_issue(hw, mbp);
522 if (ret != -EBUSY)
523 break;
524
525 /* Retry if mbox returns busy */
526 spin_unlock_irq(&hw->lock);
527 msleep(2000);
528 spin_lock_irq(&hw->lock);
529 }
530
531 if (ret) {
532 csio_ln_err(ln, "Failed to issue mbox FCoE VNP command\n");
533 goto out_free;
534 }
535
536 /* Process Mbox response of VNP command */
537 rsp = (struct fw_fcoe_vnp_cmd *)(mbp->mb);
538 if (FW_CMD_RETVAL_G(ntohl(rsp->alloc_to_len16)) != FW_SUCCESS) {
539 csio_ln_err(ln, "FCOE VNP FREE cmd returned 0x%x!\n",
540 FW_CMD_RETVAL_G(ntohl(rsp->alloc_to_len16)));
541 ret = -EINVAL;
542 }
543
544 out_free:
545 mempool_free(mbp, hw->mb_mempool);
546 out:
547 spin_unlock_irq(&hw->lock);
548 return ret;
549 }
550
551 static int
csio_vport_create(struct fc_vport * fc_vport,bool disable)552 csio_vport_create(struct fc_vport *fc_vport, bool disable)
553 {
554 struct Scsi_Host *shost = fc_vport->shost;
555 struct csio_lnode *pln = shost_priv(shost);
556 struct csio_lnode *ln = NULL;
557 struct csio_hw *hw = csio_lnode_to_hw(pln);
558 uint8_t wwn[8];
559 int ret = -1;
560
561 ln = csio_shost_init(hw, &fc_vport->dev, false, pln);
562 if (!ln)
563 goto error;
564
565 if (fc_vport->node_name != 0) {
566 u64_to_wwn(fc_vport->node_name, wwn);
567
568 if (!CSIO_VALID_WWN(wwn)) {
569 csio_ln_err(ln,
570 "vport create failed. Invalid wwnn\n");
571 goto error;
572 }
573 memcpy(csio_ln_wwnn(ln), wwn, 8);
574 }
575
576 if (fc_vport->port_name != 0) {
577 u64_to_wwn(fc_vport->port_name, wwn);
578
579 if (!CSIO_VALID_WWN(wwn)) {
580 csio_ln_err(ln,
581 "vport create failed. Invalid wwpn\n");
582 goto error;
583 }
584
585 if (csio_lnode_lookup_by_wwpn(hw, wwn)) {
586 csio_ln_err(ln,
587 "vport create failed. wwpn already exists\n");
588 goto error;
589 }
590 memcpy(csio_ln_wwpn(ln), wwn, 8);
591 }
592
593 fc_vport_set_state(fc_vport, FC_VPORT_INITIALIZING);
594 ln->fc_vport = fc_vport;
595
596 if (csio_fcoe_alloc_vnp(hw, ln))
597 goto error;
598
599 *(struct csio_lnode **)fc_vport->dd_data = ln;
600 if (!fc_vport->node_name)
601 fc_vport->node_name = wwn_to_u64(csio_ln_wwnn(ln));
602 if (!fc_vport->port_name)
603 fc_vport->port_name = wwn_to_u64(csio_ln_wwpn(ln));
604 csio_fchost_attr_init(ln);
605 return 0;
606 error:
607 if (ln)
608 csio_shost_exit(ln);
609
610 return ret;
611 }
612
613 static int
csio_vport_delete(struct fc_vport * fc_vport)614 csio_vport_delete(struct fc_vport *fc_vport)
615 {
616 struct csio_lnode *ln = *(struct csio_lnode **)fc_vport->dd_data;
617 struct Scsi_Host *shost = csio_ln_to_shost(ln);
618 struct csio_hw *hw = csio_lnode_to_hw(ln);
619 int rmv;
620
621 spin_lock_irq(&hw->lock);
622 rmv = csio_is_hw_removing(hw);
623 spin_unlock_irq(&hw->lock);
624
625 if (rmv) {
626 csio_shost_exit(ln);
627 return 0;
628 }
629
630 /* Quiesce ios and send remove event to lnode */
631 scsi_block_requests(shost);
632 spin_lock_irq(&hw->lock);
633 csio_scsim_cleanup_io_lnode(csio_hw_to_scsim(hw), ln);
634 csio_lnode_close(ln);
635 spin_unlock_irq(&hw->lock);
636 scsi_unblock_requests(shost);
637
638 /* Free vnp */
639 if (fc_vport->vport_state != FC_VPORT_DISABLED)
640 csio_fcoe_free_vnp(hw, ln);
641
642 csio_shost_exit(ln);
643 return 0;
644 }
645
646 static int
csio_vport_disable(struct fc_vport * fc_vport,bool disable)647 csio_vport_disable(struct fc_vport *fc_vport, bool disable)
648 {
649 struct csio_lnode *ln = *(struct csio_lnode **)fc_vport->dd_data;
650 struct Scsi_Host *shost = csio_ln_to_shost(ln);
651 struct csio_hw *hw = csio_lnode_to_hw(ln);
652
653 /* disable vport */
654 if (disable) {
655 /* Quiesce ios and send stop event to lnode */
656 scsi_block_requests(shost);
657 spin_lock_irq(&hw->lock);
658 csio_scsim_cleanup_io_lnode(csio_hw_to_scsim(hw), ln);
659 csio_lnode_stop(ln);
660 spin_unlock_irq(&hw->lock);
661 scsi_unblock_requests(shost);
662
663 /* Free vnp */
664 csio_fcoe_free_vnp(hw, ln);
665 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
666 csio_ln_err(ln, "vport disabled\n");
667 return 0;
668 } else {
669 /* enable vport */
670 fc_vport_set_state(fc_vport, FC_VPORT_INITIALIZING);
671 if (csio_fcoe_alloc_vnp(hw, ln)) {
672 csio_ln_err(ln, "vport enabled failed.\n");
673 return -1;
674 }
675 csio_ln_err(ln, "vport enabled\n");
676 return 0;
677 }
678 }
679
680 static void
csio_dev_loss_tmo_callbk(struct fc_rport * rport)681 csio_dev_loss_tmo_callbk(struct fc_rport *rport)
682 {
683 struct csio_rnode *rn;
684 struct csio_hw *hw;
685 struct csio_lnode *ln;
686
687 rn = *((struct csio_rnode **)rport->dd_data);
688 ln = csio_rnode_to_lnode(rn);
689 hw = csio_lnode_to_hw(ln);
690
691 spin_lock_irq(&hw->lock);
692
693 /* return if driver is being removed or same rnode comes back online */
694 if (csio_is_hw_removing(hw) || csio_is_rnode_ready(rn))
695 goto out;
696
697 csio_ln_dbg(ln, "devloss timeout on rnode:%p portid:x%x flowid:x%x\n",
698 rn, rn->nport_id, csio_rn_flowid(rn));
699
700 CSIO_INC_STATS(ln, n_dev_loss_tmo);
701
702 /*
703 * enqueue devloss event to event worker thread to serialize all
704 * rnode events.
705 */
706 if (csio_enqueue_evt(hw, CSIO_EVT_DEV_LOSS, &rn, sizeof(rn))) {
707 CSIO_INC_STATS(hw, n_evt_drop);
708 goto out;
709 }
710
711 if (!(hw->flags & CSIO_HWF_FWEVT_PENDING)) {
712 hw->flags |= CSIO_HWF_FWEVT_PENDING;
713 spin_unlock_irq(&hw->lock);
714 schedule_work(&hw->evtq_work);
715 return;
716 }
717
718 out:
719 spin_unlock_irq(&hw->lock);
720 }
721
722 /* FC transport functions template - Physical port */
723 struct fc_function_template csio_fc_transport_funcs = {
724 .show_host_node_name = 1,
725 .show_host_port_name = 1,
726 .show_host_supported_classes = 1,
727 .show_host_supported_fc4s = 1,
728 .show_host_maxframe_size = 1,
729
730 .get_host_port_id = csio_get_host_port_id,
731 .show_host_port_id = 1,
732
733 .get_host_port_type = csio_get_host_port_type,
734 .show_host_port_type = 1,
735
736 .get_host_port_state = csio_get_host_port_state,
737 .show_host_port_state = 1,
738
739 .show_host_active_fc4s = 1,
740 .get_host_speed = csio_get_host_speed,
741 .show_host_speed = 1,
742 .get_host_fabric_name = csio_get_host_fabric_name,
743 .show_host_fabric_name = 1,
744
745 .get_fc_host_stats = csio_get_stats,
746
747 .dd_fcrport_size = sizeof(struct csio_rnode *),
748 .show_rport_maxframe_size = 1,
749 .show_rport_supported_classes = 1,
750
751 .set_rport_dev_loss_tmo = csio_set_rport_loss_tmo,
752 .show_rport_dev_loss_tmo = 1,
753
754 .show_starget_port_id = 1,
755 .show_starget_node_name = 1,
756 .show_starget_port_name = 1,
757
758 .dev_loss_tmo_callbk = csio_dev_loss_tmo_callbk,
759 .dd_fcvport_size = sizeof(struct csio_lnode *),
760
761 .vport_create = csio_vport_create,
762 .vport_disable = csio_vport_disable,
763 .vport_delete = csio_vport_delete,
764 };
765
766 /* FC transport functions template - Virtual port */
767 struct fc_function_template csio_fc_transport_vport_funcs = {
768 .show_host_node_name = 1,
769 .show_host_port_name = 1,
770 .show_host_supported_classes = 1,
771 .show_host_supported_fc4s = 1,
772 .show_host_maxframe_size = 1,
773
774 .get_host_port_id = csio_get_host_port_id,
775 .show_host_port_id = 1,
776
777 .get_host_port_type = csio_get_host_port_type,
778 .show_host_port_type = 1,
779
780 .get_host_port_state = csio_get_host_port_state,
781 .show_host_port_state = 1,
782 .show_host_active_fc4s = 1,
783
784 .get_host_speed = csio_get_host_speed,
785 .show_host_speed = 1,
786
787 .get_host_fabric_name = csio_get_host_fabric_name,
788 .show_host_fabric_name = 1,
789
790 .get_fc_host_stats = csio_get_stats,
791
792 .dd_fcrport_size = sizeof(struct csio_rnode *),
793 .show_rport_maxframe_size = 1,
794 .show_rport_supported_classes = 1,
795
796 .set_rport_dev_loss_tmo = csio_set_rport_loss_tmo,
797 .show_rport_dev_loss_tmo = 1,
798
799 .show_starget_port_id = 1,
800 .show_starget_node_name = 1,
801 .show_starget_port_name = 1,
802
803 .dev_loss_tmo_callbk = csio_dev_loss_tmo_callbk,
804
805 };
806