Quelle  fip.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
 * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
 */
#include "fnic.h"
#include "fip.h"
#include <linux/etherdevice.h>

#define FIP_FNIC_RESET_WAIT_COUNT 15

/**
 * fnic_fcoe_reset_vlans - Free up the list of discovered vlans
 * @fnic: Handle to fnic driver instance
 */
void fnic_fcoe_reset_vlans(struct fnic *fnic)
{
 unsigned long flags;
 struct fcoe_vlan *vlan, *next;

 spin_lock_irqsave(&fnic->vlans_lock, flags);
 if (!list_empty(&fnic->vlan_list)) {
  list_for_each_entry_safe(vlan, next, &fnic->vlan_list, list) {
   list_del(&vlan->list);
   kfree(vlan);
  }
 }

 spin_unlock_irqrestore(&fnic->vlans_lock, flags);
 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "Reset vlan complete\n");
}

/**
 * fnic_fcoe_send_vlan_req - Send FIP vlan request to all FCFs MAC
 * @fnic: Handle to fnic driver instance
 */
void fnic_fcoe_send_vlan_req(struct fnic *fnic)
{
 uint8_t *frame;
 struct fnic_iport_s *iport = &fnic->iport;
 struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 u64 vlan_tov;
 struct fip_vlan_req *pvlan_req;
 uint16_t frame_size = sizeof(struct fip_vlan_req);

 frame = fdls_alloc_frame(iport);
 if (frame == NULL) {
  FNIC_FIP_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
       "Failed to allocate frame to send VLAN req");
  return;
 }

 fnic_fcoe_reset_vlans(fnic);

 fnic->set_vlan(fnic, 0);
 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "set vlan done\n");

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "got MAC 0x%x:%x:%x:%x:%x:%x\n", iport->hwmac[0],
       iport->hwmac[1], iport->hwmac[2], iport->hwmac[3],
       iport->hwmac[4], iport->hwmac[5]);

 pvlan_req = (struct fip_vlan_req *) frame;
 *pvlan_req = (struct fip_vlan_req) {
  .eth = {.h_dest = FCOE_ALL_FCFS_MAC,
   .h_proto = cpu_to_be16(ETH_P_FIP)},
  .fip = {.fip_ver = FIP_VER_ENCAPS(FIP_VER),
   .fip_op = cpu_to_be16(FIP_OP_VLAN),
   .fip_subcode = FIP_SC_REQ,
   .fip_dl_len = cpu_to_be16(FIP_VLAN_REQ_LEN)},
  .mac_desc = {.fd_desc = {.fip_dtype = FIP_DT_MAC,
      .fip_dlen = 2}}
 };

 memcpy(pvlan_req->eth.h_source, iport->hwmac, ETH_ALEN);
 memcpy(pvlan_req->mac_desc.fd_mac, iport->hwmac, ETH_ALEN);

 atomic64_inc(&fnic_stats->vlan_stats.vlan_disc_reqs);

 iport->fip.state = FDLS_FIP_VLAN_DISCOVERY_STARTED;

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "Send VLAN req\n");
 fnic_send_fip_frame(iport, frame, frame_size);

 vlan_tov = jiffies + msecs_to_jiffies(FCOE_CTLR_FIPVLAN_TOV);
 mod_timer(&fnic->retry_fip_timer, round_jiffies(vlan_tov));
 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "fip timer set\n");
}

/**
 * fnic_fcoe_process_vlan_resp - Processes the vlan response from one FCF and
 * populates VLAN list.
 * @fnic: Handle to fnic driver instance
 * @fiph: Received FIP frame
 *
 * Will wait for responses from multiple FCFs until timeout.
 */
