drivers/scsi/fnic/fnic_fcs.c

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