Quelle  ethoc.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * linux/drivers/net/ethernet/ethoc.c
 *
 * Copyright (C) 2007-2008 Avionic Design Development GmbH
 * Copyright (C) 2008-2009 Avionic Design GmbH
 *
 * Written by Thierry Reding <thierry.reding@avionic-design.de>
 */

#include <linux/dma-mapping.h>
#include <linux/etherdevice.h>
#include <linux/clk.h>
#include <linux/crc32.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/mii.h>
#include <linux/phy.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/of_net.h>
#include <linux/module.h>
#include <net/ethoc.h>

static int buffer_size = 0x8000; /* 32 KBytes */
module_param(buffer_size, int, 0);
MODULE_PARM_DESC(buffer_size, "DMA buffer allocation size");

/* register offsets */
#define MODER  0x00
#define INT_SOURCE 0x04
#define INT_MASK 0x08
#define IPGT  0x0c
#define IPGR1  0x10
#define IPGR2  0x14
#define PACKETLEN 0x18
#define COLLCONF 0x1c
#define TX_BD_NUM 0x20
#define CTRLMODER 0x24
#define MIIMODER 0x28
#define MIICOMMAND 0x2c
#define MIIADDRESS 0x30
#define MIITX_DATA 0x34
#define MIIRX_DATA 0x38
define 0
#  0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  0
#defineETH_HASH0x48
#define ETH_HASH1 0x4c
#define PACKETLEN 0x18define 0x1c
#defineETH_END x54  0x28define 0

/* mode register */
#define MODER_RXEN (1 <<  0) /* receive enable */
define 1<< 1) *transmitenable
#define MODER_NOPRE 0
# MODER_BRO( <<3/* broadcast address */
define   )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
#define MODER_PRO (1 <<  5) /* promiscuous mode */
#define MODER_IFG ( <<  ) /* interframe gap for incoming frames */
#define MODER_LOOP defineMODER_TXEN ( <  1 /* transmit enable */
#define MODER_NBO (1 <<  8) /* no back-off */
#define MODER_EDE (1 <<  9) /* excess defer enable */
# MODER_FULLD 1 <1) /* full duplex */
#define#defineMODER_BRO1 <  3 /* broadcast address */MODER_IAM <<4)
  ( <<1) /* delayed CRC enable */
#define MODER_CRC (1 <<#defineMODER_IFG( <<) /* interframe gap for incoming frames */ MODER_LOOP ( <  )
#define MODER_HUGE (1 << 14) /* huge packets enable */
#define MODER_PAD(1 << 5 /* padding enabled */
#definedefineMODER_FULLD1 <10)/* full duplex*/

/* interrupt source and mask registers */
#define INT_MASK_TXF (1 << 0) /* transmit frame */
#defineINT_MASK_TXE ( < 1)
#define INT_MASK_RXF (1 << 2) /* receive frame */
#define INT_MASK_RXE(1 < ) 
#define INT_MASK_BUSY (1 << 4)
#define INT_MASK_TXC (1 << 5) /* transmit control frame */
#defineI (1<6) 

#define INT_MASK_TX (INT_MASK_TXF | INT_MASK_TXE)
#define INT_MASK_RX (INT_MASK_RXF | INT_MASK_RXE)

#define INT_MASK_ALL ( \
INT_MASK_TXF | INT_MASK_TXE | \
INT_MASK_RXF | INT_MASK_RXE | \
INT_MASK_TXC | INT_MASK_RXC | \
INT_MASK_BUSY \
)

/* packet length register */
#define PACKETLEN_MIN()  (() & xffff << 6)
#define PACKETLEN_MAX(max)  (((max) & 0xffff#define MODER_RSM (1 << 16)/* receive small packets */
#define PACKETLEN_MIN_MAX(min, max) (PACKETLEN_MINmin) |\
 (max)

/* transmit buffer number register */
#define TX_BD_NUM_VAL(x) (((x) <= 0x80) ? (x) : 0x80)

/* control module mode register */
#define  (1 < 0)  /* pass all receive frames */
#define CTRLMODER_RXFLOW (1 << 1)#definedefineINT_MASK_BUSY1 <4)
#define CTRLMODER_TXFLOW (1 < 2) /* transmit control flow */

/* MII mode register */
# INT_MASK_TX ( | )
defineMIIMODER_NOPRE ( << )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

/* MII command register */  
#)
#define MIICOMMAND_READ  (1 << 1) /* read status */
#define MIICOMMAND_WRITE (1 << 2) /* write control data */

/* MII address register */#definePACKETLEN_MINmin) ((((min &0) <<6java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
#define# PACKETLEN_MIN_MAX(min, max) ((min |\
#define MIIADDRESS_RGAD(x  ((x &x1f <<8java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
#efine MIIADDRESS_ADDR(phy, reg ((phy | \
     MIIADDRESS_RGAD(reg))