void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct fip_header *fiph)
{
 struct fip_vlan_notif *vlan_notif = (struct fip_vlan_notif *)fiph;

 struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 u16 vid;
 int num_vlan = 0;
 int cur_desc, desc_len;
 struct fcoe_vlan *vlan;
 struct fip_vlan_desc *vlan_desc;
 unsigned long flags;

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "fnic 0x%p got vlan resp\n", fnic);

 desc_len = be16_to_cpu(vlan_notif->fip.fip_dl_len);
 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "desc_len %d\n", desc_len);

 spin_lock_irqsave(&fnic->vlans_lock, flags);

 cur_desc = 0;
 while (desc_len > 0) {
  vlan_desc =
      (struct fip_vlan_desc *)(((char *)vlan_notif->vlans_desc)
            + cur_desc * 4);

  if (vlan_desc->fd_desc.fip_dtype == FIP_DT_VLAN) {
   if (vlan_desc->fd_desc.fip_dlen != 1) {
    FNIC_FIP_DBG(KERN_INFO, fnic->host,
          fnic->fnic_num,
          "Invalid descriptor length(%x) in VLan response\n",
          vlan_desc->fd_desc.fip_dlen);

   }
   num_vlan++;
   vid = be16_to_cpu(vlan_desc->fd_vlan);
   FNIC_FIP_DBG(KERN_INFO, fnic->host,
         fnic->fnic_num,
         "process_vlan_resp: FIP VLAN %d\n", vid);
   vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);

   if (!vlan) {
    /* retry from timer */
    FNIC_FIP_DBG(KERN_INFO, fnic->host,
          fnic->fnic_num,
          "Mem Alloc failure\n");
    spin_unlock_irqrestore(&fnic->vlans_lock,
             flags);
    goto out;
   }
   vlan->vid = vid & 0x0fff;
   vlan->state = FIP_VLAN_AVAIL;
   list_add_tail(&vlan->list, &fnic->vlan_list);
   break;
  }
  FNIC_FIP_DBG(KERN_INFO, fnic->host,
        fnic->fnic_num,
        "Invalid descriptor type(%x) in VLan response\n",
        vlan_desc->fd_desc.fip_dtype);
  /*
 * Note : received a type=2 descriptor here i.e. FIP
 * MAC Address Descriptor
 */
  cur_desc += vlan_desc->fd_desc.fip_dlen;
  desc_len -= vlan_desc->fd_desc.fip_dlen;
 }

 /* any VLAN descriptors present ? */
 if (num_vlan == 0) {
  atomic64_inc(&fnic_stats->vlan_stats.resp_withno_vlanID);
  FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
        "fnic 0x%p No VLAN descriptors in FIP VLAN response\n",
        fnic);
 }

 spin_unlock_irqrestore(&fnic->vlans_lock, flags);

 out:
 return;
}

/**
 * fnic_fcoe_start_fcf_discovery - Start FIP FCF discovery in a selected vlan
 * @fnic: Handle to fnic driver instance
 */
void fnic_fcoe_start_fcf_discovery(struct fnic *fnic)
{
 uint8_t *frame;
 struct fnic_iport_s *iport = &fnic->iport;
 u64 fcs_tov;
 struct fip_discovery *pdisc_sol;
 uint16_t frame_size = sizeof(struct fip_discovery);

 frame = fdls_alloc_frame(iport);
 if (frame == NULL) {
  FNIC_FIP_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
       "Failed to allocate frame to start FCF discovery");
  return;
 }

 eth_zero_addr(iport->selected_fcf.fcf_mac);

 pdisc_sol = (struct fip_discovery *) frame;
 *pdisc_sol = (struct fip_discovery) {
  .eth = {.h_dest = FCOE_ALL_FCFS_MAC,
   .h_proto = cpu_to_be16(ETH_P_FIP)},
  .fip = {
   .fip_ver = FIP_VER_ENCAPS(FIP_VER), .fip_op = cpu_to_be16(FIP_OP_DISC),
   .fip_subcode = FIP_SC_REQ, .fip_dl_len = cpu_to_be16(FIP_DISC_SOL_LEN),
   .fip_flags = cpu_to_be16(FIP_FL_FPMA)},
  .mac_desc = {.fd_desc = {.fip_dtype = FIP_DT_MAC, .fip_dlen = 2}},
  .name_desc = {.fd_desc = {.fip_dtype = FIP_DT_NAME, .fip_dlen = 3}},
  .fcoe_desc = {.fd_desc = {.fip_dtype = FIP_DT_FCOE_SIZE, .fip_dlen = 1},
         .fd_size = cpu_to_be16(FCOE_MAX_SIZE)}
 };

 memcpy(pdisc_sol->eth.h_source, iport->hwmac, ETH_ALEN);
 memcpy(pdisc_sol->mac_desc.fd_mac, iport->hwmac, ETH_ALEN);
 iport->selected_fcf.fcf_priority = 0xFF;

 FNIC_STD_SET_NODE_NAME(&pdisc_sol->name_desc.fd_wwn, iport->wwnn);

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "Start FCF discovery\n");
 fnic_send_fip_frame(iport, frame, frame_size);

 iport->fip.state = FDLS_FIP_FCF_DISCOVERY_STARTED;

 fcs_tov = jiffies + msecs_to_jiffies(FCOE_CTLR_FCS_TOV);
 mod_timer(&fnic->retry_fip_timer, round_jiffies(fcs_tov));
}

/**
 * fnic_fcoe_fip_discovery_resp - Processes FCF advertisements.
 * @fnic: Handle to fnic driver instance
 * @fiph: Received frame
 *
 * FCF advertisements can be:
 * solicited - Sent in response of a discover FCF FIP request
 * Store the information of the FCF with highest priority.
 * Wait until timeout in case of multiple FCFs.
 *
 * unsolicited - Sent periodically by the FCF for keep alive.
 * If FLOGI is in progress or completed and the advertisement is
 * received by our selected FCF, refresh the keep alive timer.
 */
