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