1 /* 2 * Copyright 2008 Cisco Systems, Inc. All rights reserved. 3 * Copyright 2007 Nuova Systems, Inc. All rights reserved. 4 * 5 * This program is free software; you may redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; version 2 of the License. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 10 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 11 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 12 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 13 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 14 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 15 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 16 * SOFTWARE. 17 */ 18 #include <linux/errno.h> 19 #include <linux/pci.h> 20 #include <linux/slab.h> 21 #include <linux/skbuff.h> 22 #include <linux/interrupt.h> 23 #include <linux/spinlock.h> 24 #include <linux/if_ether.h> 25 #include <linux/if_vlan.h> 26 #include <linux/workqueue.h> 27 #include <scsi/fc/fc_fip.h> 28 #include <scsi/fc/fc_els.h> 29 #include <scsi/fc/fc_fcoe.h> 30 #include <scsi/fc_frame.h> 31 #include <scsi/libfc.h> 32 #include "fnic_io.h" 33 #include "fnic.h" 34 #include "fnic_fip.h" 35 #include "cq_enet_desc.h" 36 #include "cq_exch_desc.h" 37 38 static u8 fcoe_all_fcfs[ETH_ALEN] = FIP_ALL_FCF_MACS; 39 struct workqueue_struct *fnic_fip_queue; 40 struct workqueue_struct *fnic_event_queue; 41 42 static void fnic_set_eth_mode(struct fnic *); 43 static void fnic_fcoe_send_vlan_req(struct fnic *fnic); 44 static void fnic_fcoe_start_fcf_disc(struct fnic *fnic); 45 static void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct sk_buff *); 46 static int fnic_fcoe_vlan_check(struct fnic *fnic, u16 flag); 47 static int fnic_fcoe_handle_fip_frame(struct fnic *fnic, struct sk_buff *skb); 48 49 void fnic_handle_link(struct work_struct *work) 50 { 51 struct fnic *fnic = container_of(work, struct fnic, link_work); 52 unsigned long flags; 53 int old_link_status; 54 u32 old_link_down_cnt; 55 u64 old_port_speed, new_port_speed; 56 57 spin_lock_irqsave(&fnic->fnic_lock, flags); 58 59 fnic->link_events = 1; /* less work to just set everytime*/ 60 61 if (fnic->stop_rx_link_events) { 62 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 63 return; 64 } 65 66 old_link_down_cnt = fnic->link_down_cnt; 67 old_link_status = fnic->link_status; 68 old_port_speed = atomic64_read( 69 &fnic->fnic_stats.misc_stats.current_port_speed); 70 71 fnic->link_status = vnic_dev_link_status(fnic->vdev); 72 fnic->link_down_cnt = vnic_dev_link_down_cnt(fnic->vdev); 73 74 new_port_speed = vnic_dev_port_speed(fnic->vdev); 75 atomic64_set(&fnic->fnic_stats.misc_stats.current_port_speed, 76 new_port_speed); 77 if (old_port_speed != new_port_speed) 78 FNIC_MAIN_DBG(KERN_INFO, fnic->lport->host, 79 "Current vnic speed set to : %llu\n", 80 new_port_speed); 81 82 switch (vnic_dev_port_speed(fnic->vdev)) { 83 case DCEM_PORTSPEED_10G: 84 fc_host_speed(fnic->lport->host) = FC_PORTSPEED_10GBIT; 85 fnic->lport->link_supported_speeds = FC_PORTSPEED_10GBIT; 86 break; 87 case DCEM_PORTSPEED_20G: 88 fc_host_speed(fnic->lport->host) = FC_PORTSPEED_20GBIT; 89 fnic->lport->link_supported_speeds = FC_PORTSPEED_20GBIT; 90 break; 91 case DCEM_PORTSPEED_25G: 92 fc_host_speed(fnic->lport->host) = FC_PORTSPEED_25GBIT; 93 fnic->lport->link_supported_speeds = FC_PORTSPEED_25GBIT; 94 break; 95 case DCEM_PORTSPEED_40G: 96 case DCEM_PORTSPEED_4x10G: 97 fc_host_speed(fnic->lport->host) = FC_PORTSPEED_40GBIT; 98 fnic->lport->link_supported_speeds = FC_PORTSPEED_40GBIT; 99 break; 100 case DCEM_PORTSPEED_100G: 101 fc_host_speed(fnic->lport->host) = FC_PORTSPEED_100GBIT; 102 fnic->lport->link_supported_speeds = FC_PORTSPEED_100GBIT; 103 break; 104 default: 105 fc_host_speed(fnic->lport->host) = FC_PORTSPEED_UNKNOWN; 106 fnic->lport->link_supported_speeds = FC_PORTSPEED_UNKNOWN; 107 break; 108 } 109 110 if (old_link_status == fnic->link_status) { 111 if (!fnic->link_status) { 112 /* DOWN -> DOWN */ 113 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 114 fnic_fc_trace_set_data(fnic->lport->host->host_no, 115 FNIC_FC_LE, "Link Status: DOWN->DOWN", 116 strlen("Link Status: DOWN->DOWN")); 117 } else { 118 if (old_link_down_cnt != fnic->link_down_cnt) { 119 /* UP -> DOWN -> UP */ 120 fnic->lport->host_stats.link_failure_count++; 121 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 122 fnic_fc_trace_set_data( 123 fnic->lport->host->host_no, 124 FNIC_FC_LE, 125 "Link Status:UP_DOWN_UP", 126 strlen("Link_Status:UP_DOWN_UP") 127 ); 128 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 129 "link down\n"); 130 fcoe_ctlr_link_down(&fnic->ctlr); 131 if (fnic->config.flags & VFCF_FIP_CAPABLE) { 132 /* start FCoE VLAN discovery */ 133 fnic_fc_trace_set_data( 134 fnic->lport->host->host_no, 135 FNIC_FC_LE, 136 "Link Status: UP_DOWN_UP_VLAN", 137 strlen( 138 "Link Status: UP_DOWN_UP_VLAN") 139 ); 140 fnic_fcoe_send_vlan_req(fnic); 141 return; 142 } 143 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 144 "link up\n"); 145 fcoe_ctlr_link_up(&fnic->ctlr); 146 } else { 147 /* UP -> UP */ 148 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 149 fnic_fc_trace_set_data( 150 fnic->lport->host->host_no, FNIC_FC_LE, 151 "Link Status: UP_UP", 152 strlen("Link Status: UP_UP")); 153 } 154 } 155 } else if (fnic->link_status) { 156 /* DOWN -> UP */ 157 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 158 if (fnic->config.flags & VFCF_FIP_CAPABLE) { 159 /* start FCoE VLAN discovery */ 160 fnic_fc_trace_set_data( 161 fnic->lport->host->host_no, 162 FNIC_FC_LE, "Link Status: DOWN_UP_VLAN", 163 strlen("Link Status: DOWN_UP_VLAN")); 164 fnic_fcoe_send_vlan_req(fnic); 165 return; 166 } 167 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link up\n"); 168 fnic_fc_trace_set_data(fnic->lport->host->host_no, FNIC_FC_LE, 169 "Link Status: DOWN_UP", strlen("Link Status: DOWN_UP")); 170 fcoe_ctlr_link_up(&fnic->ctlr); 171 } else { 172 /* UP -> DOWN */ 173 fnic->lport->host_stats.link_failure_count++; 174 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 175 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link down\n"); 176 fnic_fc_trace_set_data( 177 fnic->lport->host->host_no, FNIC_FC_LE, 178 "Link Status: UP_DOWN", 179 strlen("Link Status: UP_DOWN")); 180 if (fnic->config.flags & VFCF_FIP_CAPABLE) { 181 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 182 "deleting fip-timer during link-down\n"); 183 del_timer_sync(&fnic->fip_timer); 184 } 185 fcoe_ctlr_link_down(&fnic->ctlr); 186 } 187 188 } 189 190 /* 191 * This function passes incoming fabric frames to libFC 192 */ 193 void fnic_handle_frame(struct work_struct *work) 194 { 195 struct fnic *fnic = container_of(work, struct fnic, frame_work); 196 struct fc_lport *lp = fnic->lport; 197 unsigned long flags; 198 struct sk_buff *skb; 199 struct fc_frame *fp; 200 201 while ((skb = skb_dequeue(&fnic->frame_queue))) { 202 203 spin_lock_irqsave(&fnic->fnic_lock, flags); 204 if (fnic->stop_rx_link_events) { 205 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 206 dev_kfree_skb(skb); 207 return; 208 } 209 fp = (struct fc_frame *)skb; 210 211 /* 212 * If we're in a transitional state, just re-queue and return. 213 * The queue will be serviced when we get to a stable state. 214 */ 215 if (fnic->state != FNIC_IN_FC_MODE && 216 fnic->state != FNIC_IN_ETH_MODE) { 217 skb_queue_head(&fnic->frame_queue, skb); 218 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 219 return; 220 } 221 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 222 223 fc_exch_recv(lp, fp); 224 } 225 } 226 227 void fnic_fcoe_evlist_free(struct fnic *fnic) 228 { 229 struct fnic_event *fevt = NULL; 230 struct fnic_event *next = NULL; 231 unsigned long flags; 232 233 spin_lock_irqsave(&fnic->fnic_lock, flags); 234 if (list_empty(&fnic->evlist)) { 235 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 236 return; 237 } 238 239 list_for_each_entry_safe(fevt, next, &fnic->evlist, list) { 240 list_del(&fevt->list); 241 kfree(fevt); 242 } 243 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 244 } 245 246 void fnic_handle_event(struct work_struct *work) 247 { 248 struct fnic *fnic = container_of(work, struct fnic, event_work); 249 struct fnic_event *fevt = NULL; 250 struct fnic_event *next = NULL; 251 unsigned long flags; 252 253 spin_lock_irqsave(&fnic->fnic_lock, flags); 254 if (list_empty(&fnic->evlist)) { 255 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 256 return; 257 } 258 259 list_for_each_entry_safe(fevt, next, &fnic->evlist, list) { 260 if (fnic->stop_rx_link_events) { 261 list_del(&fevt->list); 262 kfree(fevt); 263 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 264 return; 265 } 266 /* 267 * If we're in a transitional state, just re-queue and return. 268 * The queue will be serviced when we get to a stable state. 269 */ 270 if (fnic->state != FNIC_IN_FC_MODE && 271 fnic->state != FNIC_IN_ETH_MODE) { 272 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 273 return; 274 } 275 276 list_del(&fevt->list); 277 switch (fevt->event) { 278 case FNIC_EVT_START_VLAN_DISC: 279 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 280 fnic_fcoe_send_vlan_req(fnic); 281 spin_lock_irqsave(&fnic->fnic_lock, flags); 282 break; 283 case FNIC_EVT_START_FCF_DISC: 284 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 285 "Start FCF Discovery\n"); 286 fnic_fcoe_start_fcf_disc(fnic); 287 break; 288 default: 289 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 290 "Unknown event 0x%x\n", fevt->event); 291 break; 292 } 293 kfree(fevt); 294 } 295 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 296 } 297 298 /** 299 * Check if the Received FIP FLOGI frame is rejected 300 * @fip: The FCoE controller that received the frame 301 * @skb: The received FIP frame 302 * 303 * Returns non-zero if the frame is rejected with unsupported cmd with 304 * insufficient resource els explanation. 305 */ 306 static inline int is_fnic_fip_flogi_reject(struct fcoe_ctlr *fip, 307 struct sk_buff *skb) 308 { 309 struct fc_lport *lport = fip->lp; 310 struct fip_header *fiph; 311 struct fc_frame_header *fh = NULL; 312 struct fip_desc *desc; 313 struct fip_encaps *els; 314 u16 op; 315 u8 els_op; 316 u8 sub; 317 318 size_t rlen; 319 size_t dlen = 0; 320 321 if (skb_linearize(skb)) 322 return 0; 323 324 if (skb->len < sizeof(*fiph)) 325 return 0; 326 327 fiph = (struct fip_header *)skb->data; 328 op = ntohs(fiph->fip_op); 329 sub = fiph->fip_subcode; 330 331 if (op != FIP_OP_LS) 332 return 0; 333 334 if (sub != FIP_SC_REP) 335 return 0; 336 337 rlen = ntohs(fiph->fip_dl_len) * 4; 338 if (rlen + sizeof(*fiph) > skb->len) 339 return 0; 340 341 desc = (struct fip_desc *)(fiph + 1); 342 dlen = desc->fip_dlen * FIP_BPW; 343 344 if (desc->fip_dtype == FIP_DT_FLOGI) { 345 346 if (dlen < sizeof(*els) + sizeof(*fh) + 1) 347 return 0; 348 349 els = (struct fip_encaps *)desc; 350 fh = (struct fc_frame_header *)(els + 1); 351 352 if (!fh) 353 return 0; 354 355 /* 356 * ELS command code, reason and explanation should be = Reject, 357 * unsupported command and insufficient resource 358 */ 359 els_op = *(u8 *)(fh + 1); 360 if (els_op == ELS_LS_RJT) { 361 shost_printk(KERN_INFO, lport->host, 362 "Flogi Request Rejected by Switch\n"); 363 return 1; 364 } 365 shost_printk(KERN_INFO, lport->host, 366 "Flogi Request Accepted by Switch\n"); 367 } 368 return 0; 369 } 370 371 static void fnic_fcoe_send_vlan_req(struct fnic *fnic) 372 { 373 struct fcoe_ctlr *fip = &fnic->ctlr; 374 struct fnic_stats *fnic_stats = &fnic->fnic_stats; 375 struct sk_buff *skb; 376 char *eth_fr; 377 struct fip_vlan *vlan; 378 u64 vlan_tov; 379 380 fnic_fcoe_reset_vlans(fnic); 381 fnic->set_vlan(fnic, 0); 382 383 if (printk_ratelimit()) 384 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, 385 "Sending VLAN request...\n"); 386 387 skb = dev_alloc_skb(sizeof(struct fip_vlan)); 388 if (!skb) 389 return; 390 391 eth_fr = (char *)skb->data; 392 vlan = (struct fip_vlan *)eth_fr; 393 394 memset(vlan, 0, sizeof(*vlan)); 395 memcpy(vlan->eth.h_source, fip->ctl_src_addr, ETH_ALEN); 396 memcpy(vlan->eth.h_dest, fcoe_all_fcfs, ETH_ALEN); 397 vlan->eth.h_proto = htons(ETH_P_FIP); 398 399 vlan->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER); 400 vlan->fip.fip_op = htons(FIP_OP_VLAN); 401 vlan->fip.fip_subcode = FIP_SC_VL_REQ; 402 vlan->fip.fip_dl_len = htons(sizeof(vlan->desc) / FIP_BPW); 403 404 vlan->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC; 405 vlan->desc.mac.fd_desc.fip_dlen = sizeof(vlan->desc.mac) / FIP_BPW; 406 memcpy(&vlan->desc.mac.fd_mac, fip->ctl_src_addr, ETH_ALEN); 407 408 vlan->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME; 409 vlan->desc.wwnn.fd_desc.fip_dlen = sizeof(vlan->desc.wwnn) / FIP_BPW; 410 put_unaligned_be64(fip->lp->wwnn, &vlan->desc.wwnn.fd_wwn); 411 atomic64_inc(&fnic_stats->vlan_stats.vlan_disc_reqs); 412 413 skb_put(skb, sizeof(*vlan)); 414 skb->protocol = htons(ETH_P_FIP); 415 skb_reset_mac_header(skb); 416 skb_reset_network_header(skb); 417 fip->send(fip, skb); 418 419 /* set a timer so that we can retry if there no response */ 420 vlan_tov = jiffies + msecs_to_jiffies(FCOE_CTLR_FIPVLAN_TOV); 421 mod_timer(&fnic->fip_timer, round_jiffies(vlan_tov)); 422 } 423 424 static void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct sk_buff *skb) 425 { 426 struct fcoe_ctlr *fip = &fnic->ctlr; 427 struct fip_header *fiph; 428 struct fip_desc *desc; 429 struct fnic_stats *fnic_stats = &fnic->fnic_stats; 430 u16 vid; 431 size_t rlen; 432 size_t dlen; 433 struct fcoe_vlan *vlan; 434 u64 sol_time; 435 unsigned long flags; 436 437 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, 438 "Received VLAN response...\n"); 439 440 fiph = (struct fip_header *) skb->data; 441 442 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, 443 "Received VLAN response... OP 0x%x SUB_OP 0x%x\n", 444 ntohs(fiph->fip_op), fiph->fip_subcode); 445 446 rlen = ntohs(fiph->fip_dl_len) * 4; 447 fnic_fcoe_reset_vlans(fnic); 448 spin_lock_irqsave(&fnic->vlans_lock, flags); 449 desc = (struct fip_desc *)(fiph + 1); 450 while (rlen > 0) { 451 dlen = desc->fip_dlen * FIP_BPW; 452 switch (desc->fip_dtype) { 453 case FIP_DT_VLAN: 454 vid = ntohs(((struct fip_vlan_desc *)desc)->fd_vlan); 455 shost_printk(KERN_INFO, fnic->lport->host, 456 "process_vlan_resp: FIP VLAN %d\n", vid); 457 vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC); 458 if (!vlan) { 459 /* retry from timer */ 460 spin_unlock_irqrestore(&fnic->vlans_lock, 461 flags); 462 goto out; 463 } 464 vlan->vid = vid & 0x0fff; 465 vlan->state = FIP_VLAN_AVAIL; 466 list_add_tail(&vlan->list, &fnic->vlans); 467 break; 468 } 469 desc = (struct fip_desc *)((char *)desc + dlen); 470 rlen -= dlen; 471 } 472 473 /* any VLAN descriptors present ? */ 474 if (list_empty(&fnic->vlans)) { 475 /* retry from timer */ 476 atomic64_inc(&fnic_stats->vlan_stats.resp_withno_vlanID); 477 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, 478 "No VLAN descriptors in FIP VLAN response\n"); 479 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 480 goto out; 481 } 482 483 vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list); 484 fnic->set_vlan(fnic, vlan->vid); 485 vlan->state = FIP_VLAN_SENT; /* sent now */ 486 vlan->sol_count++; 487 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 488 489 /* start the solicitation */ 490 fcoe_ctlr_link_up(fip); 491 492 sol_time = jiffies + msecs_to_jiffies(FCOE_CTLR_START_DELAY); 493 mod_timer(&fnic->fip_timer, round_jiffies(sol_time)); 494 out: 495 return; 496 } 497 498 static void fnic_fcoe_start_fcf_disc(struct fnic *fnic) 499 { 500 unsigned long flags; 501 struct fcoe_vlan *vlan; 502 u64 sol_time; 503 504 spin_lock_irqsave(&fnic->vlans_lock, flags); 505 vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list); 506 fnic->set_vlan(fnic, vlan->vid); 507 vlan->state = FIP_VLAN_SENT; /* sent now */ 508 vlan->sol_count = 1; 509 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 510 511 /* start the solicitation */ 512 fcoe_ctlr_link_up(&fnic->ctlr); 513 514 sol_time = jiffies + msecs_to_jiffies(FCOE_CTLR_START_DELAY); 515 mod_timer(&fnic->fip_timer, round_jiffies(sol_time)); 516 } 517 518 static int fnic_fcoe_vlan_check(struct fnic *fnic, u16 flag) 519 { 520 unsigned long flags; 521 struct fcoe_vlan *fvlan; 522 523 spin_lock_irqsave(&fnic->vlans_lock, flags); 524 if (list_empty(&fnic->vlans)) { 525 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 526 return -EINVAL; 527 } 528 529 fvlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list); 530 if (fvlan->state == FIP_VLAN_USED) { 531 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 532 return 0; 533 } 534 535 if (fvlan->state == FIP_VLAN_SENT) { 536 fvlan->state = FIP_VLAN_USED; 537 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 538 return 0; 539 } 540 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 541 return -EINVAL; 542 } 543 544 static void fnic_event_enq(struct fnic *fnic, enum fnic_evt ev) 545 { 546 struct fnic_event *fevt; 547 unsigned long flags; 548 549 fevt = kmalloc(sizeof(*fevt), GFP_ATOMIC); 550 if (!fevt) 551 return; 552 553 fevt->fnic = fnic; 554 fevt->event = ev; 555 556 spin_lock_irqsave(&fnic->fnic_lock, flags); 557 list_add_tail(&fevt->list, &fnic->evlist); 558 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 559 560 schedule_work(&fnic->event_work); 561 } 562 563 static int fnic_fcoe_handle_fip_frame(struct fnic *fnic, struct sk_buff *skb) 564 { 565 struct fip_header *fiph; 566 int ret = 1; 567 u16 op; 568 u8 sub; 569 570 if (!skb || !(skb->data)) 571 return -1; 572 573 if (skb_linearize(skb)) 574 goto drop; 575 576 fiph = (struct fip_header *)skb->data; 577 op = ntohs(fiph->fip_op); 578 sub = fiph->fip_subcode; 579 580 if (FIP_VER_DECAPS(fiph->fip_ver) != FIP_VER) 581 goto drop; 582 583 if (ntohs(fiph->fip_dl_len) * FIP_BPW + sizeof(*fiph) > skb->len) 584 goto drop; 585 586 if (op == FIP_OP_DISC && sub == FIP_SC_ADV) { 587 if (fnic_fcoe_vlan_check(fnic, ntohs(fiph->fip_flags))) 588 goto drop; 589 /* pass it on to fcoe */ 590 ret = 1; 591 } else if (op == FIP_OP_VLAN && sub == FIP_SC_VL_NOTE) { 592 /* set the vlan as used */ 593 fnic_fcoe_process_vlan_resp(fnic, skb); 594 ret = 0; 595 } else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK) { 596 /* received CVL request, restart vlan disc */ 597 fnic_event_enq(fnic, FNIC_EVT_START_VLAN_DISC); 598 /* pass it on to fcoe */ 599 ret = 1; 600 } 601 drop: 602 return ret; 603 } 604 605 void fnic_handle_fip_frame(struct work_struct *work) 606 { 607 struct fnic *fnic = container_of(work, struct fnic, fip_frame_work); 608 struct fnic_stats *fnic_stats = &fnic->fnic_stats; 609 unsigned long flags; 610 struct sk_buff *skb; 611 struct ethhdr *eh; 612 613 while ((skb = skb_dequeue(&fnic->fip_frame_queue))) { 614 spin_lock_irqsave(&fnic->fnic_lock, flags); 615 if (fnic->stop_rx_link_events) { 616 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 617 dev_kfree_skb(skb); 618 return; 619 } 620 /* 621 * If we're in a transitional state, just re-queue and return. 622 * The queue will be serviced when we get to a stable state. 623 */ 624 if (fnic->state != FNIC_IN_FC_MODE && 625 fnic->state != FNIC_IN_ETH_MODE) { 626 skb_queue_head(&fnic->fip_frame_queue, skb); 627 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 628 return; 629 } 630 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 631 eh = (struct ethhdr *)skb->data; 632 if (eh->h_proto == htons(ETH_P_FIP)) { 633 skb_pull(skb, sizeof(*eh)); 634 if (fnic_fcoe_handle_fip_frame(fnic, skb) <= 0) { 635 dev_kfree_skb(skb); 636 continue; 637 } 638 /* 639 * If there's FLOGI rejects - clear all 640 * fcf's & restart from scratch 641 */ 642 if (is_fnic_fip_flogi_reject(&fnic->ctlr, skb)) { 643 atomic64_inc( 644 &fnic_stats->vlan_stats.flogi_rejects); 645 shost_printk(KERN_INFO, fnic->lport->host, 646 "Trigger a Link down - VLAN Disc\n"); 647 fcoe_ctlr_link_down(&fnic->ctlr); 648 /* start FCoE VLAN discovery */ 649 fnic_fcoe_send_vlan_req(fnic); 650 dev_kfree_skb(skb); 651 continue; 652 } 653 fcoe_ctlr_recv(&fnic->ctlr, skb); 654 continue; 655 } 656 } 657 } 658 659 /** 660 * fnic_import_rq_eth_pkt() - handle received FCoE or FIP frame. 661 * @fnic: fnic instance. 662 * @skb: Ethernet Frame. 663 */ 664 static inline int fnic_import_rq_eth_pkt(struct fnic *fnic, struct sk_buff *skb) 665 { 666 struct fc_frame *fp; 667 struct ethhdr *eh; 668 struct fcoe_hdr *fcoe_hdr; 669 struct fcoe_crc_eof *ft; 670 671 /* 672 * Undo VLAN encapsulation if present. 673 */ 674 eh = (struct ethhdr *)skb->data; 675 if (eh->h_proto == htons(ETH_P_8021Q)) { 676 memmove((u8 *)eh + VLAN_HLEN, eh, ETH_ALEN * 2); 677 eh = skb_pull(skb, VLAN_HLEN); 678 skb_reset_mac_header(skb); 679 } 680 if (eh->h_proto == htons(ETH_P_FIP)) { 681 if (!(fnic->config.flags & VFCF_FIP_CAPABLE)) { 682 printk(KERN_ERR "Dropped FIP frame, as firmware " 683 "uses non-FIP mode, Enable FIP " 684 "using UCSM\n"); 685 goto drop; 686 } 687 if ((fnic_fc_trace_set_data(fnic->lport->host->host_no, 688 FNIC_FC_RECV|0x80, (char *)skb->data, skb->len)) != 0) { 689 printk(KERN_ERR "fnic ctlr frame trace error!!!"); 690 } 691 skb_queue_tail(&fnic->fip_frame_queue, skb); 692 queue_work(fnic_fip_queue, &fnic->fip_frame_work); 693 return 1; /* let caller know packet was used */ 694 } 695 if (eh->h_proto != htons(ETH_P_FCOE)) 696 goto drop; 697 skb_set_network_header(skb, sizeof(*eh)); 698 skb_pull(skb, sizeof(*eh)); 699 700 fcoe_hdr = (struct fcoe_hdr *)skb->data; 701 if (FC_FCOE_DECAPS_VER(fcoe_hdr) != FC_FCOE_VER) 702 goto drop; 703 704 fp = (struct fc_frame *)skb; 705 fc_frame_init(fp); 706 fr_sof(fp) = fcoe_hdr->fcoe_sof; 707 skb_pull(skb, sizeof(struct fcoe_hdr)); 708 skb_reset_transport_header(skb); 709 710 ft = (struct fcoe_crc_eof *)(skb->data + skb->len - sizeof(*ft)); 711 fr_eof(fp) = ft->fcoe_eof; 712 skb_trim(skb, skb->len - sizeof(*ft)); 713 return 0; 714 drop: 715 dev_kfree_skb_irq(skb); 716 return -1; 717 } 718 719 /** 720 * fnic_update_mac_locked() - set data MAC address and filters. 721 * @fnic: fnic instance. 722 * @new: newly-assigned FCoE MAC address. 723 * 724 * Called with the fnic lock held. 725 */ 726 void fnic_update_mac_locked(struct fnic *fnic, u8 *new) 727 { 728 u8 *ctl = fnic->ctlr.ctl_src_addr; 729 u8 *data = fnic->data_src_addr; 730 731 if (is_zero_ether_addr(new)) 732 new = ctl; 733 if (ether_addr_equal(data, new)) 734 return; 735 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "update_mac %pM\n", new); 736 if (!is_zero_ether_addr(data) && !ether_addr_equal(data, ctl)) 737 vnic_dev_del_addr(fnic->vdev, data); 738 memcpy(data, new, ETH_ALEN); 739 if (!ether_addr_equal(new, ctl)) 740 vnic_dev_add_addr(fnic->vdev, new); 741 } 742 743 /** 744 * fnic_update_mac() - set data MAC address and filters. 745 * @lport: local port. 746 * @new: newly-assigned FCoE MAC address. 747 */ 748 void fnic_update_mac(struct fc_lport *lport, u8 *new) 749 { 750 struct fnic *fnic = lport_priv(lport); 751 752 spin_lock_irq(&fnic->fnic_lock); 753 fnic_update_mac_locked(fnic, new); 754 spin_unlock_irq(&fnic->fnic_lock); 755 } 756 757 /** 758 * fnic_set_port_id() - set the port_ID after successful FLOGI. 759 * @lport: local port. 760 * @port_id: assigned FC_ID. 761 * @fp: received frame containing the FLOGI accept or NULL. 762 * 763 * This is called from libfc when a new FC_ID has been assigned. 764 * This causes us to reset the firmware to FC_MODE and setup the new MAC 765 * address and FC_ID. 766 * 767 * It is also called with FC_ID 0 when we're logged off. 768 * 769 * If the FC_ID is due to point-to-point, fp may be NULL. 770 */ 771 void fnic_set_port_id(struct fc_lport *lport, u32 port_id, struct fc_frame *fp) 772 { 773 struct fnic *fnic = lport_priv(lport); 774 u8 *mac; 775 int ret; 776 777 FNIC_FCS_DBG(KERN_DEBUG, lport->host, "set port_id %x fp %p\n", 778 port_id, fp); 779 780 /* 781 * If we're clearing the FC_ID, change to use the ctl_src_addr. 782 * Set ethernet mode to send FLOGI. 783 */ 784 if (!port_id) { 785 fnic_update_mac(lport, fnic->ctlr.ctl_src_addr); 786 fnic_set_eth_mode(fnic); 787 return; 788 } 789 790 if (fp) { 791 mac = fr_cb(fp)->granted_mac; 792 if (is_zero_ether_addr(mac)) { 793 /* non-FIP - FLOGI already accepted - ignore return */ 794 fcoe_ctlr_recv_flogi(&fnic->ctlr, lport, fp); 795 } 796 fnic_update_mac(lport, mac); 797 } 798 799 /* Change state to reflect transition to FC mode */ 800 spin_lock_irq(&fnic->fnic_lock); 801 if (fnic->state == FNIC_IN_ETH_MODE || fnic->state == FNIC_IN_FC_MODE) 802 fnic->state = FNIC_IN_ETH_TRANS_FC_MODE; 803 else { 804 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 805 "Unexpected fnic state %s while" 806 " processing flogi resp\n", 807 fnic_state_to_str(fnic->state)); 808 spin_unlock_irq(&fnic->fnic_lock); 809 return; 810 } 811 spin_unlock_irq(&fnic->fnic_lock); 812 813 /* 814 * Send FLOGI registration to firmware to set up FC mode. 815 * The new address will be set up when registration completes. 816 */ 817 ret = fnic_flogi_reg_handler(fnic, port_id); 818 819 if (ret < 0) { 820 spin_lock_irq(&fnic->fnic_lock); 821 if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE) 822 fnic->state = FNIC_IN_ETH_MODE; 823 spin_unlock_irq(&fnic->fnic_lock); 824 } 825 } 826 827 static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc 828 *cq_desc, struct vnic_rq_buf *buf, 829 int skipped __attribute__((unused)), 830 void *opaque) 831 { 832 struct fnic *fnic = vnic_dev_priv(rq->vdev); 833 struct sk_buff *skb; 834 struct fc_frame *fp; 835 struct fnic_stats *fnic_stats = &fnic->fnic_stats; 836 u8 type, color, eop, sop, ingress_port, vlan_stripped; 837 u8 fcoe = 0, fcoe_sof, fcoe_eof; 838 u8 fcoe_fc_crc_ok = 1, fcoe_enc_error = 0; 839 u8 tcp_udp_csum_ok, udp, tcp, ipv4_csum_ok; 840 u8 ipv6, ipv4, ipv4_fragment, rss_type, csum_not_calc; 841 u8 fcs_ok = 1, packet_error = 0; 842 u16 q_number, completed_index, bytes_written = 0, vlan, checksum; 843 u32 rss_hash; 844 u16 exchange_id, tmpl; 845 u8 sof = 0; 846 u8 eof = 0; 847 u32 fcp_bytes_written = 0; 848 unsigned long flags; 849 850 dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len, 851 DMA_FROM_DEVICE); 852 skb = buf->os_buf; 853 fp = (struct fc_frame *)skb; 854 buf->os_buf = NULL; 855 856 cq_desc_dec(cq_desc, &type, &color, &q_number, &completed_index); 857 if (type == CQ_DESC_TYPE_RQ_FCP) { 858 cq_fcp_rq_desc_dec((struct cq_fcp_rq_desc *)cq_desc, 859 &type, &color, &q_number, &completed_index, 860 &eop, &sop, &fcoe_fc_crc_ok, &exchange_id, 861 &tmpl, &fcp_bytes_written, &sof, &eof, 862 &ingress_port, &packet_error, 863 &fcoe_enc_error, &fcs_ok, &vlan_stripped, 864 &vlan); 865 skb_trim(skb, fcp_bytes_written); 866 fr_sof(fp) = sof; 867 fr_eof(fp) = eof; 868 869 } else if (type == CQ_DESC_TYPE_RQ_ENET) { 870 cq_enet_rq_desc_dec((struct cq_enet_rq_desc *)cq_desc, 871 &type, &color, &q_number, &completed_index, 872 &ingress_port, &fcoe, &eop, &sop, 873 &rss_type, &csum_not_calc, &rss_hash, 874 &bytes_written, &packet_error, 875 &vlan_stripped, &vlan, &checksum, 876 &fcoe_sof, &fcoe_fc_crc_ok, 877 &fcoe_enc_error, &fcoe_eof, 878 &tcp_udp_csum_ok, &udp, &tcp, 879 &ipv4_csum_ok, &ipv6, &ipv4, 880 &ipv4_fragment, &fcs_ok); 881 skb_trim(skb, bytes_written); 882 if (!fcs_ok) { 883 atomic64_inc(&fnic_stats->misc_stats.frame_errors); 884 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 885 "fcs error. dropping packet.\n"); 886 goto drop; 887 } 888 if (fnic_import_rq_eth_pkt(fnic, skb)) 889 return; 890 891 } else { 892 /* wrong CQ type*/ 893 shost_printk(KERN_ERR, fnic->lport->host, 894 "fnic rq_cmpl wrong cq type x%x\n", type); 895 goto drop; 896 } 897 898 if (!fcs_ok || packet_error || !fcoe_fc_crc_ok || fcoe_enc_error) { 899 atomic64_inc(&fnic_stats->misc_stats.frame_errors); 900 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 901 "fnic rq_cmpl fcoe x%x fcsok x%x" 902 " pkterr x%x fcoe_fc_crc_ok x%x, fcoe_enc_err" 903 " x%x\n", 904 fcoe, fcs_ok, packet_error, 905 fcoe_fc_crc_ok, fcoe_enc_error); 906 goto drop; 907 } 908 909 spin_lock_irqsave(&fnic->fnic_lock, flags); 910 if (fnic->stop_rx_link_events) { 911 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 912 goto drop; 913 } 914 fr_dev(fp) = fnic->lport; 915 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 916 if ((fnic_fc_trace_set_data(fnic->lport->host->host_no, FNIC_FC_RECV, 917 (char *)skb->data, skb->len)) != 0) { 918 printk(KERN_ERR "fnic ctlr frame trace error!!!"); 919 } 920 921 skb_queue_tail(&fnic->frame_queue, skb); 922 queue_work(fnic_event_queue, &fnic->frame_work); 923 924 return; 925 drop: 926 dev_kfree_skb_irq(skb); 927 } 928 929 static int fnic_rq_cmpl_handler_cont(struct vnic_dev *vdev, 930 struct cq_desc *cq_desc, u8 type, 931 u16 q_number, u16 completed_index, 932 void *opaque) 933 { 934 struct fnic *fnic = vnic_dev_priv(vdev); 935 936 vnic_rq_service(&fnic->rq[q_number], cq_desc, completed_index, 937 VNIC_RQ_RETURN_DESC, fnic_rq_cmpl_frame_recv, 938 NULL); 939 return 0; 940 } 941 942 int fnic_rq_cmpl_handler(struct fnic *fnic, int rq_work_to_do) 943 { 944 unsigned int tot_rq_work_done = 0, cur_work_done; 945 unsigned int i; 946 int err; 947 948 for (i = 0; i < fnic->rq_count; i++) { 949 cur_work_done = vnic_cq_service(&fnic->cq[i], rq_work_to_do, 950 fnic_rq_cmpl_handler_cont, 951 NULL); 952 if (cur_work_done) { 953 err = vnic_rq_fill(&fnic->rq[i], fnic_alloc_rq_frame); 954 if (err) 955 shost_printk(KERN_ERR, fnic->lport->host, 956 "fnic_alloc_rq_frame can't alloc" 957 " frame\n"); 958 } 959 tot_rq_work_done += cur_work_done; 960 } 961 962 return tot_rq_work_done; 963 } 964 965 /* 966 * This function is called once at init time to allocate and fill RQ 967 * buffers. Subsequently, it is called in the interrupt context after RQ 968 * buffer processing to replenish the buffers in the RQ 969 */ 970 int fnic_alloc_rq_frame(struct vnic_rq *rq) 971 { 972 struct fnic *fnic = vnic_dev_priv(rq->vdev); 973 struct sk_buff *skb; 974 u16 len; 975 dma_addr_t pa; 976 int r; 977 978 len = FC_FRAME_HEADROOM + FC_MAX_FRAME + FC_FRAME_TAILROOM; 979 skb = dev_alloc_skb(len); 980 if (!skb) { 981 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 982 "Unable to allocate RQ sk_buff\n"); 983 return -ENOMEM; 984 } 985 skb_reset_mac_header(skb); 986 skb_reset_transport_header(skb); 987 skb_reset_network_header(skb); 988 skb_put(skb, len); 989 pa = dma_map_single(&fnic->pdev->dev, skb->data, len, DMA_FROM_DEVICE); 990 if (dma_mapping_error(&fnic->pdev->dev, pa)) { 991 r = -ENOMEM; 992 printk(KERN_ERR "PCI mapping failed with error %d\n", r); 993 goto free_skb; 994 } 995 996 fnic_queue_rq_desc(rq, skb, pa, len); 997 return 0; 998 999 free_skb: 1000 kfree_skb(skb); 1001 return r; 1002 } 1003 1004 void fnic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf) 1005 { 1006 struct fc_frame *fp = buf->os_buf; 1007 struct fnic *fnic = vnic_dev_priv(rq->vdev); 1008 1009 dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len, 1010 DMA_FROM_DEVICE); 1011 1012 dev_kfree_skb(fp_skb(fp)); 1013 buf->os_buf = NULL; 1014 } 1015 1016 /** 1017 * fnic_eth_send() - Send Ethernet frame. 1018 * @fip: fcoe_ctlr instance. 1019 * @skb: Ethernet Frame, FIP, without VLAN encapsulation. 1020 */ 1021 void fnic_eth_send(struct fcoe_ctlr *fip, struct sk_buff *skb) 1022 { 1023 struct fnic *fnic = fnic_from_ctlr(fip); 1024 struct vnic_wq *wq = &fnic->wq[0]; 1025 dma_addr_t pa; 1026 struct ethhdr *eth_hdr; 1027 struct vlan_ethhdr *vlan_hdr; 1028 unsigned long flags; 1029 1030 if (!fnic->vlan_hw_insert) { 1031 eth_hdr = (struct ethhdr *)skb_mac_header(skb); 1032 vlan_hdr = skb_push(skb, sizeof(*vlan_hdr) - sizeof(*eth_hdr)); 1033 memcpy(vlan_hdr, eth_hdr, 2 * ETH_ALEN); 1034 vlan_hdr->h_vlan_proto = htons(ETH_P_8021Q); 1035 vlan_hdr->h_vlan_encapsulated_proto = eth_hdr->h_proto; 1036 vlan_hdr->h_vlan_TCI = htons(fnic->vlan_id); 1037 if ((fnic_fc_trace_set_data(fnic->lport->host->host_no, 1038 FNIC_FC_SEND|0x80, (char *)eth_hdr, skb->len)) != 0) { 1039 printk(KERN_ERR "fnic ctlr frame trace error!!!"); 1040 } 1041 } else { 1042 if ((fnic_fc_trace_set_data(fnic->lport->host->host_no, 1043 FNIC_FC_SEND|0x80, (char *)skb->data, skb->len)) != 0) { 1044 printk(KERN_ERR "fnic ctlr frame trace error!!!"); 1045 } 1046 } 1047 1048 pa = dma_map_single(&fnic->pdev->dev, skb->data, skb->len, 1049 DMA_TO_DEVICE); 1050 if (dma_mapping_error(&fnic->pdev->dev, pa)) { 1051 printk(KERN_ERR "DMA mapping failed\n"); 1052 goto free_skb; 1053 } 1054 1055 spin_lock_irqsave(&fnic->wq_lock[0], flags); 1056 if (!vnic_wq_desc_avail(wq)) 1057 goto irq_restore; 1058 1059 fnic_queue_wq_eth_desc(wq, skb, pa, skb->len, 1060 0 /* hw inserts cos value */, 1061 fnic->vlan_id, 1); 1062 spin_unlock_irqrestore(&fnic->wq_lock[0], flags); 1063 return; 1064 1065 irq_restore: 1066 spin_unlock_irqrestore(&fnic->wq_lock[0], flags); 1067 dma_unmap_single(&fnic->pdev->dev, pa, skb->len, DMA_TO_DEVICE); 1068 free_skb: 1069 kfree_skb(skb); 1070 } 1071 1072 /* 1073 * Send FC frame. 1074 */ 1075 static int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp) 1076 { 1077 struct vnic_wq *wq = &fnic->wq[0]; 1078 struct sk_buff *skb; 1079 dma_addr_t pa; 1080 struct ethhdr *eth_hdr; 1081 struct vlan_ethhdr *vlan_hdr; 1082 struct fcoe_hdr *fcoe_hdr; 1083 struct fc_frame_header *fh; 1084 u32 tot_len, eth_hdr_len; 1085 int ret = 0; 1086 unsigned long flags; 1087 1088 fh = fc_frame_header_get(fp); 1089 skb = fp_skb(fp); 1090 1091 if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ) && 1092 fcoe_ctlr_els_send(&fnic->ctlr, fnic->lport, skb)) 1093 return 0; 1094 1095 if (!fnic->vlan_hw_insert) { 1096 eth_hdr_len = sizeof(*vlan_hdr) + sizeof(*fcoe_hdr); 1097 vlan_hdr = skb_push(skb, eth_hdr_len); 1098 eth_hdr = (struct ethhdr *)vlan_hdr; 1099 vlan_hdr->h_vlan_proto = htons(ETH_P_8021Q); 1100 vlan_hdr->h_vlan_encapsulated_proto = htons(ETH_P_FCOE); 1101 vlan_hdr->h_vlan_TCI = htons(fnic->vlan_id); 1102 fcoe_hdr = (struct fcoe_hdr *)(vlan_hdr + 1); 1103 } else { 1104 eth_hdr_len = sizeof(*eth_hdr) + sizeof(*fcoe_hdr); 1105 eth_hdr = skb_push(skb, eth_hdr_len); 1106 eth_hdr->h_proto = htons(ETH_P_FCOE); 1107 fcoe_hdr = (struct fcoe_hdr *)(eth_hdr + 1); 1108 } 1109 1110 if (fnic->ctlr.map_dest) 1111 fc_fcoe_set_mac(eth_hdr->h_dest, fh->fh_d_id); 1112 else 1113 memcpy(eth_hdr->h_dest, fnic->ctlr.dest_addr, ETH_ALEN); 1114 memcpy(eth_hdr->h_source, fnic->data_src_addr, ETH_ALEN); 1115 1116 tot_len = skb->len; 1117 BUG_ON(tot_len % 4); 1118 1119 memset(fcoe_hdr, 0, sizeof(*fcoe_hdr)); 1120 fcoe_hdr->fcoe_sof = fr_sof(fp); 1121 if (FC_FCOE_VER) 1122 FC_FCOE_ENCAPS_VER(fcoe_hdr, FC_FCOE_VER); 1123 1124 pa = dma_map_single(&fnic->pdev->dev, eth_hdr, tot_len, DMA_TO_DEVICE); 1125 if (dma_mapping_error(&fnic->pdev->dev, pa)) { 1126 ret = -ENOMEM; 1127 printk(KERN_ERR "DMA map failed with error %d\n", ret); 1128 goto free_skb_on_err; 1129 } 1130 1131 if ((fnic_fc_trace_set_data(fnic->lport->host->host_no, FNIC_FC_SEND, 1132 (char *)eth_hdr, tot_len)) != 0) { 1133 printk(KERN_ERR "fnic ctlr frame trace error!!!"); 1134 } 1135 1136 spin_lock_irqsave(&fnic->wq_lock[0], flags); 1137 1138 if (!vnic_wq_desc_avail(wq)) { 1139 dma_unmap_single(&fnic->pdev->dev, pa, tot_len, DMA_TO_DEVICE); 1140 ret = -1; 1141 goto irq_restore; 1142 } 1143 1144 fnic_queue_wq_desc(wq, skb, pa, tot_len, fr_eof(fp), 1145 0 /* hw inserts cos value */, 1146 fnic->vlan_id, 1, 1, 1); 1147 1148 irq_restore: 1149 spin_unlock_irqrestore(&fnic->wq_lock[0], flags); 1150 1151 free_skb_on_err: 1152 if (ret) 1153 dev_kfree_skb_any(fp_skb(fp)); 1154 1155 return ret; 1156 } 1157 1158 /* 1159 * fnic_send 1160 * Routine to send a raw frame 1161 */ 1162 int fnic_send(struct fc_lport *lp, struct fc_frame *fp) 1163 { 1164 struct fnic *fnic = lport_priv(lp); 1165 unsigned long flags; 1166 1167 if (fnic->in_remove) { 1168 dev_kfree_skb(fp_skb(fp)); 1169 return -1; 1170 } 1171 1172 /* 1173 * Queue frame if in a transitional state. 1174 * This occurs while registering the Port_ID / MAC address after FLOGI. 1175 */ 1176 spin_lock_irqsave(&fnic->fnic_lock, flags); 1177 if (fnic->state != FNIC_IN_FC_MODE && fnic->state != FNIC_IN_ETH_MODE) { 1178 skb_queue_tail(&fnic->tx_queue, fp_skb(fp)); 1179 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 1180 return 0; 1181 } 1182 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 1183 1184 return fnic_send_frame(fnic, fp); 1185 } 1186 1187 /** 1188 * fnic_flush_tx() - send queued frames. 1189 * @fnic: fnic device 1190 * 1191 * Send frames that were waiting to go out in FC or Ethernet mode. 1192 * Whenever changing modes we purge queued frames, so these frames should 1193 * be queued for the stable mode that we're in, either FC or Ethernet. 1194 * 1195 * Called without fnic_lock held. 1196 */ 1197 void fnic_flush_tx(struct fnic *fnic) 1198 { 1199 struct sk_buff *skb; 1200 struct fc_frame *fp; 1201 1202 while ((skb = skb_dequeue(&fnic->tx_queue))) { 1203 fp = (struct fc_frame *)skb; 1204 fnic_send_frame(fnic, fp); 1205 } 1206 } 1207 1208 /** 1209 * fnic_set_eth_mode() - put fnic into ethernet mode. 1210 * @fnic: fnic device 1211 * 1212 * Called without fnic lock held. 1213 */ 1214 static void fnic_set_eth_mode(struct fnic *fnic) 1215 { 1216 unsigned long flags; 1217 enum fnic_state old_state; 1218 int ret; 1219 1220 spin_lock_irqsave(&fnic->fnic_lock, flags); 1221 again: 1222 old_state = fnic->state; 1223 switch (old_state) { 1224 case FNIC_IN_FC_MODE: 1225 case FNIC_IN_ETH_TRANS_FC_MODE: 1226 default: 1227 fnic->state = FNIC_IN_FC_TRANS_ETH_MODE; 1228 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 1229 1230 ret = fnic_fw_reset_handler(fnic); 1231 1232 spin_lock_irqsave(&fnic->fnic_lock, flags); 1233 if (fnic->state != FNIC_IN_FC_TRANS_ETH_MODE) 1234 goto again; 1235 if (ret) 1236 fnic->state = old_state; 1237 break; 1238 1239 case FNIC_IN_FC_TRANS_ETH_MODE: 1240 case FNIC_IN_ETH_MODE: 1241 break; 1242 } 1243 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 1244 } 1245 1246 static void fnic_wq_complete_frame_send(struct vnic_wq *wq, 1247 struct cq_desc *cq_desc, 1248 struct vnic_wq_buf *buf, void *opaque) 1249 { 1250 struct sk_buff *skb = buf->os_buf; 1251 struct fc_frame *fp = (struct fc_frame *)skb; 1252 struct fnic *fnic = vnic_dev_priv(wq->vdev); 1253 1254 dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len, 1255 DMA_TO_DEVICE); 1256 dev_kfree_skb_irq(fp_skb(fp)); 1257 buf->os_buf = NULL; 1258 } 1259 1260 static int fnic_wq_cmpl_handler_cont(struct vnic_dev *vdev, 1261 struct cq_desc *cq_desc, u8 type, 1262 u16 q_number, u16 completed_index, 1263 void *opaque) 1264 { 1265 struct fnic *fnic = vnic_dev_priv(vdev); 1266 unsigned long flags; 1267 1268 spin_lock_irqsave(&fnic->wq_lock[q_number], flags); 1269 vnic_wq_service(&fnic->wq[q_number], cq_desc, completed_index, 1270 fnic_wq_complete_frame_send, NULL); 1271 spin_unlock_irqrestore(&fnic->wq_lock[q_number], flags); 1272 1273 return 0; 1274 } 1275 1276 int fnic_wq_cmpl_handler(struct fnic *fnic, int work_to_do) 1277 { 1278 unsigned int wq_work_done = 0; 1279 unsigned int i; 1280 1281 for (i = 0; i < fnic->raw_wq_count; i++) { 1282 wq_work_done += vnic_cq_service(&fnic->cq[fnic->rq_count+i], 1283 work_to_do, 1284 fnic_wq_cmpl_handler_cont, 1285 NULL); 1286 } 1287 1288 return wq_work_done; 1289 } 1290 1291 1292 void fnic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf) 1293 { 1294 struct fc_frame *fp = buf->os_buf; 1295 struct fnic *fnic = vnic_dev_priv(wq->vdev); 1296 1297 dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len, 1298 DMA_TO_DEVICE); 1299 1300 dev_kfree_skb(fp_skb(fp)); 1301 buf->os_buf = NULL; 1302 } 1303 1304 void fnic_fcoe_reset_vlans(struct fnic *fnic) 1305 { 1306 unsigned long flags; 1307 struct fcoe_vlan *vlan; 1308 struct fcoe_vlan *next; 1309 1310 /* 1311 * indicate a link down to fcoe so that all fcf's are free'd 1312 * might not be required since we did this before sending vlan 1313 * discovery request 1314 */ 1315 spin_lock_irqsave(&fnic->vlans_lock, flags); 1316 if (!list_empty(&fnic->vlans)) { 1317 list_for_each_entry_safe(vlan, next, &fnic->vlans, list) { 1318 list_del(&vlan->list); 1319 kfree(vlan); 1320 } 1321 } 1322 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 1323 } 1324 1325 void fnic_handle_fip_timer(struct fnic *fnic) 1326 { 1327 unsigned long flags; 1328 struct fcoe_vlan *vlan; 1329 struct fnic_stats *fnic_stats = &fnic->fnic_stats; 1330 u64 sol_time; 1331 1332 spin_lock_irqsave(&fnic->fnic_lock, flags); 1333 if (fnic->stop_rx_link_events) { 1334 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 1335 return; 1336 } 1337 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 1338 1339 if (fnic->ctlr.mode == FIP_MODE_NON_FIP) 1340 return; 1341 1342 spin_lock_irqsave(&fnic->vlans_lock, flags); 1343 if (list_empty(&fnic->vlans)) { 1344 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 1345 /* no vlans available, try again */ 1346 if (printk_ratelimit()) 1347 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 1348 "Start VLAN Discovery\n"); 1349 fnic_event_enq(fnic, FNIC_EVT_START_VLAN_DISC); 1350 return; 1351 } 1352 1353 vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list); 1354 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 1355 "fip_timer: vlan %d state %d sol_count %d\n", 1356 vlan->vid, vlan->state, vlan->sol_count); 1357 switch (vlan->state) { 1358 case FIP_VLAN_USED: 1359 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 1360 "FIP VLAN is selected for FC transaction\n"); 1361 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 1362 break; 1363 case FIP_VLAN_FAILED: 1364 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 1365 /* if all vlans are in failed state, restart vlan disc */ 1366 if (printk_ratelimit()) 1367 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, 1368 "Start VLAN Discovery\n"); 1369 fnic_event_enq(fnic, FNIC_EVT_START_VLAN_DISC); 1370 break; 1371 case FIP_VLAN_SENT: 1372 if (vlan->sol_count >= FCOE_CTLR_MAX_SOL) { 1373 /* 1374 * no response on this vlan, remove from the list. 1375 * Try the next vlan 1376 */ 1377 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, 1378 "Dequeue this VLAN ID %d from list\n", 1379 vlan->vid); 1380 list_del(&vlan->list); 1381 kfree(vlan); 1382 vlan = NULL; 1383 if (list_empty(&fnic->vlans)) { 1384 /* we exhausted all vlans, restart vlan disc */ 1385 spin_unlock_irqrestore(&fnic->vlans_lock, 1386 flags); 1387 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, 1388 "fip_timer: vlan list empty, " 1389 "trigger vlan disc\n"); 1390 fnic_event_enq(fnic, FNIC_EVT_START_VLAN_DISC); 1391 return; 1392 } 1393 /* check the next vlan */ 1394 vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, 1395 list); 1396 fnic->set_vlan(fnic, vlan->vid); 1397 vlan->state = FIP_VLAN_SENT; /* sent now */ 1398 } 1399 spin_unlock_irqrestore(&fnic->vlans_lock, flags); 1400 atomic64_inc(&fnic_stats->vlan_stats.sol_expiry_count); 1401 vlan->sol_count++; 1402 sol_time = jiffies + msecs_to_jiffies 1403 (FCOE_CTLR_START_DELAY); 1404 mod_timer(&fnic->fip_timer, round_jiffies(sol_time)); 1405 break; 1406 } 1407 } 1408