void fnic_fcoe_fip_discovery_resp(struct fnic *fnic, struct fip_header *fiph)
{
 struct fnic_iport_s *iport = &fnic->iport;
 struct fip_disc_adv *disc_adv = (struct fip_disc_adv *)fiph;
 u64 fcs_ka_tov;
 u64 tov;
 int fka_has_changed;

 switch (iport->fip.state) {
 case FDLS_FIP_FCF_DISCOVERY_STARTED:
  if (be16_to_cpu(disc_adv->fip.fip_flags) & FIP_FL_SOL) {
   FNIC_FIP_DBG(KERN_INFO, fnic->host,
         fnic->fnic_num,
         "fnic 0x%p Solicited adv\n", fnic);

   if ((disc_adv->prio_desc.fd_pri <
        iport->selected_fcf.fcf_priority)
       && (be16_to_cpu(disc_adv->fip.fip_flags) & FIP_FL_AVAIL)) {

    FNIC_FIP_DBG(KERN_INFO, fnic->host,
          fnic->fnic_num,
          "fnic 0x%p FCF Available\n", fnic);
    memcpy(iport->selected_fcf.fcf_mac,
           disc_adv->mac_desc.fd_mac, ETH_ALEN);
    iport->selected_fcf.fcf_priority =
        disc_adv->prio_desc.fd_pri;
    iport->selected_fcf.fka_adv_period =
        be32_to_cpu(disc_adv->fka_adv_desc.fd_fka_period);
    FNIC_FIP_DBG(KERN_INFO, fnic->host,
          fnic->fnic_num, "adv time %d",
          iport->selected_fcf.fka_adv_period);
    iport->selected_fcf.ka_disabled =
        (disc_adv->fka_adv_desc.fd_flags & 1);
   }
  }
  break;
 case FDLS_FIP_FLOGI_STARTED:
 case FDLS_FIP_FLOGI_COMPLETE:
  if (!(be16_to_cpu(disc_adv->fip.fip_flags) & FIP_FL_SOL)) {
   /* same fcf */
   if (memcmp
       (iport->selected_fcf.fcf_mac,
        disc_adv->mac_desc.fd_mac, ETH_ALEN) == 0) {
    if (iport->selected_fcf.fka_adv_period !=
        be32_to_cpu(disc_adv->fka_adv_desc.fd_fka_period)) {
     iport->selected_fcf.fka_adv_period =
         be32_to_cpu(disc_adv->fka_adv_desc.fd_fka_period);
     FNIC_FIP_DBG(KERN_INFO,
           fnic->host,
           fnic->fnic_num,
           "change fka to %d",
           iport->selected_fcf.fka_adv_period);
    }

    fka_has_changed =
        (iport->selected_fcf.ka_disabled == 1)
        && ((disc_adv->fka_adv_desc.fd_flags & 1) ==
     0);

    iport->selected_fcf.ka_disabled =
        (disc_adv->fka_adv_desc.fd_flags & 1);
    if (!((iport->selected_fcf.ka_disabled)
          || (iport->selected_fcf.fka_adv_period ==
       0))) {

     fcs_ka_tov = jiffies
         + 3
         *
         msecs_to_jiffies(iport->selected_fcf.fka_adv_period);
     mod_timer(&fnic->fcs_ka_timer,
        round_jiffies(fcs_ka_tov));
    } else {
     if (timer_pending(&fnic->fcs_ka_timer))
      timer_delete_sync(&fnic->fcs_ka_timer);
    }

    if (fka_has_changed) {
     if (iport->selected_fcf.fka_adv_period != 0) {
      tov =
       jiffies +
       msecs_to_jiffies(
        iport->selected_fcf.fka_adv_period);
      mod_timer(&fnic->enode_ka_timer,
         round_jiffies(tov));

      tov =
          jiffies +
          msecs_to_jiffies
          (FIP_VN_KA_PERIOD);
      mod_timer(&fnic->vn_ka_timer,
         round_jiffies(tov));
     }
    }
   }
  }
  break;
 default:
  break;
 }   /* end switch */
}

/**
 * fnic_fcoe_start_flogi - Send FIP FLOGI to the selected FCF
 * @fnic: Handle to fnic driver instance
 */
