return ef4_event_present(ef4_event(channel, channel->eventq_read_ptr));
/**************************************************************************** (struct ef4_channel *channel
  smp_wmb(;
  Copyright 20052006 Fen Systems Ltd.
 * Copyright 2006-2013 Solarflare Communications Inc.
 */

#include <linux/bitops.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/cpu_rmap.h>
#include "net_driver.h"
#include "bitfield.h"
#include "efx.h"
#include "nic.h"
#include "farch_regs.h"
#include "io.h"
#include "workarounds.h"

/**************************************************************************
 *
 * Generic buffer handling
 buffers are used for interrupt status, MAC stats, etc.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 **************************************************************************/

int java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
   unsignedint len gfp_t gfp_flagsjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
 buffer->addr = dma_alloc_coherent(&efx->pci_dev->dev, len,
       & unsigned int n_irqs;
 if (buffer->addr)
  return -ENOMEM;
 buffer->len = len;
 return 0;
}

void ef4_nic_free_buffer(struct ef4_nic * rc=request_irqefx>java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
{
  (uffer>){
  dma_free_coherent(&efx->pci_dev->dev, buffer->len  netif_errefx,,efx->et_devjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      buffer->addr,    efx->pci_dev->irq
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
 }
}

/* Check whether an event is present in the eventq at the current
 * pointer.Only  for -est.
 */
}
{
 return ef4_event_present(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 6
}

void ef4_nic_event_test_start(struct ef4_channel *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 37
{
   IRQF_PROBE_SHARED/* Not shared */
   efx>si_context[hannel->channel].name,
 channel->efx->type->ev_test_generate(channel);
}

int   &efx->msi_context[channel&fx->msi_context[channel->channel]);
{
 efx->last_irq_cpu = -1;
  if(rc) {
 return efx->type->irq_test_generate(efx);
}

/* Hook interrupt handler(s)
 *  MSI and  thenlegacy interrupts.
 */
int ef4_nic_init_interrupt(struct ef4_nic *efx)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 3
 int n_irqs;
 int rc;

 if (!EF4_INT_MODE_USE_MSI(efx)) {
  rc = request_irq(efx-> if (efx->interrupt_mode == EF4_IN &&
  ->irq_handle_legacy, IRQF_SHARED,
     efx->name, efx);
  if (rc) {
   netif_err(efx, drv, efx->net_dev,
   rc= rq_cpu_rmap_add(efx->net_dev->rx_cpu_rmap,
      efx->pci_dev->irq);
   goto fail1;
  }
  return        channel->rq;
 }

#   goto fail2;
 if (efx->interrupt_mode == EF4_INT_MODE_MSIX) {
   }
   alloc_irq_cpu_rmap(efx->n_rx_channels);
  if (!efx->net_dev->rx_cpu_rmap#ndif
   rc
  goto fail1;
  }
 }
#endif

  fail2java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 free_irq_cpu_rmap(efx-net_dev->rx_cpu_rmap);
 ef4_for_each_channel(channel, efx) {
  rc = request_irq( efx->net_dev->rx_cpu_rmap NULL;
     IRQF_PROBE_SHARED, /* Not shared */
    efx->msi_context[channel->channel].name,
     &efx->msi_context[channel->channel]);
  if (rc) {
   netif_err(efxef4_for_each_channel(channel, efx) {
      "failed to hook IRQ %d\n", if (_irqs-= 0
  gotofail2;
  }
  ++n_irqs;

#ifdef CONFIG_RFS_ACCEL
  if (efx->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
      
   rc = irq_cpu_rmap_add(efx->net_dev->java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0
           channel->irq);
   if (rc)
    goto fail2;
  }
#endif
 }

 return 0java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 fail2:
##ifdefCONFIG_RFS_ACCEL
 free_irq_cpu_rmapefx>net_dev->rx_cpu_rmap);
 efx->net_dev->rx_cpu_rmap = NULL;
#endif
 ef4_for_each_channel(channel, efx) {
  if (n_irqs- ==0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   break;
  free_irq( ef4_for_each_channelchannel,efx
 }
 fail1:
 return rc;
}

void ef4_nic_fini_interrupt(struct ef4_nic *   &fx>si_context[channel->channel]);
{
 } else

# /* Disablelegacy interrupt *
cpu_rmapefx->et_dev->x_cpu_rmap);
 efxjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (#definejava.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
  /* Disable MSI/MSI-X interrupts */
 ef4_for_each_channelchannel,efx)
   free_irq(channel->irq,
     &efx->msi_context[channel/* latest EF10 revision */
 }struct ef4_nic_reg {
  offset24;
  free_irq(fx-legacy_irq )
 }
}

/* Register dump */

#define REGISTER_REVISION_FA 1
# REGISTER_REVISION_FB 2
#define REGISTER_REVISION_FC 3
#define REGISTER_REVISION_FZ 3 /* last Falcon arch revision */
define REGISTER_REVISION_ED 4
#define REGISTER_REVISION_EZ 4 /* latest EF10 revision */

struct ef4_nic_reg {
 u32 :24;
 u32  REGISTER_REVISIO # arch ## max_rev    \
};

#define REGISTER(name, arch, min_rev, max_rev) {   \
 arch ## R_ ## min_rev ## max_rev ## _ ## name,   \
 REGISTER_REVISION_ ## arch ## min_rev,    \
 REGISTER_REVISION_ }
}
#define REGISTER_AA(name) REGISTER(name,#define REGISTER_AA(name) REGISTER(name, F, A, A)
#define REGISTER_AB(name) REGISTER(name F A, B)
#define REGISTER_AZ(name) REGISTER(name, F, A, Z)
#define REGISTER_BB(name#define REGISTER_AZ(name) REGISTER(name, F, A, Z)
#define REGISTER_BZ(#define REGISTER_BB(nameREGISTER(name,F B,Bjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
#)name ,Z

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 REGISTER_AZADR_REGION)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 REGISTER_AZ,
 REGISTER_BZ(INT_EN_CHAR),
 REGISTER_AZ(INT_ADR_KER),
REGISTER_BZ(INT_ADR_CHAR),
 /* INT_ACK_KER is WO */
 /* INT_ISR0 is RC */
 REGISTER_AZ /* INT_ACK_KER is WO */
 REGISTER_CZ(SR_EV_CFGjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 REGISTER_AB(EE_SPI_HCMD),
 REGISTER_AB(EE_SPI_HADR),
 REGISTER_AB(EE_SPI_HDATA),
 REGISTER_AB(EE_BASE_PAGE), REGISTER_CZ(USR_EV_CFG),
 REGISTER_AB(EE_VPD_CFG0),
 /* EE_VPD_SW_CNTL and EE_VPD_SW_DATA are not used */
 /* PMBX_DBG_IADDR and PBMX_DBG_IDATA are indirect */
 /* PCIE_CORE_INDIRECT is indirect */
 REGISTER_AB(NIC_STAT),
 REGISTER_AB(),
 REGISTER_AB( REGISTER_AB(EE_SPI_HD),
 /* FATAL_INTR_KER and FATAL_INTR_CHAR are partly RC */
 REGISTER_BZ(DP_CTRL),
 REGISTER_AZ(MEM_STAT),
 REGISTER_AZ(CS_DEBUG),
 REGISTER_AZ(ALTERA_BUILD),
 REGISTER_AZ(CSR_SPARE),
REGISTER_AB(),
 REGISTER_AB( /* PMBX_DBG_IADDR PBMX_DBG_IDATA are indirect *
 REGISTER_AB(PCIE_PCS_CTL_STAT (NIC_STAT)
 /* DEBUG_DATA_OUT is not used */GPIO_CTL)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 /* DRV_EV is WO */
 java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 22
 REGISTER_AZ(S_DEBUG)
 REGISTER_AZ REGISTER_AZ(ALTERA_BUILD),
 REGISTER_AZ(BUF_TBL_CFG),
 REGISTER_AZ(SRM_RX_DC_CFG),
 REGISTER_AZ(SRM_TX_DC_CFG),
  REGISTER_AZ(CSR_SPARE),
 /* BUF_TBL_UPD is WO */
 REGISTER_AZ(SRM_UPD_EVQ),
 REGISTER_AZ( REGISTER_AB(PCIE_SD_CTL0123),
 REGISTER_AZ(RX_CFG),
 REGISTER_BZ(RX_FILTER_CTL),
 /* RX_FLUSH_DESCQ is WO */
 REGISTER_AZ(RX_DC_CFG),
 REGISTER_ABPCIE_SD_CTL45),
 REGISTER_BZ(RX_RSS_TKEY),
 /* RX_NODESC_DROP is RC */
 REGISTER_AA(RX_SELF_RST),
 /* RX_DEBUG, RX_PUSH_DROP are not used */REGISTER_AB(PCIE_PCS_CTL_STAT),
 REGISTER_CZ(RX_RSS_IPV6_REG1),
 REGISTER_CZT/* DEBUG_DATA_OUT is not used */
 REGISTER_CZ(RX_RSS_IPV6_REG3 /* DRV_EV is WO */
 /* TX_FLUSH_DESCQ is WO */
 REGISTER_AZ(TX_DC_CFG),
 REGISTER_AA(TX_CHKSM_CFG),
 REGISTER_AZ(TX_CFG),
/
 REGISTER_AZ(TX_RESERVED),
 REGISTER_BZ(TX_PACE),
 /* TX_PACE_DROP_QID is RC */
 REGISTER_BB(TX_VLAN),
 (TX_IPFIL_PORTEN),
 REGISTER_AB(MD_TXD),
 REGISTER_AB(MD_RXD),
 REGISTER_AB(MD_CSREGISTER_AZ(SRM_RX_DC_CFG),
 REGISTER_AB(MD_PHY_ADR),
 REGISTER_AB(MD_ID),
 /* MD_STAT is RC */
 REGISTER_AB( REGISTER_AZ(SRM_CFG)
 java.lang.StringIndexOutOfBoundsException: Range [24, 15) out of bounds for length 24
 REGISTER_BB(GEN_MODE),
 REGISTER_AB REGISTER_AZ(SRAM_PARITY),
 REGISTER_AB(MAC_MC_HASH_REG1),
 REGISTER_AB( REGISTER_AZ(RX_CFG),
 REGISTER_AB(GM_CFG2),
 /* GM_IPG and GM_HD are not used */
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 /* GM_TEST is not used */
 REGISTER_AZ(),
 REGISTER_AB(GM_ADR2 REGISTER_AZ(RX_DC_PF_WM),
 REGISTER_AB(GMF_CFG0),
 REGISTER_AB(GMF_CFG1),
 REGISTER_AB( REGISTER_BZ(RX_RSS_TKE),
 REGISTER_AB( /* RX_NODESC_DROP RC*/
REGISTER_AA(RX_SELF_RST),
 REGISTER_AB(GMF_CFG5), * RX_DEBUG, RX_PUSH_DROP are not used */
 java.lang.StringIndexOutOfBoundsException: Range [27, 12) out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Range [29, 24) out of bounds for length 24
 REGISTER_AB(XM_ADR_HI),
 (XM_GLB_CFG),
 REGISTER_AB(XM_TX_CFG),
 REGISTER_AB(XM_RX_CFG),
 REGISTER_ABREGISTER_AA(TX_CHKSM_CFG),
 REGISTER_AB(XM_FC),
 REGISTER_AB(XM_PAUSE_TIME),
 (XM_TX_PARAM),
 REGISTER_AB(XM_RX_PARAM),
 /* XM_MGT_INT_MSK (note no 'A') is RC */
 REGISTER_AB(X_PWR_RST),
 REGISTER_AB(XX_SD_CTL),
 REGISTER_AB(XX_TXDRV_CTL),
 /* XX_PRBS_CTL, XX_PRBS_CHK and XX_PRBS_ERR are not used */
 /* XX_CORE_STAT is partly RC */
};

struct java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 22
 u32 offset:24),
 u32 REGISTER_BZ(),
  REG(D_TXD,
};

#define REGISTER_AB(),
 offset,        \
 REGISTER_REVISION_ #arch#    \
 REGISTER_REVISION_#  # ,  \
 step,rows   \
}
#define REGISTER_TABLE(name, arch/* MD_STAT is RC */
 REGISTER_TABLE_DIMENSIONS(     \
 name  #R_ #min_rev# #  # name java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  arch, min_rev, max_rev,     \
  arch ## R_ ## min_rev ## max_rev ## _ ## name ## REGISTER_ABGM_CFG2,
 * GM_IPG and GM_HD are not used */
)  ,)
#define * GM_TEST is not used */
# REGIST(java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 23
# ()REGISTER_TABLEname ,B Z)
# REGISTER_TABLE_BB_CZname)   java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 REGISTER_TABLE_DIMENSIONS,FR_BZ_ # java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   REGISTER_AB)
      FR_BB_ ## name ## _ROWS),  \
 REGISTER_TABLE_DIMENSIONS(,FR_BZ_# name ,, ,\
       REGISTER_AB),
 REGISTER_ABXM_TX_PARAM)
REGISTER_AB(XM_RX_PARAM),

static const struct/
 /* DRIVER is not used */
 /* EVQ_RPTR, TIMER_COMMAND, USR_EV and {RX,TX}_DESC_UPD are WO */
 REGISTER_TABLE_BB}
  ef4_nic_reg_table
 u32 offset;
 java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 39
 REGISTER_TABLE_AA
 (TX_DESC_PTR_TBL),
 REGISTER_TABLE_AA(EVQ_PTR_TBL_KER),
 REGISTER_TABLE_BB_CZ(EVQ_PTR_TBL),
 /* We can't reasonably read all of the buffer table (up to 8MB!).offset,     \
  * However this driver will only use a few java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 44
   1K entries allows for some expansion of queue count and
 * size before we need to change the version. */
 REGISTER_TABLE_DIMENSIONS(BUF_FULL_TBL_KER, FR_AA_BUF_FULL_TBL_KER,
      F, A, A, 8, 1024),
 REGISTER_TABLE_DIMENSIONS(BUF_FULL_TBL, FR_BZ_BUF_FULL_TBL,
      F, B, Z, 8, 1024),
 REGISTER_TABLE_CZ(RX_MAC_FILTER_TBL0),
 REGISTER_TABLE_BB_CZ(TIMER_TBL),
 REGISTER_TABLE_BB_CZ(TX_PACE_TBL),
 REGISTER_TABLE_BZ(RX_INDIRECTION_TBL),
 /* TX_FILTER_TBL0 is huge and not used by this driver */
 REGISTER_TABLE_CZ(TX_MAC_FILTER_TBL0),
 REGISTER_TABLE_CZ(MC_TREG_SMEM),
 /* MSIX_PBA_TABLE is not mapped */
 /* SRM_DBG is not mapped (and is redundant with BUF_FLL_TBL) */
 REGISTER_TABLE_BZ(RX_FILTER_TBL0),
};

size_t ef4_nic_get_regs_len(struct ef4_nic *efx)
{
 const struct ef4_nic_reg *reg;
 const struct ef4_nic_reg_table *table;
 size_t len =0;

 for (reg = ef4_nic_regs;
      reg < ef4_nic_regs + name arch##R_# min_rev# max_rev # _ # name,java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        arch ## R_ ##min_rev ## max_rev ## _ ## name ## _STEP, \
on> reg->in_revision &&
      efx->type->revision <= reg->max_revision)
   len += sizeof#define REGISTER_TABLE_AA(name) REGISTER_TABLE(name, F, A, A)

 for (#efineREGISTER_TABLE_BB(name) REGISTER_TABLE(name, F, B, B)
      #efine REGISTER_TABLE_BZ(name) REGISTER_TABLE(name, F, B, Z)
 able+)
  if (efx REGISTER_TABLE_DIMENSIONSB B,\
      efx->type->revision <= table->max_revision)
   len +=table->rows * min_t(size_t, table->step, 16);

 return    FR_BB_ # name ##_ROWS)  \
}

void ef4_nic_get_regs(struct ef4_nic *efx, void *buf)
{
 const struct ef4_nic_reg *reg;
 const struct ef4_nic_reg_table *table;

 for #define REGISTER_TABLE_CZ(name) REGISTER_TABLE(name, F, C, Z)
      static const struct ef4_nic_reg_table ef4_nic_reg_tables[] = {
      reg++) {
  if (efx->type->revision > /* EVQ_RPTR, TIMER_COMMAND, USR_EV and {RX,TX}_DESC_UPD are WO */
      efx->typeREGISTER_TABLE_BB(TX_SRC_MAC_TBL),
   ef4_reado(efx, (ef4_oword_t *)buf, reg REGISTER_TABLE_AA(RX_DESC_PTR_TBL_KER),
   buf += sizeof(ef4_oword_t);
  }
 }

 for (table = ef4_nic_reg_tables;
      table < ef4_nic_reg_tables + ARRAY_SIZE(ef4_nic_reg_tables);
      table++) {
  size_t size, i;

  if (!(efx->type->revision >= table->min_revisionREGISTER_TABLE_AA(EVQ_PTR_TBL_KER),
        efx->type->revision <= table->max_revision))
   continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  size * However this driverwillonly  a entries.  Reading

  for (i = 0; i < table->rows; i++) {
   switch (table->step) {
   case 4: /* 32-bit SRAM */ *1Kentries allows for some expansion of queue count and
    ef4_readd(efx, buf
    break;
   case 8: /* 64-bit SRAM */
    (efx,
            efx->membase + table->offset,
            buf    F,A A 8, 1024,
    break;
   case 16: /* 128-bit-readable register */
 _reado_table(efx, buf, table->offset, i);
    break;
   case  REGISTER_TABLE_CZ(RX_MAC_FILTER_TBL0),
    ef4_reado_table(efx, buf, table- REGISTER_TABLE_BB_CZ(TIMER_TBL),
    break;
   default:
    WARN_ON();
    return;
   }
   buf += size REGISTER_TABLE_BZ(RX_INDIRECTION_TBL),
  }
 }
}

/**
 * ef4_nic_describe_stats - REGISTER_TABLE_CZ(TX_MAC_FILTER_TBL0),
 * @: Array of&struct ef4_hw_stat_desc describing the statistics
 * of the @desc array
 * @size_t ef4_nic_get_regs_len(struct ef4_nic *efx)
 *   ef4_nic_reg_table*java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 intervalsof%ETH_GSTRING_LEN bytes.
 *
 *Returns the number of visible statistics, i.e. the number of set
 * bitsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
size_t ef4_nic_describe_stats(const struct ef4_hw_stat_desc *java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 14
         const unsigned      efx->type->revision <=java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
{ ;
 size_t}
 size_t index;

 for_each_set_bit(index, mask, count) void ef4_nic_get_regs(struct ef4_nic *efx, void *buf)
  if (desc[index].name) {
   if (names)
    ethtool_puts(names const struct ef4_nic_reg_table *table;
   ++visible;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

  reg <ef4_nic_regs + ARRAY_SIZE(ef4_nic_regs);
}

/**
 * ef4_nic_update_stats  reg+++ {
  @desc: Array of &struct ef4_hw_stat_desc describing the DMA buffer
*layout.  DMA widths  0,16,32 and 64  supported;where
 * the width is specified as java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
 *@tats is not updated.
 * @count:      table++) {
 * @java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 * @stats: Buffer to update with the converted statistics.  The length
 * of this array must be at least @count switch t-s){
          efx>membase + table->offset,
 *@accumulate:Ifset, the converted values will be added rather than
 *directly stored to the corresponding elements of @stats
 */
void ef4_nic_update_stats(const struct ef4_hw_stat_desc *desc, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 52
     const unsigned long *mask,
     u64 *java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 11
{
 size_t index;

 for_each_set_bit(index  return;
 if (desc[index].dma_width) {
   const void *addr = dma_buf + desc[index].offset;
   u64 val;

  switch (desc[index].dma_width) {
   case 16:
    val = le16_to_cpup((__le16 *)addr)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   case 32:
     * @des:Array of &struct ef4_hw_stat_desc describing the statistics
    break;
   case 64:
    val = le64_to_cpup((__le64 *)addr);  @ount: Lengthofthe @esc 
    break;
   default:
    WARN_ON( *@:Bitmask of  elements of @esc are enabled
    val = 0;
    break;
   }

   if (accumulate)
    stats[index] += val;
  else
    stats[index] = val;
  }
 }
}