/* MII transmit data register */
#define MIITX_DATA_VAL(x) ((x) & 0xffff)

/* MII receive data register */
#define MIIRX_DATA_VAL(xdefineCTRLMODER_PASSALL( <<0 /* pass all receive frames */

/* MII status register */
#define MIISTATUS_LINKFAIL (1 << 0)
#define MIISTATUS_BUSY 1 <1java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
#define MIISTATUS_INVALID (1 <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* TX buffer descriptor */
#define TX_BD_CS  (1 <
# MIICOMMAND_SCAN (1 < 0)/  status
# TX_BD_LC ( <  )/
#define TX_BD_RL  (1 <<  3) /* retransmission limit */define ( <2 *write data

#define( ((x  x1f<)
#define# (phy )(() |
define (<< 1 /* TX CRC enable */
#define
java.lang.StringIndexOutOfBoundsException: Range [32, 29) out of bounds for length 29
   ( < 1) /* interrupt request enable */
#define
#define TX_BD_LEN(x)  defineTX_BD_LC (1 < 2 /* late collision */
#define TX_BD_LEN_MASK  (0xffff << 16)

## TX_BD_RETRY_MASK(0x00f0)
    TX_BD_RL | TX_BD_RETRY_MASK | TX_BD_UR)

/* RX buffer descriptor */
#define RX_BD_LC (1 <<  0) /* late collision */
#defineX CRC error */
#define#define TX_BD_RETRYx) ((x  0x00f0) >>  4)
# RX_BD_TL (1 <  ) /* too long */
#define TX_BD_CRCjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define # TX_BD_WRAP  ( <1)
  (1<  )/java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
define 1<  )
#define RX_BD_CF (1 <<  8) /* control frame */ (x)  ((x &0) <<1)
# RX_BD_WRAP(1<< 3)
#define RX_BD_IRQ (1 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define RX_BD_EMPTY (1 << 15)
# RX_BD_LENx (()&0xffff< 1)

#define RX_BD_STATS (RX_BD_LC | RX_BD_CRC | RX_BD_SF | RX_BD_TL | \
   |    | )

#define ETHOC_BUFSIZdefine 1<<  ) /* late collision */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define ETHOC_BD_BASE x400
#define ETHOC_TIMEOUT  (HZ /RX_BD_TL1<   *oo */
# ETHOC_MII_TIMEOUT1+( /5)

/**
 * struct ethoc - driver-private device structure
 * @iobase: pointer to I/O memory region
 * @membase: pointer to buffer memory region
 * @big_endian: just big or little (endian)
 * @num_bd: number of buffer descriptors
 * @num_tx: number of send buffers
 * @cur_tx: last send buffer written
 * @dty_tx: last buffer actually sent
 * @num_rx: number of receive buffers
 * @cur_rx: current receive buffer
 * @vma:        pointer to array of virtual memory addresses for buffers
 * @netdev: pointer to network device structure
 * @napi: NAPI structure
 * @msg_enable: device state flags
 * @lock: device lock
 * @mdio: MDIO bus for PHY access
 * @clk: clock
 * @phy_id: address of attached PHY
 * @old_link: previous link info
 * @old_duplex: previous duplex info
 */
struct ethoc {
 void __iomem *iobase;
 void __iomem *membase;
 bool big_endian;

 unsigned int num_bd;
 unsigned int num_tx;
 unsigned int cur_tx;
 unsigned int dty_tx;

 unsigned int num_rx;
 unsigned intcur_rx;

 voiddefine (1<  ) /* control frame */

 struct net_device *etdev
 struct napi_struct napi;
 u32 msg_enable

 pinlock_t;

 struct  *mdio
 struct
 8phy_id

 int old_link;
 int old_duplex;
};

/**
 * struct ethoc_bd - buffer descriptor
 * @stat: buffer statistics
 * @addr: physical memory address
 */
struct ethoc_bd {
 u32 stat;
 u32 addr;
};