void fnic_fcoe_start_flogi(struct fnic *fnic)
{
 uint8_t *frame;
 struct fnic_iport_s *iport = &fnic->iport;
 struct fip_flogi *pflogi_req;
 u64 flogi_tov;
 uint16_t oxid;
 uint16_t frame_size = sizeof(struct fip_flogi);

 frame = fdls_alloc_frame(iport);
 if (frame == NULL) {
  FNIC_FIP_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
       "Failed to allocate frame to start FIP FLOGI");
  return;
 }

 pflogi_req = (struct fip_flogi *) frame;
 *pflogi_req = (struct fip_flogi) {
  .eth = {
   .h_proto = cpu_to_be16(ETH_P_FIP)},
  .fip = {
   .fip_ver = FIP_VER_ENCAPS(FIP_VER),
   .fip_op = cpu_to_be16(FIP_OP_LS),
   .fip_subcode = FIP_SC_REQ,
   .fip_dl_len = cpu_to_be16(FIP_FLOGI_LEN),
   .fip_flags = cpu_to_be16(FIP_FL_FPMA)},
  .flogi_desc = {
    .fd_desc = {.fip_dtype = FIP_DT_FLOGI, .fip_dlen = 36},
          .flogi = {
      .fchdr = {
         .fh_r_ctl = FC_RCTL_ELS_REQ,
         .fh_d_id = {0xFF, 0xFF, 0xFE},
         .fh_type = FC_TYPE_ELS,
         .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0},
         .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)},
      .els = {
       .fl_cmd = ELS_FLOGI,
       .fl_csp = {
           .sp_hi_ver =
           FNIC_FC_PH_VER_HI,
           .sp_lo_ver =
           FNIC_FC_PH_VER_LO,
           .sp_bb_cred =
           cpu_to_be16
           (FNIC_FC_B2B_CREDIT),
           .sp_bb_data =
           cpu_to_be16
           (FNIC_FC_B2B_RDF_SZ)},
       .fl_cssp[2].cp_class =
       cpu_to_be16(FC_CPC_VALID | FC_CPC_SEQ)
      },
     }
   },
  .mac_desc = {.fd_desc = {.fip_dtype = FIP_DT_MAC, .fip_dlen = 2}}
 };

 memcpy(pflogi_req->eth.h_source, iport->hwmac, ETH_ALEN);
 if (iport->usefip)
  memcpy(pflogi_req->eth.h_dest, iport->selected_fcf.fcf_mac,
         ETH_ALEN);

 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_FLOGI,
  &iport->active_oxid_fabric_req);
 if (oxid == FNIC_UNASSIGNED_OXID) {
  FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "Failed to allocate OXID to send FIP FLOGI");
  mempool_free(frame, fnic->frame_pool);
  return;
 }
 FNIC_STD_SET_OX_ID(pflogi_req->flogi_desc.flogi.fchdr, oxid);

 FNIC_STD_SET_NPORT_NAME(&pflogi_req->flogi_desc.flogi.els.fl_wwpn,
   iport->wwpn);
 FNIC_STD_SET_NODE_NAME(&pflogi_req->flogi_desc.flogi.els.fl_wwnn,
   iport->wwnn);

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "FIP start FLOGI\n");
 fnic_send_fip_frame(iport, frame, frame_size);
 iport->fip.flogi_retry++;

 iport->fip.state = FDLS_FIP_FLOGI_STARTED;
 flogi_tov = jiffies + msecs_to_jiffies(fnic->config.flogi_timeout);
 mod_timer(&fnic->retry_fip_timer, round_jiffies(flogi_tov));
}

/**
 * fnic_fcoe_process_flogi_resp - Processes FLOGI response from FCF.
 * @fnic: Handle to fnic driver instance
 * @fiph: Received frame
 *
 * If successful save assigned fc_id and MAC, program firmware
 * and start fdls discovery, else restart vlan discovery.
 */
