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