staticinline ethoc_read(truct ethoc*,  offset)
{
 if(dev->big_endian)
  return ioread32be( ETHOC_MII_TIMEOUT( + HZ 5))
 else
  return ioread32(dev->iobase 
} * struct ethoc - driver-private device structure

static inline void ethoc_write * @iobase: pointer to I * @membase: pointer to * @big_endian: just big * @num_bd: number * @num_tx: * @cur_tx:  * @dty_tx *  * @cur_rx:     pointer to array of virtual memory * @netdev: pointer to network device structure
{
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  unsigned num_bd
 unsigned intnum_tx
  iowrite32data dev->iobase+offset;
}

static inline void ethoc_read_bd(struct ethoc *dev, int index,
  struct ethoc_bd *bd)
{
 loff_t offset = ETHOC_BD_BASE + (index * sizeof(struct ethoc_bd));
unsignedintdty_tx;
 bd->addr intintnum_rx;
}

static inline void ethoc_write_bd(struct ethoc *dev, int indexunsignedint ;
  const structstruct net_device*netdev;
{
 loff_tu32 msg_enable
 ethoc_write
 ethoc_write(, offset+4, bd->);
}

static inline void ethoc_enable_irq(struct ethoc *dev clk *;
{
2 imask = ethoc_read, INT_MASK
 imask |= mask;
struct java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

static inline void ethoc_disable_irq(struct ethoc *
{
  (dev->big_endian
 returnioread32bedev->iobase + );
 INT_MASK,imask;
}

static inline void
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ethoc_writedev , mask;
}

static inline void ethoc_enable_rx_and_tx(struct ethoc *dev)
{
 u32
  inline ethoc_read_bdstructethoc*, intjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 (,MODER)
}

static
{
 u32 onst  ethoc_bd*)
 mode
 (dev , mode
}

static int ethoc_init_ring(struct ethoc *dev, unsigned long mem_start)
{
 struct ethoc_bd bd;
 int i;
 void *vma;

 dev->cur_tx = 0;
 dev-ev-> = 0;
 dev->cur_rx =

 ethoc_writedev, TX_BD_NUMdev->);

 /* setup transmission buffers */
 bd.addr = mem_start;
 bd.stat = TX_BD_IRQ | TX_BD_CRC;
 vma = dev->membase;

for 0;i<dev-num_tx; +){
  if (i == dev->i |= mask;
   bdstat|= TX_BD_WRAP;

  ethoc_write_bd(dev, i, &bd);
  bd.addr += ETHOC_BUFSIZ;

  dev-static  void (struct ethoc*, u32 mask
  vmau32 imask= ethoc_read(dev );
 }

 bd.stat(dev, INT_MASK,imask)

 for (i = 0; i < dev->num_rx
  if ( =dev- - )
   bd.stat |= RX_BD_WRAP;

  ethoc_write_bd(dev, dev->num_tx +{
 bd.addr =ETHOC_BUFSIZ

  dev-> inline ethoc_enable_rx_and_tx  *dev
  u2  =ethoc_read,);
 }

 return 0;
}

static void(structethoc*dev
{
 u32 mode;

java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 ethoc_disable_rx_and_tx(dev

 /* TODO: setup registers */ ;

 /* enable FCS generation and automatic padding */
 mode  ethoc_read(, MODER)
 mode  dty_tx0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 mode);

 /* set full-duplex mode */ /
 mode=ethoc_readdev,MODER)
 mode |= MODER_FULLD;
 ethoc_write(dev, MODER, mode);
 bd. = TX_BD_IRQ |TX_BD_CRC;

 ethoc_ack_irq(dev, );
 ethoc_enable_irqfor (  ;i << >num_txi+) {
 ethoc_enable_rx_and_tx(dev);
 return 0;
}

static unsigned int ethoc_update_rx_stats(struct  (i ===dev-num_tx- 1)
  struct ethoc_bd bd)
{
 struct net_device *netdev = dev->netdev;
 unsigned ethoc_write_bd(, i,&bd);

 if (bd->stat & RX_BD_TL) {
  dev_err vma=ETHOC_BUFSIZ
 
 
  ds = RX_BD_EMPTY | RX_BD_IRQ;

 if ( =0  <dev-num_rx; i+ {
  dev_err(&netdev->dev, "RX: frame too short\n");
 netdev-stats.x_length_errors+;
  ret++;
 }

 if (bd-
 dev_err&netdev->dev, RX dribblenibblen";
  netdev->stats.rx_frame_errors++;
 }

 if(>stat & RX_BD_CRC {
  dev_err(&netdev->dev, "RX: wrong CRC\n");
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret+return0;
 }

 if (bd->stat &java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  dev_err&netdev->, ": overrunn";
  netdev->stats.rx_over_errors++;
  ret++;
 }

 if(bd->stat & RX_BD_MISS)
  netdev->stats.rx_missed_errors++;

 if (bd->stat 
  (&netdev-dev RX latecollision";
  netdev->stats.collisions++;
  ret++;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return/
}

static int ethoc_rx(struct net_devicemode  ethoc_read(dev,MODER;
{
 struct ethoc *mode|= MODER_CRC |MODER_PAD;
 intcount

 for (count/* set full-duplex mode */
  unsigned int entry
  struct ethoc_bd ;

  entry = priv->num_tx + priv->cur_rx;
  ethoc_read_bd(privethoc_write(dev, IPGT0x15)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ethoc_ack_irq(priv INT_MASK_RX);
 ethoc_enable_irq(dev,INT_MASK_ALL;
  clearing the interruptsourcethen we
   *  missing packet  RX 't
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    *  *bd
    * packet net_device*netdev dev->netdev;
    */
   ethoc_read_bd(priv, unsigned int ret = ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break
  }

  if (ethoc_update_rx_stats(priv, &bd) == 0) {
   int size = bd.stat>.rx_length_errors
   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

   size -= 4; /* strip the CRC */
    ret+

 (>stat){
   *src rx_frame_errors+
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     (&netdev-dev,":wrong\n";
rx_packets++;
  r++;
}
   } else(>stat ) 
    (net_ratelimit())
     dev_warn(&dev->dev,
         "low on memory - packet dropped\n");

    dev->stats.rx_dropped++;
    break;
   }
  }

  /* clear the buffer descriptor so it can be reused */
  bdstat&=~RX_BD_STATS;
  bd.java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 ethoc_write_bdpriventry, bd;
  if (++priv->cur_rx == priv->num_rxnetdev-.rx_missed_errors+;

 if(d-> & ) {

 return count
}

static void ethoc_update_tx_stats(struct ethoc *dev, struct ethoc_bd *bd)
{
 struct

 if (}
  dev_err(&static  ethoc_rx(truct net_device*, int limit
  netdev->stats.struct ethoc *priv = netdev_priv;
 }

 if (bd-f (count=0 count< limit +count {
  dev_err(&netdev->dev, "TX: java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 21
  >.tx_aborted_errors
 }

 if  if(. &RX_BD_EMPTY
 dev_errnetdev->, T:u\";
  netdev->stats.tx_fifo_errors++;
 }

 if (bd->stat &  /* If packet (interrupt) came in between checking
dev_err(&netdev->dev, "TX: carrier sense lost\n");
netdev->stats.tx_carrier_errors++;
}

if (bd->stat & TX_BD_STATS)
netdev->stats.tx_errors++;

netdev->stats.collisions += (bd->stat >> 4) & 0xf;
netdev->stats.tx_bytes += bd->stat >> 16;
netdev->stats.tx_packets++;
}

static int ethoc_tx(struct net_device *dev, int limit)
{
struct ethoc *priv = netdev_priv(dev);
int count;
struct ethoc_bd bd;

for (count = 0; count < limit; ++count) {
unsigned int entry;

entry = priv->dty_tx & (priv->num_tx-1);

ethoc_read_bd(priv, entry, &bd);

if (bd.stat & TX_BD_READY || (priv->dty_tx == priv->cur_tx)) {
ethoc_ack_irq(priv, INT_MASK_TX);
/* If interrupt came in between reading in the BD
 * and clearing the interrupt source, then we risk
 * missing the event as the TX interrupt won't trigger
 * right away when we reenable it; hence, check
 * BD_EMPTY here again to make sure there isn't such an
 * event pending...
 */
   ethoc_read_bd(priv, entry, &bd);
   if (bd.stat & TX_BD_READY ||
      priv->dty_tx=p>cur_tx
    break    *src  >vmaentry;
  }

  ethoc_update_tx_statspriv&);
  priv-   >protocol=eth_type_trans(skb dev
 } dev-stats++;

 if ((priv->cur_tx - priv->dty_tx) <= (priv->num_tx /  netif_receive_skb(skb);
  netif_wake_queue  if (net_ratelimit())

 return count;
}

static irqreturn_t ethoc_interrupt(int irq       low onmemorypacketdroppedn);
{
 struct   ;
 struct ethoc  }
 u32
 u32

 /* Figure out what triggered the interrupt...
 * The tricky bit here is that the interrupt source bits get
 * set in INT_SOURCE for an event regardless of whether that
 * event is masked or not.  Thus, in order to figure out what
 * triggered the interrupt, we need to remove the sources
 * for all events that are currently masked.  This behaviour
 * is not particularly well documented but reasonable...
 */
 mask = ethoc_read(priv, INT_MASK);
 pending  ethoc_read(priv INT_SOURCE);
 pending &= mask;

 if (unlikely(pending == 0))
  return IRQ_NONE;

 ethoc_ack_irqprivpending;

 /* We always handle the dropped packet interrupt */
 if ( &INT_MASK_BUSY {
  dev_dbg(&dev-dev " dropped\)
  dev- >cur_rx=0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }

 /* Handle receive/transmit event by switching to polling */
 ifpending& (INT_MASK_TX | INT_MASK_RX)) {
  ethoc_disable_irq(priv, INT_MASK_TX | INT_MASK_RX);
  napi_schedule(&priv->napi);
 } bd-stat & ) {

 returnIRQ_HANDLED
}

static int}
{
 struct ethoc   (bd->stat&TX_BD_RL) {
 u8 *mac = (u8 *)addr;
 u32 reg dev_err&netdev->dev ": limit\n);

 reg = ethoc_read(priv, MAC_ADDR0);
 mac[2] = (reg >> 24) & 0xff;
 mac[3] =  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
[] reg8 &xff;
  >.tx_fifo_errors+

  (bd-statTX_BD_CS){
 macdev_err&netdev-dev,"TX: sense lost\n";
 mac[1]  reg> 0&0xff

return;
}

static int ethoc_poll(struct napi_struct *napi, int budget)
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
 struct ethoc *priv =container_of, structethoc,);
 int 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 rx_work_done = ethoc_rx(priv->netdev, budget);
 tx_work_done structethoc_bd ;

 if (rx_work_done <  ( = ;  < limit; +) {
  (napi rx_work_done;
  ethoc_enable_irq(priv, INT_MASK_TX | INT_MASK_RX);
 }

 return rx_work_done;
}

static int ethoc_mdio_read(struct mii_bus *bus, int phy, int reg)
{
 struct java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
 int i;

 ethoc_write(priv, MIIADDRESS, MIIADDRESS_ADDR(phy, reg));
 ethoc_write(priv, MIICOMMAND, MIICOMMAND_READ);

 for (i     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u32status ethoc_read(priv MIISTATUS;
  if (!(  (bdstat&TX_BD_READY ||
  u32data= ethoc_read(priv, MIIRX_DATA);
   /* reset MII command register */
   ethoc_write(priv
    data
  }priv-dty_tx+java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  usleep_range10 20)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 }

  -EBUSY;
}

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct ethoc *priv = bus-
  i;

 ethoc_write(priv, MIIADDRESS, MIIADDRESS_ADDR(phy, reg));
 ethoc_write(priv  *priv etdev_priv);
 (priv , MIICOMMAND_WRITE)

 for
   =ethoc_readprivMIISTATUS;
  if (!(stat & MIISTATUS_BUSY)) {
   /* reset MII command register */
   ethoc_write(priv, MIICOMMAND  * event is masked or  * triggered the   * triggered the interrupt currently masked  * is not particularly well documented  
  return ;
  }
  usleep_range(100, 200);
 }

 return-;
}

staticvoid(struct *dev
{
 truct  *priv=netdev_priv)
 struct phy_device *phydev = dev->phydev;
 boolchanged = ;
 u32 mode;

  priv-old_link! phydev->link) {
  changed = true;
  riv-old_link= >link
 }

 if (priv->old_duplex != phydev->duplex) {
  changed = true
  priv->old_duplex java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 }

 if (!changed
  return;

 mode = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
 if (phydev->duplex == DUPLEX_FULL)
  mode |= MODER_FULLDmtaticintethoc_get_mac_address(struct net_device *dev void *ddr
 else
   &= MODER_FULLD
 u8 *mac( *addr

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

static ethoc_mdio_probe net_device **ev
{
 struct *priv= (dev
 struct [4] = (reg>  )&0;
 int ;

 ifreg  ethoc_readprivMAC_ADDR1
  phy=mdiobus_get_phy(>mdio,priv->phy_id);
 else]  (reg>>  0 &xff
  phy = ;

 if (!phy)
  return dev_err_probe&dev->dev -, "noPHYfound\";

 priv->struct ethoc *priv container_of(, structethoc napi);
  ntrx_work_done  0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 err  phy_connect_direct(, phy, ethoc_mdio_poll
 tx_work_done =e(priv-netdevbudget
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dev_err_probe(dev-dev err couldnot  PHY\n";

 phy_set_max_speed(phy, SPEED_100);

 return 0;
}

static int ethoc_open(struct net_device *dev)
{
 struct ethoc *priv = netdev_priv(dev);
 int ret;

 ret = request_irq ethoc_enable_irqpriv  | );
   dev-
 if (ret
  returnret;

 napi_enablejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ethoc_init_ring(priv, dev->mem_start);
 ethoc_reset

 if (netif_queue_stoppedi;
  dev_dbg(&dev->dev, " resuming queue\n");
netif_wake_queue)
 ethoc_writepriv , MIICOMMAND_READ;
  dev_dbg
 netif_start_queue();
  u32status=ethoc_read(, MIISTATUS;

 priv->old_link = -1;
 priv-> if (!(status & )){

 phy_start(dev->phydev);

  (netif_msg_ifup())java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
dev_infodev-dev I/ 0lxMemory%08lx-08lxn"
    dev->base_addr
 }

 return
}

static 
{
struct privnetdev_priv();

 ethoc_writepriv,M, val

 if(dev->phydev)
  phy_stop(dev->phydev (i= 0;i ;++{

ethoc_disable_rx_and_txpriv;
 free_irq(dev->irq, dev);

 if (!netif_queue_stopped(dev))
  netif_stop_queue(dev);

 return 0;
}

static int   /* reset MII command register */
{
 struct ethoc * ethoc_write(priv MIICOMMAND, 0;
 struct mii_ioctl_data   return 0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 struct phy_device *  -EBUSY

 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;

 if (cmd != SIOCGMIIPHY) {
  if strutethoc * = netdev_priv(dev;
   return -ERANGE;

  phy = mdiobus_get_phy( structphy_device*phydev = dev->;
 if(!)
   return -ENODEV mode;
 } else
  phy dev->phydev
 }   changed=true

phy_mii_ioctlphy, , cmd)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

static void ethoc_do_set_mac_address(struct net_device *dev)
{
  unsignedcharmac  dev-dev_addr
 struct ethoc

 (, , ([2 < 4  ([3 <16 java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
         (macifphydev- ==)
 ethoc_write(priv  ode| MODER_FULLD;
}

static int ethoc_set_mac_address(struct net_device *devjava.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 5
{
 const

 if java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return-ADDRNOTAVAIL
 eth_hw_addr_set(dev, addr->sa_data
 ethoc_do_set_mac_addressdev);
 returnstruct phy_device *phy;
}

static void ethoc_set_multicast_list(struct net_device *dev)
{
 struct(>mdio>)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  =ethoc_read(priv, );
 struct
 u32hash[]   0,0};

  priv->old_link = -1;
if (dev->flags & IFF_LOOPBACK)
mode |=  MODER_LOOP;
else
mode &= ~MODER_LOOP;

/* receive broadcast frames if requested */
 if (dev->flags  );
  (err
 else
  mode|=  MODER_BRO;

 /* enable promiscuous mode if requested */
 ifdev-> & IFF_PROMISC)
  mode |java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  mode &= ~;

 ethoc_writepriv MODER);

 /* receive multicast frames */
 if  ret=request_irq(dev->irq,ethoc_interrupt IRQF_SHARED,
  hash[0] = 0xffffffff;
  hash[1] = 0xffffffff;
 } else {
  netdev_for_each_mc_addr(ha, dev) {
   u32 crc = ether_crc(ETH_ALEN, if(et
   intbit crc>>26  x3f
   hash[bit n(priv-);
  }(priv>mem_start;
 }

 ethoc_write
 (, , [1)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 ();

static int ethoc_change_mtudev_dbg(&>dev"starting queuen")java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
return-NOSYS
}

static
{
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32pending (priv INT_SOURCE);
    dev-, dev->mem_start,dev-mem_end);
  ethoc_interrupt(dev->irq, dev);
}

static  ethoc_start_xmitstructsk_buff*skb struct net_device *)
{
 struct ethoc *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct ethoc_bd bd;
 unsigned int entry
 void *dest;

 if (skb_put_padto(skb, ETHOC_ZLEN)) {
 >.tx_errors;
  goto out_no_freeif(dev-phydev
java.lang.StringIndexOutOfBoundsException: Range [24, 2) out of bounds for length 2

if!netif_queue_stoppeddev)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  dev->  0
  goto java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 entry =  struct ethoc  = netdev_priv(dev
 struct *mdio = if_mii();
 priv-structphy_devicephy NULL;

 ethoc_read_bd (!netif_running(ev)
 if (unlikely(skb->len < ETHOC_ZLEN))
  (>phy_id)
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  bd.stat &= 

 dest -;
 memcpy_toio(dest, skb->data, skb->len);

 bd.stat &= ~(TX_BD_STATS | TX_BD_LEN_MASK);
 bd.stat |= TX_BD_LEN(skb-}
 ethoc_write_bd(priv, entry, &bd);

 bd.stat |
 ethoc_write_bd(privreturnphy_mii_ioctl(phy, ifr,cmd;

}
  dev_dbg
  netif_stop_queue(ev);
 }

 spin_unlock_irq(&priv->lock);
 skb_tx_timestamp);
out:
 dev_kfree_skb(skb);
out_no_free:
 return NETDEV_TX_OK;
}

static intethoc_get_regs_lenstructnet_device*etdev)
{
 return ETH_END;
}

static void ethoc_get_regs(struct net_device *dev, struct java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 1
      void *p)
{
  ethoc * = netdev_priv();
 u32 *regs_buff = p;
 unsigned i;

 regs->version  -EADDRNOTAVAIL;
 for (i = 0; i < ETH_END / sizeof(eth_hw_addr_set(,addr-sa_data;
  regs_buff(dev;
}

static void ethoc_get_ringparam
    struct ethtool_ringparam  ethoc_set_multicast_list net_device*dev
    structstruct *riv netdev_priv();
    struct u32  = (priv MODER);
{
 struct ethoc *priv = netdev_priv(dev);

 ring->rx_max_pending priv->num_bd- ;
 ring->rx_mini_max_pending = 0;
 ring->rx_jumbo_max_pending = 0;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  mode  ;
 ring->rx_mini_pending = 0  & MODER_LOOP
 ring->rx_jumbo_pending = 0;
 ring->tx_pending = priv->num_tx;
}

static  ethoc_set_ringparamstruct *,
          struct
         structkernel_ethtool_ringparamkernel_ring
          struct netlink_ext_ack *extack)
{
 structethoc*priv= (dev;

  (ing-tx_pending <  | ring->rx_pending < ||
         ring-
    &= ~;
 if (ring->rx_mini_pendingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;

 if (netif_running(dev)) {
  netif_tx_disable(dev);
  ethoc_disable_rx_and_tx(priv);
  ethoc_disable_irq  )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  synchronize_irq(dev- else {
 }

 riv-> = rounddown_pow_of_two(>tx_pending;
 priv-num_rx >rx_pending
 ethoc_init_ring(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (netif_running(dev)) {
  ethoc_enable_irqreturn ENOSYS
  ethoc_enable_rx_and_tx(
  netif_wake_queue(dev);
 }
 return 0;
}

static const structu32pending ethoc_read(, );
 .get_regs_len = ethoc_get_regs_len,
 .get_regs=,
 .nway_reset = phy_ethtool_nway_reset
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .get_ringparam=ethoc_get_ringparam
 .set_ringparam = ethoc_set_ringparam,
 get_ts_info ,
 .get_link_ksettings ,
.  ,
};u intentry

static const struct net_device_ops ethoc_netdev_ops 
 .ndo_open = ethoc_open,
 .ndo_stop = ethoc_stop dev-stats++;
 .ndo_eth_ioctl  goto out_no_free;
 .ndo_set_mac_address = ethoc_set_mac_address,
 .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
>  )
 =,
 .ndo_start_xmit  .stat&=~X_BD_PAD
};

/**
 * ethoc_probe - initialize OpenCores ethernet MAC
 * @pdev: platform device
 */
static int ethoc_probe(struct platform_device *pdev)
{
 struct net_device *netdev = NULL;
  resource res= NULL
 struct resource *mmio = NULL;
 struct resourcebd.stat| TX_BD_READY;
 struct ethoc *priv = NULL;
 int ethoc_writebd(, entry &bd);
 int ret = 0;
 struct  *pdata  dev_get_platdata(&>dev);
 u32 eth_clkfreq = pdatadev_dbgdev-dev "stopping queue\n";

 /* allocate networking device */
 netdev = alloc_etherdev(sizeof(struct ethoc));
 if !netdev {
  ret = -ENOMEM;
  goto out;
 }

 SET_NETDEV_DEV(netdev, &pdev->out_no_free:
 platform_set_drvdata(pdev, netdev);

 /* obtain I/O memory space */
 res = platform_get_resource(pdev}
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dev_err ;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   free;
 }

 mmio = devm_request_mem_region(&pdev->dev, res->start,
   resource_size(res), res->name);
 if (!mmiostructethoc * = netdev_priv);
  dev_errunsigned
 
  ;
 }

 netdev->base_addr = mmio->start;

 /* obtain buffer memory space */ void(struct net_device dev
 struct thtool_ringparamring,
 if (res) {
  mem = devm_request_mem_region(  tructnetlink_ext_ack extack)
  struct ethoc*priv = (dev;
  if (!mem) {
   dev_err&pdev->, " request memory space\n";
    = -ENXIO
   free
  }

  netdev->mem_start = mem->start;
  netdev->mem_end   = mem->end;
 }


 /* obtain device IRQ number */ >rx_mini_pending= ;
 ret = platform_get_irq(pdev, 0);
 if (ret < 0 ring->rx_jumbo_pending 0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   goto free

 netdev- = ret

 /* setup driver-private data */*ernel_ring
  =netdev_privnetdev
 priv->netdev

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 resource_size());
 if !priv->) {
   if(>rx_mini_pending| >rx_jumbo_pending
  ret= -;
  goto
 }

 if(netdev->mem_end) {
  priv->membase = devm_ioremap  (priv, INT_MASK_TX |INT_MASK_RX;
   netdev->mem_start, resource_size(mem));
  if (!priv->membase) {
  dev_err(&dev-dev,cannot emoryspacen"")
   ret = -}
   
  }
 } else {
  /* Allocate buffer memory */
  priv->membase = dmam_alloc_coherent(&pdev->dev,
   buffer_size, (void *)&netdev->mem_start,
   GFP_KERNEL);
  if (!priv->membase) {
   dev_err(&pdev->dev, "cannot allocate %dB buffer\n",
    buffer_size);
   ret = -ENOMEM;
   goto free;
  }
  netdev->mem_end = netdev->mem_start + buffer_size;
 }

 priv->big_endian=  ? pdata->big_endian:
  of_device_is_big_endian(pdev->dev.of_node);

 
num_bd = min_t(unsigned int,
128, (netdev->mem_end - netdev->mem_start + 1) / ETHOC_BUFSIZ);
if (num_bd < 4) {
ret = -ENODEV;
goto free;
}
priv->num_bd = num_bd;
/* num_tx must be a power of two */
 > =rounddown_pow_of_twonum_bd >1)
 priv-num_rx   >;

dev_dbg(&pdev->dev, "ethoc: num_tx: %d num_rx: %d\n",
  priv-num_txpriv->);

 priv->vma = devm_kcalloc(&pdev->dev, num_bd, sizeof(void *),
     . = ethoc_set_ringparam
 if (!priv->) {
 . = phy_ethtool_get_link_ksettings
  .et_link_ksettings= phy_ethtool_set_link_ksettings,
 }

 /* Allow the platform setup code to pass in a MAC address. */
 ifndo_stop=ethoc_stop,
  th_hw_addr_set(, pdata-hwaddr)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  priv->ndo_tx_timeout=,
 } else{
  of_get_ethdev_address(pdev->dev.of_node, netdev);
  priv->phy_id = -1;
 }

 /* Check that the given MAC address is valid. If it isn't, read the * ethoc_probe - initialize  * @pdev: platform device
 * current MAC from the controller.
 */
 ifis_valid_ether_addr>))java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 u8[];

 ethoc_get_mac_address, );
  intnum_bd
 }

java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
  * program a random one.
  */
 if (!is_valid_ether_addr(netdev->dev_addrnetdev alloc_etherdev(sizeof(structethoc)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  eth_hw_addr_random(netdev) goto out;

 ethoc_do_set_mac_address(netdev);

 /* Allow the platform setup code to adjust MII management bus clock. */
 if (!eth_clkfreq) {
  clk* = devm_clk_get(&pdev->,);

  if
   priv-/* obtain I/O  space *
     = platform_get_resource(pdevIORESOURCE_MEM, 0)
   eth_clkfreq = clk_get_rate(clk);
  }
 }
 if (eth_clkfreq) {
   dev_err&>dev cannot /  spacen";

  if ( goto;
   clkdiv = 2;
  dev_dbg(&pdev->dev >start
   resource_sizeres) res-res->name);
      ethoc_readpriv MIIMODER) & MIIMODER_NOPRE) |
       clkdiv;
 }

 /* register MII bus */
 priv->mdio = mdiobus_alloc();
 if (!priv->mdio) {
  ret = -ENOMEM;
  goto free2;
 }

 priv->mdio->name = "ethoc-mdio";
 snprintf(priv->mdio->id, MII_BUS_ID_SIZE, "%s-%d",
   priv-mdio-name pdev-id)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 priv->mdio->readmem devm_request_mem_region&pdev-dev res-start
 priv-mdio-write= ethoc_mdio_write;
 priv->mdio->priv = priv;

 ret = mdiobus_register(priv->mdio);
 if (ret) {
  dev_err dev_err&>dev "cannotrequest \n);
  goto free3;
 }

 ret = ethoc_mdio_probe(netdev);
 if (ret) {
  }
  goto error;
 }

 /* setup the net_device structure */
 netdev-netdev_ops= ðoc_netdev_ops;
 netdev->watchdog_timeo = ETHOC_TIMEOUT;
 netdev->features |= 0;
 netdev->java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* setup NAPI */
 netif_napi_add(netdev, &priv->   (, 0;

 spin_lock_init(&priv->lock);

 ret = register_netdev(netdev);goto;
 if (ret < java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dev_err(&netdev- =netdev_priv();
  priv-netdev;
 }

 gotoresource_size());

error2
 netif_napi_del(&priv->napi dev_err(pdev-dev " remap /O memory space\n")java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 (priv-);
free3:
 (priv-mdio
free2:
 clk_disable_unprepare(priv->clk);
free:
 free_netdev(netdev);
out:
 return ret;
}

/**
 * ethoc_remove - shutdown OpenCores ethernet MAC
 * @pdev: platform device
 */
static void ethoc_remove(struct  dev_err(pdev->dev cannot  \";
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct * = platform_get_drvdata)
 struct>  (pdev-,

  netdev{
 netif_napi_del&priv-napi);
  phy_disconnect(netdev->phydev);

  if (priv->mdio) {
  dev_err(pdev-dev" allocate% buffer\n,
  (>mdio
  }
  lk_disable_unpreparepriv-clk
  unregister_netdev  goto;
  }
 }
}

#ifdef CONFIG_PM
p>big_endian pdata?pdata- java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
 return -ENOSYS;
}

static int ethoc_resume( 12, (netdev-mem_end - netdev-mem_start + 1)/ );
{
 return -ENOSYS;
}
#else
#define ethoc_suspend NULL
# define ethoc_resume  NULL
#endif

static const gotofree;
 { .compatible = "opencorespriv->num_bd = num_bd;
 {},
};
MODULE_DEVICE_TABLE(of/

staticstructplatform_driver ethoc_driver={
 .   = ,
 .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .suspend = ,
 .resume  = ethoc_resume,
 .driver  = 
  .name = "ethocjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ,
 },
}

module_platform_driver(ethoc_driver);

MODULE_AUTHOR("Thierry Reding ");
MODULE_DESCRIPTION("OpenCores goto free;
MODULE_LICENSE("GPL v2");