void fnic_fcoe_process_flogi_resp(struct fnic *fnic, struct fip_header *fiph)
{
 struct fnic_iport_s *iport = &fnic->iport;
 struct fip_flogi_rsp *flogi_rsp = (struct fip_flogi_rsp *)fiph;
 int desc_len;
 uint32_t s_id;
 int frame_type;
 uint16_t oxid;

 struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 struct fc_frame_header *fchdr = &flogi_rsp->rsp_desc.flogi.fchdr;

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "fnic 0x%p FIP FLOGI rsp\n", fnic);
 desc_len = be16_to_cpu(flogi_rsp->fip.fip_dl_len);
 if (desc_len != 38) {
  FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
        "Invalid Descriptor List len (%x). Dropping frame\n",
        desc_len);
  return;
 }

 if (!((flogi_rsp->rsp_desc.fd_desc.fip_dtype == 7)
       && (flogi_rsp->rsp_desc.fd_desc.fip_dlen == 36))
     || !((flogi_rsp->mac_desc.fd_desc.fip_dtype == 2)
   && (flogi_rsp->mac_desc.fd_desc.fip_dlen == 2))) {
  FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
        "Dropping frame invalid type and len mix\n");
  return;
 }

 frame_type = fnic_fdls_validate_and_get_frame_type(iport, fchdr);

 s_id = ntoh24(fchdr->fh_s_id);
 if ((fchdr->fh_f_ctl[0] != 0x98)
     || (fchdr->fh_r_ctl != 0x23)
     || (s_id != FC_FID_FLOGI)
     || (frame_type != FNIC_FABRIC_FLOGI_RSP)
     || (fchdr->fh_type != 0x01)) {
  FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
        "Dropping invalid frame: s_id %x F %x R %x t %x OX_ID %x\n",
        s_id, fchdr->fh_f_ctl[0], fchdr->fh_r_ctl,
        fchdr->fh_type, FNIC_STD_GET_OX_ID(fchdr));
  return;
 }

 if (iport->fip.state == FDLS_FIP_FLOGI_STARTED) {
  FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
        "fnic 0x%p rsp for pending FLOGI\n", fnic);

  oxid = FNIC_STD_GET_OX_ID(fchdr);
  fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req);
  timer_delete_sync(&fnic->retry_fip_timer);

  if ((be16_to_cpu(flogi_rsp->fip.fip_dl_len) == FIP_FLOGI_LEN)
      && (flogi_rsp->rsp_desc.flogi.els.fl_cmd == ELS_LS_ACC)) {

   FNIC_FIP_DBG(KERN_INFO, fnic->host,
         fnic->fnic_num,
         "fnic 0x%p FLOGI success\n", fnic);
   memcpy(iport->fpma, flogi_rsp->mac_desc.fd_mac, ETH_ALEN);
   iport->fcid =
       ntoh24(flogi_rsp->rsp_desc.flogi.fchdr.fh_d_id);

   iport->r_a_tov =
       be32_to_cpu(flogi_rsp->rsp_desc.flogi.els.fl_csp.sp_r_a_tov);
   iport->e_d_tov =
       be32_to_cpu(flogi_rsp->rsp_desc.flogi.els.fl_csp.sp_e_d_tov);
   memcpy(fnic->iport.fcfmac, iport->selected_fcf.fcf_mac,
          ETH_ALEN);
   vnic_dev_add_addr(fnic->vdev, flogi_rsp->mac_desc.fd_mac);

   if (fnic_fdls_register_portid(iport, iport->fcid, NULL)
       != 0) {
    FNIC_FIP_DBG(KERN_INFO, fnic->host,
          fnic->fnic_num,
          "fnic 0x%p flogi registration failed\n",
          fnic);
    return;
   }

   iport->fip.state = FDLS_FIP_FLOGI_COMPLETE;
   iport->state = FNIC_IPORT_STATE_FABRIC_DISC;
   FNIC_FIP_DBG(KERN_INFO, fnic->host,
         fnic->fnic_num, "iport->state:%d\n",
         iport->state);
   fnic_fdls_disc_start(iport);
   if (!((iport->selected_fcf.ka_disabled)
         || (iport->selected_fcf.fka_adv_period == 0))) {
    u64 tov;

    tov = jiffies
        +
        msecs_to_jiffies(iport->selected_fcf.fka_adv_period);
    mod_timer(&fnic->enode_ka_timer,
       round_jiffies(tov));

    tov =
        jiffies +
        msecs_to_jiffies(FIP_VN_KA_PERIOD);
    mod_timer(&fnic->vn_ka_timer,
       round_jiffies(tov));

   }
  } else {
   /*
 * If there's FLOGI rejects - clear all
 * fcf's & restart from scratch
 */
   atomic64_inc(&fnic_stats->vlan_stats.flogi_rejects);
   /* start FCoE VLAN discovery */
   fnic_fcoe_send_vlan_req(fnic);

   iport->fip.state = FDLS_FIP_VLAN_DISCOVERY_STARTED;
  }
 }
}

/**
 * fnic_common_fip_cleanup - Clean up FCF info and timers in case of
 * link down/CVL
 * @fnic: Handle to fnic driver instance
 */
void fnic_common_fip_cleanup(struct fnic *fnic)
{

 struct fnic_iport_s *iport = &fnic->iport;

 if (!iport->usefip)
  return;
 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "fnic 0x%p fip cleanup\n", fnic);

 iport->fip.state = FDLS_FIP_INIT;

 timer_delete_sync(&fnic->retry_fip_timer);
 timer_delete_sync(&fnic->fcs_ka_timer);
 timer_delete_sync(&fnic->enode_ka_timer);
 timer_delete_sync(&fnic->vn_ka_timer);

 if (!is_zero_ether_addr(iport->fpma))
  vnic_dev_del_addr(fnic->vdev, iport->fpma);

 eth_zero_addr(iport->fpma);
 iport->fcid = 0;
 iport->r_a_tov = 0;
 iport->e_d_tov = 0;
 eth_zero_addr(fnic->iport.fcfmac);
 eth_zero_addr(iport->selected_fcf.fcf_mac);
 iport->selected_fcf.fcf_priority = 0;
 iport->selected_fcf.fka_adv_period = 0;
 iport->selected_fcf.ka_disabled = 0;

 fnic_fcoe_reset_vlans(fnic);
}

/**
 * fnic_fcoe_process_cvl - Processes Clear Virtual Link from FCF.
 * @fnic: Handle to fnic driver instance
 * @fiph: Received frame
 *
 * Verify that cvl is received from our current FCF for our assigned MAC
 * and clean up and restart the vlan discovery.
 */
void fnic_fcoe_process_cvl(struct fnic *fnic, struct fip_header *fiph)
{
 struct fnic_iport_s *iport = &fnic->iport;
 struct fip_cvl *cvl_msg = (struct fip_cvl *)fiph;
 int i;
 int found = false;
 int max_count = 0;

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "fnic 0x%p clear virtual link handler\n", fnic);

 if (!((cvl_msg->fcf_mac_desc.fd_desc.fip_dtype == 2)
       && (cvl_msg->fcf_mac_desc.fd_desc.fip_dlen == 2))
     || !((cvl_msg->name_desc.fd_desc.fip_dtype == 4)
   && (cvl_msg->name_desc.fd_desc.fip_dlen == 3))) {

  FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
        "invalid mix: ft %x fl %x ndt %x ndl %x",
        cvl_msg->fcf_mac_desc.fd_desc.fip_dtype,
        cvl_msg->fcf_mac_desc.fd_desc.fip_dlen,
     cvl_msg->name_desc.fd_desc.fip_dtype,
        cvl_msg->name_desc.fd_desc.fip_dlen);
 }

 if (memcmp
     (iport->selected_fcf.fcf_mac, cvl_msg->fcf_mac_desc.fd_mac, ETH_ALEN)
     == 0) {
  for (i = 0; i < ((be16_to_cpu(fiph->fip_dl_len) / 5) - 1); i++) {
   if (!((cvl_msg->vn_ports_desc[i].fd_desc.fip_dtype == 11)
         && (cvl_msg->vn_ports_desc[i].fd_desc.fip_dlen == 5))) {

    FNIC_FIP_DBG(KERN_INFO, fnic->host,
          fnic->fnic_num,
          "Invalid type and len mix type: %d len: %d\n",
          cvl_msg->vn_ports_desc[i].fd_desc.fip_dtype,
          cvl_msg->vn_ports_desc[i].fd_desc.fip_dlen);
   }
   if (memcmp
       (iport->fpma, cvl_msg->vn_ports_desc[i].fd_mac,
        ETH_ALEN) == 0) {
    found = true;
    break;
   }
  }
  if (!found)
   return;
  fnic_common_fip_cleanup(fnic);

  while (fnic->reset_in_progress == IN_PROGRESS) {
   spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags);
   wait_for_completion_timeout(&fnic->reset_completion_wait,
       msecs_to_jiffies(5000));
   spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags);
   max_count++;
   if (max_count >= FIP_FNIC_RESET_WAIT_COUNT) {
    FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
      "Rthr waited too long. Skipping handle link event %p\n",
      fnic);
    return;
   }
   FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
     "fnic reset in progress. Link event needs to wait %p",
     fnic);
  }
  fnic->reset_in_progress = IN_PROGRESS;
  fnic_fdls_link_down(iport);
  fnic->reset_in_progress = NOT_IN_PROGRESS;
  complete(&fnic->reset_completion_wait);
  fnic_fcoe_send_vlan_req(fnic);
 }
}

/**
 * fdls_fip_recv_frame - Demultiplexer for FIP frames
 * @fnic: Handle to fnic driver instance
 * @frame: Received ethernet frame
 */
int fdls_fip_recv_frame(struct fnic *fnic, void *frame)
{
 struct ethhdr *eth = (struct ethhdr *)frame;
 struct fip_header *fiph;
 u16 op;
 u8 sub;
 int len = 2048;

 if (be16_to_cpu(eth->h_proto) == ETH_P_FIP) {
  fiph = (struct fip_header *)(eth + 1);
  op = be16_to_cpu(fiph->fip_op);
  sub = fiph->fip_subcode;

  fnic_debug_dump_fip_frame(fnic, eth, len, "Incoming");

  if (op == FIP_OP_DISC && sub == FIP_SC_REP)
   fnic_fcoe_fip_discovery_resp(fnic, fiph);
  else if (op == FIP_OP_VLAN && sub == FIP_SC_REP)
   fnic_fcoe_process_vlan_resp(fnic, fiph);
  else if (op == FIP_OP_CTRL && sub == FIP_SC_REP)
   fnic_fcoe_process_cvl(fnic, fiph);
  else if (op == FIP_OP_LS && sub == FIP_SC_REP)
   fnic_fcoe_process_flogi_resp(fnic, fiph);

  /* Return true if the frame was a FIP frame */
  return true;
 }

 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
  "Not a FIP Frame");
 return false;
}

void fnic_work_on_fip_timer(struct work_struct *work)
{
 struct fnic *fnic = container_of(work, struct fnic, fip_timer_work);
 struct fnic_iport_s *iport = &fnic->iport;

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "FIP timeout\n");

 if (iport->fip.state == FDLS_FIP_VLAN_DISCOVERY_STARTED) {
  fnic_vlan_discovery_timeout(fnic);
 } else if (iport->fip.state == FDLS_FIP_FCF_DISCOVERY_STARTED) {
  u8 zmac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };

  FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
        "FCF Discovery timeout\n");
  if (memcmp(iport->selected_fcf.fcf_mac, zmac, ETH_ALEN) != 0) {

   if (iport->flags & FNIC_FIRST_LINK_UP) {
    fnic_scsi_fcpio_reset(iport->fnic);
    iport->flags &= ~FNIC_FIRST_LINK_UP;
   }

   fnic_fcoe_start_flogi(fnic);
   if (!((iport->selected_fcf.ka_disabled)
         || (iport->selected_fcf.fka_adv_period == 0))) {
    u64 fcf_tov;

    fcf_tov = jiffies
        + 3
        *
        msecs_to_jiffies(iport->selected_fcf.fka_adv_period);
    mod_timer(&fnic->fcs_ka_timer,
       round_jiffies(fcf_tov));
   }
  } else {
   FNIC_FIP_DBG(KERN_INFO, fnic->host,
         fnic->fnic_num, "FCF Discovery timeout\n");
   fnic_vlan_discovery_timeout(fnic);
  }
 } else if (iport->fip.state == FDLS_FIP_FLOGI_STARTED) {
  fdls_schedule_oxid_free(iport, &iport->active_oxid_fabric_req);
  FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
        "FLOGI timeout\n");
  if (iport->fip.flogi_retry < fnic->config.flogi_retries)
   fnic_fcoe_start_flogi(fnic);
  else
   fnic_vlan_discovery_timeout(fnic);
 }
}

/**
 * fnic_handle_fip_timer - Timeout handler for FIP discover phase.
 * @t: Handle to the timer list
 *
 * Based on the current state, start next phase or restart discovery.
 */
void fnic_handle_fip_timer(struct timer_list *t)
{
 struct fnic *fnic = timer_container_of(fnic, t, retry_fip_timer);

 INIT_WORK(&fnic->fip_timer_work, fnic_work_on_fip_timer);
 queue_work(fnic_fip_queue, &fnic->fip_timer_work);
}

/**
 * fnic_handle_enode_ka_timer - FIP node keep alive.
 * @t: Handle to the timer list
 */
void fnic_handle_enode_ka_timer(struct timer_list *t)
{
 uint8_t *frame;
 struct fnic *fnic = timer_container_of(fnic, t, enode_ka_timer);

 struct fnic_iport_s *iport = &fnic->iport;
 struct fip_enode_ka *penode_ka;
 u64 enode_ka_tov;
 uint16_t frame_size = sizeof(struct fip_enode_ka);

 if (iport->fip.state != FDLS_FIP_FLOGI_COMPLETE)
  return;

 if ((iport->selected_fcf.ka_disabled)
     || (iport->selected_fcf.fka_adv_period == 0)) {
  return;
 }

 frame = fdls_alloc_frame(iport);
 if (frame == NULL) {
  FNIC_FIP_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
       "Failed to allocate frame to send enode ka");
  return;
 }

 penode_ka = (struct fip_enode_ka *) frame;
 *penode_ka = (struct fip_enode_ka) {
  .eth = {
   .h_proto = cpu_to_be16(ETH_P_FIP)},
  .fip = {
   .fip_ver = FIP_VER_ENCAPS(FIP_VER),
   .fip_op = cpu_to_be16(FIP_OP_CTRL),
   .fip_subcode = FIP_SC_REQ,
   .fip_dl_len = cpu_to_be16(FIP_ENODE_KA_LEN)},
  .mac_desc = {.fd_desc = {.fip_dtype = FIP_DT_MAC, .fip_dlen = 2}}
 };

 memcpy(penode_ka->eth.h_source, iport->hwmac, ETH_ALEN);
 memcpy(penode_ka->eth.h_dest, iport->selected_fcf.fcf_mac, ETH_ALEN);
 memcpy(penode_ka->mac_desc.fd_mac, iport->hwmac, ETH_ALEN);

 FNIC_FIP_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
       "Handle enode KA timer\n");
 fnic_send_fip_frame(iport, frame, frame_size);
 enode_ka_tov = jiffies
     + msecs_to_jiffies(iport->selected_fcf.fka_adv_period);
 mod_timer(&fnic->enode_ka_timer, round_jiffies(enode_ka_tov));
}

/**
 * fnic_handle_vn_ka_timer - FIP virtual port keep alive.
 * @t: Handle to the timer list
 */
void fnic_handle_vn_ka_timer(struct timer_list *t)
{
 uint8_t *frame;
 struct fnic *fnic = timer_container_of(fnic, t, vn_ka_timer);

 struct fnic_iport_s *iport = &fnic->iport;
 struct fip_vn_port_ka *pvn_port_ka;
 u64 vn_ka_tov;
 uint8_t fcid[3];
 uint16_t frame_size = sizeof(struct fip_vn_port_ka);

 if (iport->fip.state != FDLS_FIP_FLOGI_COMPLETE)
  return;

 if ((iport->selected_fcf.ka_disabled)
     || (iport->selected_fcf.fka_adv_period == 0)) {
  return;
 }

 frame = fdls_alloc_frame(iport);
 if (frame == NULL) {
  FNIC_FIP_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
       "Failed to allocate frame to send vn ka");
  return;
 }

 pvn_port_ka = (struct fip_vn_port_ka *) frame;
 *pvn_port_ka = (struct fip_vn_port_ka) {
  .eth = {
   .h_proto = cpu_to_be16(ETH_P_FIP)},
  .fip = {
   .fip_ver = FIP_VER_ENCAPS(FIP_VER),
   .fip_op = cpu_to_be16(FIP_OP_CTRL),
   .fip_subcode = FIP_SC_REQ,
   .fip_dl_len = cpu_to_be16(FIP_VN_KA_LEN)},
  .mac_desc = {.fd_desc = {.fip_dtype = FIP_DT_MAC, .fip_dlen = 2}},
  .vn_port_desc = {.fd_desc = {.fip_dtype = FIP_DT_VN_ID, .fip_dlen = 5}}
 };

 memcpy(pvn_port_ka->eth.h_source, iport->fpma, ETH_ALEN);
 memcpy(pvn_port_ka->eth.h_dest, iport->selected_fcf.fcf_mac, ETH_ALEN);
 memcpy(pvn_port_ka->mac_desc.fd_mac, iport->hwmac, ETH_ALEN);
 memcpy(pvn_port_ka->vn_port_desc.fd_mac, iport->fpma, ETH_ALEN);
 hton24(fcid, iport->fcid);
 memcpy(pvn_port_ka->vn_port_desc.fd_fc_id, fcid, 3);
 FNIC_STD_SET_NPORT_NAME(&pvn_port_ka->vn_port_desc.fd_wwpn, iport->wwpn);

 FNIC_FIP_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
       "Handle vnport KA timer\n");
 fnic_send_fip_frame(iport, frame, frame_size);
 vn_ka_tov = jiffies + msecs_to_jiffies(FIP_VN_KA_PERIOD);
 mod_timer(&fnic->vn_ka_timer, round_jiffies(vn_ka_tov));
}

/**
 * fnic_vlan_discovery_timeout - Handle vlan discovery timeout
 * @fnic: Handle to fnic driver instance
 *
 * End of VLAN discovery or FCF discovery time window.
 * Start the FCF discovery if VLAN was never used.
 */
void fnic_vlan_discovery_timeout(struct fnic *fnic)
{
 struct fcoe_vlan *vlan;
 struct fnic_iport_s *iport = &fnic->iport;
 struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 unsigned long flags;

 spin_lock_irqsave(&fnic->fnic_lock, flags);
 if (fnic->stop_rx_link_events) {
  spin_unlock_irqrestore(&fnic->fnic_lock, flags);
  return;
 }
 spin_unlock_irqrestore(&fnic->fnic_lock, flags);

 if (!iport->usefip)
  return;

 spin_lock_irqsave(&fnic->vlans_lock, flags);
 if (list_empty(&fnic->vlan_list)) {
  /* no vlans available, try again */
  spin_unlock_irqrestore(&fnic->vlans_lock, flags);
  fnic_fcoe_send_vlan_req(fnic);
  return;
 }

 vlan = list_first_entry(&fnic->vlan_list, struct fcoe_vlan, list);

 if (vlan->state == FIP_VLAN_SENT) {
  if (vlan->sol_count >= FCOE_CTLR_MAX_SOL) {
   /*
 * no response on this vlan, remove  from the list.
 * Try the next vlan
 */
   list_del(&vlan->list);
   kfree(vlan);
   vlan = NULL;
   if (list_empty(&fnic->vlan_list)) {
    /* we exhausted all vlans, restart vlan disc */
    spin_unlock_irqrestore(&fnic->vlans_lock,
             flags);
    fnic_fcoe_send_vlan_req(fnic);
    return;
   }
   /* check the next vlan */
   vlan =
       list_first_entry(&fnic->vlan_list, struct fcoe_vlan,
          list);

   fnic->set_vlan(fnic, vlan->vid);
   vlan->state = FIP_VLAN_SENT; /* sent now */

  }
  atomic64_inc(&fnic_stats->vlan_stats.sol_expiry_count);

 } else {
  fnic->set_vlan(fnic, vlan->vid);
  vlan->state = FIP_VLAN_SENT; /* sent now */
 }
 vlan->sol_count++;
 spin_unlock_irqrestore(&fnic->vlans_lock, flags);
 fnic_fcoe_start_fcf_discovery(fnic);
}

/**
 * fnic_work_on_fcs_ka_timer - Handle work on FCS keep alive timer.
 * @work: the work queue to be serviced
 *
 * Finish handling fcs_ka_timer in process context.
 * Clean up, bring the link down, and restart all FIP discovery.
 */
void fnic_work_on_fcs_ka_timer(struct work_struct *work)
{
 struct fnic
 *fnic = container_of(work, struct fnic, fip_timer_work);
 struct fnic_iport_s *iport = &fnic->iport;

 FNIC_FIP_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
       "fnic 0x%p fcs ka timeout\n", fnic);

 fnic_common_fip_cleanup(fnic);
 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags);
 fnic_fdls_link_down(iport);
 iport->state = FNIC_IPORT_STATE_FIP;
 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags);

 fnic_fcoe_send_vlan_req(fnic);
}

/**
 * fnic_handle_fcs_ka_timer - Handle FCS keep alive timer.
 * @t: Handle to the timer list
 *
 * No keep alives received from FCF. Clean up, bring the link down
 * and restart all the FIP discovery.
 */
void fnic_handle_fcs_ka_timer(struct timer_list *t)
{
 struct fnic *fnic = timer_container_of(fnic, t, fcs_ka_timer);

 INIT_WORK(&fnic->fip_timer_work, fnic_work_on_fcs_ka_timer);
 queue_work(fnic_fip_queue, &fnic->fip_timer_work);
}