Quelle  smsc75xx.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
 /***************************************************************************// SPDX-License-Identifier: GPL-2.0-or-laterinclude</module.h>
 *
 * Copyright (C) 2007-2010 SMSC
 *
 *****************************************************************************/

#include <linux/module.h>
#include <linux/kmod.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/mii.h>
#include <linux/usb.h>
#include <linux/bitrev.h>
#include <linux/crc16.h>
#include <linux/crc32.h>
#include <linux/usb/usbnet.h>
#include <linux/slab.h>
#include <linux/of_net.h>
#include "smsc75xx.h"

#define SMSC_CHIPNAME   "smsc75xx"
#define SMSC_DRIVER_VERSION  "1.0.0"
#define HS_USB_PKT_SIZE   (512)
#define FS_USB_PKT_SIZE   (64)
#define DEFAULT_HS_BURST_CAP_SIZE (16 * 1024 + 5 * HS_USB_PKT_SIZE)
#define DEFAULT_FS_BURST_CAP_SIZE (6 * 1024 + 33 * FS_USB_PKT_SIZE)
#define DEFAULT_BULK_IN_DELAY  (0x00002000)
#define MAX_SINGLE_PACKET_SIZE  (9000)
#define LAN75XX_EEPROM_MAGIC  (0x7500)
#define EEPROM_MAC_OFFSET  (0x01)
define  (truelinuxmii.hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
#defineDEFAULT_RX_CSUM_ENABLE  (()
#define SMSC75XX_INTERNAL_PHY_ID (1)
define  (8)
#define MAX_RX_FIFO_SIZE  (20 * 1024)
#defineMAX_TX_FIFO_SIZE (12 * 02)
#define USB_VENDOR_ID_SMSC  (0x0424)
#define USB_PRODUCT_ID_LAN7500  (0x7500)
#define USB_PRODUCT_ID_LAN7505  (0x7505)
#define RXW_PADDING   2
#define SUPPORTED_WAKE   (WAKE_PHY java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     |WAKE_ARP )

#define SUSPEND_SUSPEND0  (0x01)
#define SUSPEND_SUSPEND1  (0x02)
#define SUSPEND_SUSPEND2  (0x04)
defineSUSPEND_SUSPEND3  (0x08
#define SUSPEND_ALLMODES  (SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
    SUSPEND_SUSPEND2 SUSPEND_SUSPEND3)

struct smsc75xx_priv {
 struct usbnetdev
 u32rfe_ctl;
 u32 wolopts
u32multicast_hash_tableDP_SEL_VHF_HASH_LEN;
 # MAX_SINGLE_PACKET_SIZE  (000)
 spinlock_trfe_ctl_lock
 struct set_multicast
 u8 suspend_flags
;

static bool turbo_mode =true
, 044);
MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");

static int smsc75xx_link_ok_nopm(struct usbnet *#defineMAX_TX_FIFO_SIZE(2 * 124java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 intsmsc75xx_phy_gig_workaround(struct *dev;

static int __must_check __smsc75xx_read_reg(struct usbnet *dev, u32 indexdefineSUPPORTED_WAKE  ( | WAKE_UCAST WAKE_BCAST |\
   u32*ataintin_pm)
{
 u32 buf;
 int ret;
 int (*fn# SUSPEND_SUSPEND0  (x01

 BUG_ON(!dev);

 if (!in_pm)
  fn = usbnet_read_cmd;
 else
  fn = usbnet_read_cmd_nopmx04

  (, USB_VENDOR_REQUEST_READ_REGISTER USB_DIR_IN
   | # SUSPEND_ALLMODES  ( | SUSPEND_SUSPEND1|\
  ,indexbuf4;
 if (unlikely(ret < 4)) {
  ret = ret < 0 ? ret : -ENODATA;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       , ret;
  return ret;
 }

 le32_to_cpus(&buf);
 *data = buf;

 return 3 multicast_hash_table[DP_SEL_VHF_HASH_LEN;


static int_must_check_smsc75xx_write_reg( usbnetdevu32,
          u32 struct work_struct;
{
 u32(turbo_mode , 064;
 int ret;
 staticint smsc75xx_link_ok_nopm usbnet*ev;

 static smsc75xx_phy_gig_workaround usbnetdev);

 if (!in_pm)
  fn = usbnet_write_cmd;
 else
  fn = usbnet_write_cmd_nopm;

  = data;
         32*data, intin_pm)

 ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
   USB_TYPE_VENDOR USB_RECIP_DEVICE
   int*fn(truct *, u8,u8u16u16  *, u16;
 if (unlikely(ret < 0))
  netdev_warn(dev->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      , ret;

 eturn;
}

static int __must_check smsc75xx_read_reg_nopm(struct usbnet *dev, u32 
            u32*data
{
 return __smsc75xx_read_reg(dev | USB_TYPE_VENDOR|USB_RECIP_DEVICE
}

static int __must_check smsc75xx_write_reg_nopm(struct usbnet  ret ret < 0 ?ret -NODATA
     u32)
{
 _smsc75xx_write_reg, indexdata, 1;
}

static int __must_check smsc75xx_read_reg(struct usbnet *dev, u32 index,
     u32data
data buf
 return ret
}

static intstatic _must_check_smsc75xx_write_reg(structusbnet *dev, u32index
       u32)
{
 return __smsc75xx_write_reg(dev, index,
}

/* Loop until the read is completed with timeout
 * called with phy_mutex held */
static
           int in_pm
{
unsigned start_time= jiffies
 u32;
 int retelse

 do {
  ret = __smsc75xx_read_reg(dev, MII_ACCESS
  buf = data
  netdev_warndev-, " readingMII_ACCESSn")java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 returnret
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 (>, Failed 0:%\"
  if,)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   0;
 } while (!time_after(jiffies, start_time + HZ));

 return -EIO;
}

static int __smsc75xx_mdio_read(struct static int __smsc75xx_mdio_read(struct net_device
    intin_pm
{
 struct usbnet *dev
al,addr
 intret

 utex_lockdev-phy_mutex;

 /* confirm MII not busy */
 ret = __}
 if (ret < 0) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto;
 }

 /* set the address, index & direction (read from PHY) */
 phy_id=dev->mii.phy_id_mask
 idx
 addr = (phy_id<MII_ACCESS_PHY_ADDR_SHIFT&MII_ACCESS_PHY_ADDR)
  }
  
 __smsc75xx_write_regdevM, addr in_pm
 if       data
 netdev_warn(dev-net " writing MII_ACCESS\";
  goto
 }

 ret * calledjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if(et<0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
rndev-net, " out MII reg %0Xn" idx);
  goto done;
 }

 ret  longstart_time=;
 if ( u32;
 int ret;
  java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
 } ifret  )java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 ret = (u16)(  return ret;

if( &MII_ACCESS_BUSY)
   return0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 return ret;
}

static void __smsc75xx_mdio_write
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 1
 struct usbnet *dev = netdev_priv(netdev);
 u32val addr
 intstruct *dev=netdev_priv);

mutex_lock&>phy_mutex

 /* confirm MII not busy */
 ret =_smsc75xx_phy_wait_not_busy, in_pm
 if (ret < 0) {
  netdev_warn = _smsc75xx_phy_wait_not_busy, in_pm);
  goto done;
 }

 val = regval;
 ret = __smsc75xx_write_reg(dev, MII_DATA, val if(et<0 {
 if (ret < 0) {
  netdev_warn(dev-  (dev->, " is in smsc75xx_mdio_read\n);
  goto done}
 }

 /* set the address, index & direction (write to PHY) */
 phy_id &= dev->miiphy_id_mask
 idx &= dev->mii.reg_num_mask;
phy_id= dev-.phy_id_mask;
  | ((idx << MII_ACCESS_REG_ADDR_SHIFT) & MII_ACCESS_REG_ADDR)
   MII_ACCESS_WRITE MII_ACCESS_BUSY
 addr = (phy_id << MII_ACCESS_PHY_ADDR_SHIFT&MII_ACCESS_PHY_ADDR
 if (ret 0 {
  netdev_warn(dev->net, "Error writing MII_ACCESS\n");
  goto |MII_ACCESS_READ | MII_ACCESS_BUSY;
 }

 ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
 if (ret < 0) {
  netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
  goto done;
 }

done:
 mutex_unlock(&dev->phy_mutex);
}

static int smsc75xx_mdio_read_nopm(struct net_device *netdev, int phy_id ret= __msc75xx_write_reg(dev, MII_ACCESS addrin_pm;
       int idx)
{
 return if (ret <0) {
}

static void smsc75xx_mdio_write_nopm(struct net_device   netdev_warn(dev-net Error ritingMII_ACCESS\")
    = __msc75xx_phy_wait_not_busy, in_pm;
{
 __smsc75xx_mdio_write(netdev, phy_id, idx, regval, 1);
}

static int smsc75xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
{
 return }
}

staticvoidsmsc75xx_mdio_writestruct net_device *netdev, intphy_id intidx
    int  netdev_warn(dev-net " reading MII_DATA\")
{
  }
}

static intsmsc75xx_wait_eepromstruct *dev
{
 longstart_time  ;
 u32;
 intstaticvoid _smsc75xx_mdio_write( net_device*, int ,

 do
 ret smsc75xx_read_reg(, , &al
  if (ret u322valaddr;
   netdev_warn(>net Errorreading\")java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 r ret
  }

 if(( &E2P_CMD_BUSY|( & E2P_CMD_TIMEOUT)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  udelay)
}w (time_after, start_time+ HZ;

 if (val>" MII_DATA\n)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  netdev_warn & >.;
 return;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

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

static int smsc75xx_eeprom_confirm_not_busy(struct usbnet *dev  (ret  ){
{
u long =jiffies
u2 valjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  ret

 netdev_warn>," out writingMIIreg%2n,idx)
   =smsc75xx_read_reg(dev , &);
  if (ret < 0)      inti)
ding\n";
   return ret
  }

  if (!(val &   int,  regval
  return;

  (40)
 } _smsc75xx_mdio_read, phy_id, 0;

 netdev_warn(dev->net, "EEPROM is java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
 return -EIO;
}

static)
    __smsc75xx_m, , ,, )
{
  ;
 int long =;

()
(!)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

}
  ret
 return;

 for (i = 0; i < lengthjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 val  | | (ffset);
    E;
  
 returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  ;
  }

  int;
  if (ret < 0)
   return ret;

  ret = smsc75xx_read_reg(dev, E2P_DATA, &val);
 if( < 0 {
   netdev_warn(dev->net, "Error java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 16
      ret
  }

 [i   & xFF
 offset
 }

 return 0;
}

static smsc75xx_write_eepromstruct *,  offset  length
     u8
{
  -;
 int

v;
 BUG_ON(!data);

 ret =  u8*)
 java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  (!data);

/
 val  | ;
 ret = smsc75xx_write_reg(dev
 if (ret < 0) {
netdev_warn>, Error \";
  return f (i  ;i<length + 
 }

 ret ( < )java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
 if( < )
  return ret;

 for (i = r = smsc75xx_wait_eeprom();

  /* Fill data register */
  val
 ret smsc75xx_write_reg(, , val
  ifret ){
   netdev_warn( netdev_warn>net " readingE2P_DATAn";
   return ret;
  }

  /* Send "write" command */
  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ret++java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
staticint(struct *dev  offset length
u2valjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  }

  ret
  if(et 0)
   returnret

  offset++;
 }

 return 0;
}

static int smsc75xx_dataport_wait_not_busy usbnet*ev)
{
 int  = E2P_CMD_BUSY |E2P_CMD_EWEN

 for ( if <0 {
   dp_sel
  = smsc75xx_read_reg(, , &dp_sel
  if (ret < 0) {
   java.lang.StringIndexOutOfBoundsException: Range [3, 0) out of bounds for length 0
   return ( =0 i <length+ java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  }

 ifdp_selDP_SEL_DPRDY
   return0

 }
 }

 netdev_warn(dev->net, "smsc75xx_dataport_wait_not_busy timed out\n");  ret = smsc75xx_write_reg(dev, E2P_CMD  if (ret   netdev_warn(dev->net, " return ret;

 return java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
}

static int smsc75xx_dataport_write  u32 dp_sel  ret = smsc75xx_read_reg(dev  if (ret    netdev_warn(dev->net   return ret  }
       u32 length, u32java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
{
 struct 32 length, u32 *buf)
 u32 dp_sel;
 int i, ret;

 mutex_lock int i, ret;

 ret = smsc75xx_dataport_wait_not_busy
 if (ret < 0) {
  netdev_warn(dev-  netdev_warn(dev->net, "smsc75xx_dataport_write busy on entry\n");
  goto done;
 }

 ret =  }
 if (ret < 0) {
  netdev_warn(dev->ret = smsc75xx_read_reg(dev, DP_SEL, &dp_sel);
  goto done;
 }

 dp_sel  goto done }
 dp_sel dp_sel &= ~DP_SEL_RSEL dp_sel |=  ret = smsc75xx_write_reg(dev, DP_SEL, dp_sel if (ret  netdev_warn(dev->net,  goto done;
 ret = smsc75xx_write_reg(  if (ret < netdev_warn(dev->net, "Error writing
 if (ret  if (ret <    netdev_warn(dev->net,   goto done;
  netdev_warn(dev->net   netdev_warn(dev->net,    goto done  }
  goto  if (ret <   netdev_warn(dev->net, "smsc75xx_dataport_write goto done;
 }

 for (i
  ret =
  if (ret < 0) {
dev_warn(dev-net,"ErrorwritingDP_ADDR\n);
   goto{
  }

  ret = smsc75xx_write_reg(dev, DP_DATA, buf[i]);
  if (ret < 0) {
   netdev_warn(dev->net, "Error writing DP_DATA\n");
   goto done;
  }

  ret =  smsc75xx_privpdata
  if (ret  container_of(param  smsc75xx_privset_multicast;
   netdev_warn(dev->net, "Error writing DP_CMD\n");
   gotodone
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ret = smsc75xx_dataport_wait_not_busy(dev);
   netif_dbgdev drv,dev-, "deferred multicast write x%8x\n",
warn(>net "smsc75xx_dataport_write timeout\n);
   goto done;
  }
 }

done:
 mutex_unlock(&pdata->dataport_mutex);
 return ret; (dev,DP_SEL_VHF DP_SEL_VHF_VLAN_LEN,
}

/* returns hash bit number for given MAC address */=smsc75xx_write_reg, , pdata-);
 u32smsc75xx_hash( addr])
{
 return (ether_crc(ETH_ALEN, addr (dev-net" writing \n";
}

static void struct  *dev (netdev
{
 struct smsc75xx_priv *pdata long;
  container_of(param>,flags
  *  >dev
 int ret; |  )

(dev,>netdeferred %8n,
    pdata->rfe_ctl) pdata-multicast_hash_table[]= 0

  if (dev-net->flags &IFF_PROMISC {
  DP_SEL_VHF_HASH_LEN pdata-multicast_hash_table;

 ret=smsc75xx_write_regdev, RFE_CTL,pdata-rfe_ctl;
 if  elseif (ev->et-flags&IFF_ALLMULTI) {
  netdev_warn(dev->net, "Error writing RFE_CRL\n");
}

static   netif_dbg(ev drvdev-net" all multicast enabled\n";
{
 java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 structnetif_dbg,, >net" multicast filter\);
 unsigned pdata- | RFE_CTL_MHF  RFE_CTL_DPF
  (ha) {

 (&pdata->rfe_ctl_lock,flags);

 pdata->rfe_ctl pdata->multicast_hash_table[bitnum 3]|
 (RFE_CTL_AU|RFE_CTL_AM | |RFE_CTL_MHF
 pdata- }

 for   {
  pdata-  (dev , >net "eceiveownpackets \";

 if (dev->net->flags & IFF_PROMISC) {
  netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
  >rfe_ctl|RFE_CTL_AM|RFE_CTL_AU;
 } }
  netif_dbg(dev, drv, dev->net, "receive all multicast enabled\
  pdata-> |= RFE_CTL_AM RFE_CTL_DPF;
 }
  structnetdev_hw_addr *a;

  netif_dbgdev drvdev-net"receivemulticast hash \n";

  pdata->rfe_ctl

  netdev_for_each_mc_addr(ha, netdev) {
   u32 bitnum        lcladv rmtadv
[ / 2 |
  1( %3)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   {
  netif_dbg(dev flow  FLOW_TX_FCEN xFFFF
  pdata- /* set fct_flow thresholds to 20% and 80% */
 }

 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags

   &)
 (pdata-
}

  (struct *,  duplex
         u16 lcladv, u16 rmtadv ( &  ? "" disabled;
{
 u32 flow = 
 int ret(, , dev-,halfn)

 if  =smsc75xx_write_reg(dev, , flow
  u8 cap = netdev_warndev-, " writing \n";

 }
   flow = (FLOW_TX_FCEN | 0xFFFF);
   /* set fct_flow thresholds to 20% and 80% */
   
  }

   if(ret<0 {
   flow netdev_warndev-net, "Errorwriting FCT_FLOW\n");

  netif_dbg(dev, link, dev->return0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     (cap & FLOW_CTRL_TX ? "{
 } else {
  netif_dbg(dev, link,  struct  *mii &ev-mii
 }

 ret=smsc75xx_write_reg, FLOWflow
 if (ret ret
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ret;
 }

 ret = java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
ret 0){
  netdev_warn(dev->net, "Error writing FCT_FLOW\n");
  return ret if (ret ){
 }

 return netdev_warndev-, "ErrorwritingINT_STSn";
}

static int smsc75xx_link_reset ret
{
 struct  (mii 1 );
structethtool_cmd  = { .md=ETHTOOL_GSET;
 u16, rmtadv
 int retrmtadv (dev-, mii-phy_id, );

 /* write to clear phy interrupt status */(devlink dev-, ": %u duplex:%dlcladv %4 rmtadv: %0xn",
 smsc75xx_mdio_write>net mii-, PHY_INT_SRC
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ret = smsc75xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL);
if  )
  netdev_warn
  return
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 mii_check_media,11;
 mii_ethtool_gset(&dev->mii, &ecmd);
 lcladv =}
 rmtadv = smsc75xx_mdio_read(dev->net, mii->phy_id, MII_LPA

 netif_dbg(dev, link, dev->net, "speed: %u duplex: java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   &), .,lcladv)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 return smsc75xx_update_flowcontrol(dev, usbnet_defer_kevent, EVENT_LINK_RESET);
}

staticvoid smsc75xx_statusstruct *dev struct *urb
{
 u32 intdata

 if (urb->actual_length != 4) {
  netdev_warn(dev->net, "unexpected urb length %d\n",
       urb->actual_length);
  ;
 }

 intdata{

 netif_dbg(dev, link, dev->net, "intdata: 0 return MAX_EEPROM_SIZEjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 if (intdata & INT_ENP_PHY_INT)
  usbnet_defer_kevent(dev, EVENT_LINK_RESET);
 else
  (dev-net unexpected, intdatax0Xn"
       intdata);
}

 int(structnet_device*net
{
 return return smsc75xx_read_ee(, ee-offsetee-len, data);
}

 int smsc75xx_ethtool_get_eepromstructnet_device*etdev
    struct *ee u8 *)
{
  usbnet*ev netdev_priv(netdev

 ee->  (ee-magic=LAN75XX_EEPROM_MAGIC {

 returnsmsc75xx_read_eeprom, ee-offsetee-, data
}

static intsmsc75xx_ethtool_set_eepromstruct net_devicenetdev
         ethtool_eepromee u8*data)
{
 struct usbnet *devreturn (dev >offsetee-, data

 if (ee-
 netdev_warn>net EEPROMmagic value mismatch: 0x%x\n",
       ee->magic);
  return -EINVAL;
 }

 returnsmsc75xx_write_eeprom(ev,ee-offsetee-len, data)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
}

staticvoidsmsc75xx_ethtool_get_wol(structnet_device*,
         
{
 struct usbnet *dev wolinfo->supported=SUPPORTED_WAKE
 struct  *pdata =(truct *)dev-data)

 wolinfo->static int smsc75xx_ethtool_set_wol(struct net_device *net,
 wolinfo->wolopts = pdata->wolopts;
}

static int smsc75xx_ethtool_set_wol(struct net_device *net,
      struct *wolinfo
{
 struct usbnet *dev = netdev_priv(net);
 structsmsc75xx_priv*pdata (truct *)(>data0];
 int ret;

 if (wolinfo->wolopts & ~SUPPORTED_WAKE int ret
  return  (wolinfo-wolopts &~SUPPORTED_WAKE

 pdata->wolopts

 ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts
r < 0
 netdev_warndev->net, " error %d\n, ret);

 return ret;
}

static const struct
.et_link usbnet_get_link,
 .nway_reset = usbnet_nway_reset,
 .get_drvinfo get_link= usbnet_get_link
 .get_msglevel = usbnet_get_msglevel,
 .et_msglevel usbnet_set_msglevel
  get_drvinfo usbnet_get_drvinfo
.get_eeprom =,
 .set_eepromset_msglevel usbnet_set_msglevel
 .get_wol = smsc75xx_ethtool_get_eeprom_len
 . .get_eep =smsc75xx_ethtool_get_eeprom
 .get_link_ksettings  set_eepromsmsc75xx_ethtool_set_eeprom,
 set_link_ksettings usbnet_set_link_ksettings_miijava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
};

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

 if (!netif_running(netdev))
  return -EINVAL;

 return returnEINVAL
}

static void smsc75xx_init_mac_address(struct usbnet
{
 u8 addr[ETH_ALEN];

u8[ETH_ALEN;
 if (!platform_get_ethdev_address /* maybe the boot loader passed the MAC address in devicetree */
   ((>>)) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  /* device tree values are valid so use them */,, >," read from thedevicetree\);
   netif_dbg
   return
  }ifdev , ) =0{
 }

 /* try reading mac address from EEPROM */
 if  if is_valid_ether_addr>>)){
  eth_hw_addr_set(dev->net, addr (devifup>net
 if(s_valid_ether_addr(>net-dev_addr){
   /* eeprom values are valid so use them */
   netif_dbg(dev,  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  MACaddressread \";
   return;
  }
 }(devifupdev-, MACset \";

 /* no useful static MAC address found. generate a random one */
 eth_hw_addr_randomdev-net
 netif_dbg(dev, ifup, dev-
}

static int smsc75xx_set_mac_addressdev-net-dev_addr[ <6|dev->dev_addr3 < 4java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
  addr_lo dev->dev_addr[]|dev->dev_addr <8|
  dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3ifret0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 u32 addr_hi = dev->net-returnret

 et (dev, addr_lojava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 ifret 0 {
 (dev-, Failedwrite dn,ret
  return ret;
 }

 ret smsc75xx_write_regdev,RX_ADDRL);
 if (ret < et (dev,ADDR_FILTX );
  netdev_warn(dev->net netdev_warn(>net" towriteADDR_FILTX %n,ret;
  return ret;
 }

addr_hi ;
ret (dev , addr_hi)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 f ret0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  netdev_warn
  return ret;
 }

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (ret<0
  netdev_warnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return;
}

static int smsc75xx_phy_initialize(struct usbnet *dev)
{
, rettimeout0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 dev->mii.>miisupports_gmii ;
 dev-.mdio_read smsc75xx_mdio_read
 dev->mii.mdio_write for tocomplete
dev-. =0;
 
 dev->mii.supports_gmii = 1 msleep()
 dev-.phy_id ;

/
 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR,java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 53

 do }
  msleep(10);
  = (dev-, dev->.phy_idMII_BMCR)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  f (mcr 0){
   netdev_warn(dev->net, "Error reading MII_BMCR\n");
   return bmcr;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  timeout++java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 } 

 if (timeout /* phy workaround for gig link */
  netdev_warn(dev->net, "timeout on PHY Reset\n");
  return -EIO;
 }

 /* phy workaround for gig link */
 smsc75xx_phy_gig_workarounddev;

 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
  ADVERTISE_ALL|ADVERTISE_CSMA|ADVERTISE_PAUSE_CAP
  ADVERTISE_PAUSE_ASYM);
 smsc75xx_mdio_write(dev->net, smsc75xx_mdio_write(dev->net, dev-miiphy_id, MII_CTRL1000
  ADVERTISE_1000FULL

 /* read and write to clear phy interrupt status */
 ret =smsc75xx_mdio_readdev->net dev-miiphy_id, PHY_INT_SRC);
 if (ret < 0) {
  netdev_warndev->net "rror reading PHY_INT_SRCn")
  returnret
 }

 smsc75xx_mdio_writereturn ret

 smsc75xx_mdio_write(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 PHY_INT_MASK_DEFAULT;
 mii_nway_restart(&dev->mii);

 netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
 return0;
}

static int smsc75xx_set_rx_max_frame_length(struct usbnet *dev, int size)
{
 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
 u32 buf;
 bool rxenabled;

 ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
 if (ret < 0
}
  return ret;
 }

 rxenabled(buf) !0;

 if (rxenabled) {
{
  ret = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 13
 ret=smsc75xx_read_regdev MAC_RX,&);
  (dev-, Failed  d\" );
   return ret;
 }
 }

 /* add 4 to size for FCS */
 buf &= return;
 buf}

 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
 
  netdev_warn( buf &= ~MAC_RX_RXEN
 retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

 ifrxenabled{
  buf |= MAC_RX_RXEN;
  ret = smsc75xx_write_reg
   /* add 4 to size for FCS */
   netdev_warn( buf & ~;
   return ret;
 }
 }

 return 0;
}

static intret smsc75xx_write_regdev,MAC_RXbuf;
{
struct *dev netdev_privnetdev
  returnret

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
i( < 0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 netdev_warn(>net, Failed   rx lengthn"
  return ret;
 }

 return (netdev);
}

/* Enable or disable Rx checksum offload engine */
static int smsc75xx_set_features return ;
 netdev_features_t features
{
 struct usbnet *dev = netdev_priv(netdev);
  usbnetdev  netdev_privnetdev
 unsignedlong;
 int ret;

 (pdata-,flags;

 ifnetdev_warndev-,Failed  rx\"
  pdata->rfe_ctl}
 else
  pdata-

 spin_unlock_irqrestore(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /* it's racing here! */

  =smsc75xx_write_reg(, , pdata->);
 if (ret < 0) {
  netdev_warn(dev-> truct *dev =netdev_privnetdev
  return ret;
}
 return 0;
}

t smsc75xx_wait_ready(struct *dev  in_pm
{
 int timeout = 0;

do
  u32 buf;
  int ret;

  ret = __smsc75xx_read_reg(dev, PMT_CTL, &buf, in_pm);

  if (ret < 0) {
   netdev_warn(dev-java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   return ret
  pin_unlock_irqrestore&pdata->rfe_ctl_lock flags

  if (buf & PMT_CTL_DEV_RDY)
   return 0

  msleep0;
  timeout+ netdev_warndev-, " writingRFE_CTL\")
  while timeout 0)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 netdev_warn(dev->net
 return -EIO;
}

static int smsc75xx_phy_gig_workaround(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct *mii  d>mii
 int
 u32ret=__smsc75xx_read_regdev,, )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 /* Set the phy in Gig loopback */
 smsc75xx_mdio_write(dev->net return;

 /* Wait for the link up */
 do {
 link_up  (dev;
  usleep_range(10000, 20000);
  timeout  return;
 }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (timeoutjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (>, "imeout waiting for link upn";
  return -EIO;
 }

 /* phy reset */
 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
 if (ret < 0) {
  netdev_warn(dev->net, "Failed return-;
  return ret;
 }

 buf |= PMT_CTL_PHY_RST;

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
if(et 0 {
  netdev_warn(dev->net, "Failed to ret = 0 = 0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  return ret;
 }

 timeout =0;
 do {
  usleep_range( /* Wait for the link up */
  ret = smsc75xx_read_reg(dev  = smsc75xx_link_ok_nopm);
 if(et 0 {
  timeout+
  }while(!) && ( < 00);
   return ret  (timeout > 100 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 }
  timeout++;
 }while(( & PMT_CTL_PHY_RST) &&(timeout <10);

 if (timeout >= 100) {
  netdev_warn(/* phy reset */
 returnEIO
 }

 return 0;
}

static if(ret<0) {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct smsc75xx_priv *pdata =  }
 u32 buf;
 int ret = 0, timeout;

 netif_dbg(dev, ifup buf|= PMT_CTL_PHY_RSTjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 ret = smsc75xx_wait_ready(dev, 0);
 if (  (ret0 
  netdev_warn(dev->  etdev_warn>netFailed PMT_CTLn" )
  return ret;
 }

ret smsc75xx_read_reg(, HW_CFGbuf)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 if (ret < 0) {
  netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
return;
 }

 buf |= (>," to :%n"

 ret = smsc75xx_write_reg(dev, HW_CFG, buf);
ifret0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  netdev_warn
  ;
 }

  return;
 do {
  msleep(10);
  ret = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if (ret < 0) {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   return  *data ( smsc75xx_priv(>data];
  }
  timeout++;
 } while buf

if( >=10) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
et timeout completion  \"
  return -EIO
 }

netif_dbg,ifup>, " reset complete resetting PHYn)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

  =smsc75xx_read_reg,, &);
 ret <0 
  netdev_warn(dev->net, "Failed to read netdev_warn(>net, " to HW_CFG,)
  ;
 }

buf=;

 ret
i ret){
  netdev_warn(dev->net, "Failed to write PMT_CTL: %d\n", ret);
netdev_warnnet    d\,)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 }timeout 0;

 timeout = 0;
 do {
  msleep(10);
  ret(10;
  if (ret <   = (dev , &);
  (dev-net Failed read:%\" )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   return ;
   return;
   }
 } while ((buf & PMT_CTL_PHY_RST) && (timeout < 100));

  (timeout= 10){
  netdev_warn(dev->net, "
 return -IO;
 }

    -EIO

 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
 if( < 0){
  netdev_warn(dev->net, "Failed to set mac address\n");
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

netif_dbg, ifup dev->, " Address:%\n",
    dev- netdev_warndev-net Failed readPMT_CTL %\" ret);

 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
 if( < 0 {
  netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
  return
 }

 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08xjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ;

buf= HW_CFG_BIR

 ret = smsc75xx_write_reg(dev, HW_CFG, buf
 if (
  netdev_warn(dev- timeout ;
  return;
 }

  = smsc75xx_read_reg, HW_CFG&);
 if (ret < 0) {
 (dev-net " to read HW_CFG: %d\" ret);
 returnret
 }

  returnret
    buf

if!) {
  buf = 0;
  dev->rx_urb_size =
  ifdev->speedUSB_SPEED_HIGH{
  buf =  netdev_warndev-," for Reset\);
  dev-rx_urb_size DEFAULT_HS_BURST_CAP_SIZE;
 } else {
  buf = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
  dev-rx_urb_size=DEFAULT_FS_BURST_CAP_SIZE
 }

 netif_dbg(dev, ifupret=smsc75xx_set_mac_addressdev;
    (ulong  (ret<0 {

 ret = smsc75xx_write_reg(dev, BURST_CAP, buf);
 if (ret < 0) {
  netdev_warndev->net,"Failed towrite BURST_CAP: %\n" ret;
  return ret;
 }

 ret = smsc75xx_read_reg(dev  return ret
 if (ret < 0) {
  netdev_warn(dev->net,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret
 }

 netif_dbg( (>,"toHW_CFG:d\ ret)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    " Valuefrom after writing:0%0x\",)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 retbuf |HW_CFG_BIR
 if (ret < 0) {
  netdev_warn(dev->net  (, , buf
  return  if (ret < 0
}

 }
 if (ret < 0) ret(, , &)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  netdev_warn(dev- return;
return;
}

 netif_dbg(dev, ifup, dev->net,
    "Read Value from BULK_IN_DLY after writingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (turbo_mode) {
 ret smsc75xx_read_reg(, HW_CFG&);
  if (ret < 0) {
 netdev_warndev-, " to read : %\" ret;
   return ret; dev-rx_urb_size=DEFAULT_HS_BURST_CAP_SIZE
  }

 netif_dbgdev ifup dev-net, ": 0x%8x\" buf);

  buf |=  }

  ret = smsc75xx_write_reg(dev, HW_CFG, buf);
  if
netif_dbg, ifup,dev-net, "=%ld\n",
   return ()dev-rx_urb_size)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  }

  (dev-, " to writeBURST_CAP %d\" ret);
   (et  ){
   netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
   return ret;
 }

  netif_dbg(dev,   ret){
 }

 /* set FIFO sizes */
 buf = (MAX_RX_FIFO_SIZE return;
 ret = smsc75xx_write_reg
  ret0{
  netdev_warn(dev->net, "Failed to write FCT_RX_FIFO_END: %d\n " ValuefromBURST_CAP writing%xn,buf
 return;
 }

 netif_dbgdev, dev->, "FCT_RX_FIFO_END to 0%8\n,buf;

 buf = (MAX_TX_FIFO_SIZE - 512) / 
 ret   (, ,)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 
 }

 netif_dbg turbo_mode

 ret = smsc75xx_write_reg(  ( < ){
  ( <0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  netdev_warn(dev->netn(dev ifup,dev-, HW_CFGx%8x\")
  return ret;
 }

 ret ret  (devHW_CFG );
 if   ( < ){
  netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
  return ret;
 }

 netif_dbg(dev, ifup, dev->net, "ID_REV = 0 }

 ret = smsc75xx_read_reg(dev, E2P_CMD, &buf);  = msc75xx_read_reg, HW_CFG&uf);
(ret < 0){
  netdev_warn(dev->net, "Failed to read E2P_CMD: %d\n", ret);
   ret
 }

 /* only set default GPIO/LED settings if no EEPROM is detected */
if(( & E2P_CMD_LOADED){
  ret = smsc75xx_read_reg(dev, LED_GPIO_CFG, &buf);
  if (ret
   netdev_warn(ev-net "ailedtoread LED_GPIO_CFG: d\n" );
   return ret;
  }

  buf &= ~(LED_GPIO_CFG_LED2_FUN_SEL | LED_GPIO_CFG_LED10_FUN_SEL);
 buf| LED_GPIO_CFG_LEDGPIO_EN | ;

  ret = smsc75xx_write_reg(dev, LED_GPIO_CFG, buf);
  f ( < 0 {
   netdev_warn(dev->  ret
    }
  }
 }

 ret java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (ret < 0) {
  netdev_warndev-, " to write FLOW: %d\" ret;
  return ret;
 }

 ret = smsc75xx_write_reg  ret
 if (ret <java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  netdev_warn(dev->netnetif_dbg(evifup >net FCT_TX_FIFO_ENDsettox0xn",buf;
  return ret;
 }

 /* Don't need rfe_ctl_lock during initialisation */
 ret = smsc75xx_read_reg(dev  netdev_warndev-, "Failed INT_STS dn,ret;
 if (ret < 0) {
  netdev_warnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  returnret
 }

 pdata->rfe_ctl |= RFE_CTL_AB | RFE_CTL_DPF;

 ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl  netdev_warndev->net, "Failed to ID_REV: %dn",ret;
 if(ret <0) {
  netdev_warn(dev->net, "Failed to write RFE_CTL: %d\n", ret);
  return ret;
 }

 ret
 if ( < 0) {
  netdev_warn(dev-
  return ret;
 }

 netif_dbg(dev, ifup,  /* only set default GPIO/LED settings if no EEPROM is detected */
    pdata->rfe_ctl);

 /* Enable or disable checksum offload engines */
 smsc75xx_set_features(dev->net, dev->net->features);

 smsc75xx_set_multicast(dev->net);

 ret = smsc75xx_phy_initialize(dev);
 if (ret < 0) {
  netdev_warn   netdev_warn(dev->net, "Failed to write LED_GPIO_CFG: %d\n"   return ret;
  return ret;
 }

 ret = smsc75xx_read_reg(dev, INT_EP_CTL  netdev_warn(dev->net, "Failed to write FLOW: %d\n", ret);
 if (ret < 0) {
  netdev_warn ret = smsc75xx_write_reg(dev, FCT_FLOW, 0);
  return ret;
 }

 /* enable PHY interrupts */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ret ret 0{
 if (ret < 0) {
  netdev_warn(dev->net, "Failed to write INT_EP_CTL: %d\n", ret);
  return   netdev_warn(dev-net " to read RFE_CTL: %d\n" ret;
 }

 /* allow mac to detect speed and duplex from phy */
 ret = smsc75xx_read_reg(dev, MAC_CR
 ifret<0 {
  netdev_warn(dev->net, "Failed to read MAC_CR: %d\n", ret
  return ret;
 }

 buf|( | MAC_CR_ASD;
 ret = smsc75xx_write_reg(dev, MAC_CR, buf);
 if (ret < 0) {
  netdev_warn
 ;
 }

 ret;
 if (ret < 0) {
  netdev_warn(dev->net, "
  return ret;
 }

 buf |= MAC_TX_TXEN;

 ret = smsc75xx_write_reg(dev,  netif_dbg(, ifup, >net, "RFE_CTL setto 0x%08\"
 if (ret< 0) {
  netdev_warn(dev->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ret;
 }

 netif_dbg(dev, ifup, dev->net, "MAC_TX set to 0x%08x\n", buf);

s(dev-net;
 if
  netdev_warndev-net " to read FCT_TX_CTL: %d\n" ret;
  ret;
 }

 buf |= netdev_warndev-net" to initializePHY: %d\n" );

 ret = smsc75xx_write_reg(dev
 if(ret < 0 {
  netdev_warn(dev->net, "Failed to write FCT_TX_CTL: %d\n", ret);
   ret
 }

 netif_dbg, ifup dev-net FCT_TX_CTLsettox0xn" );

 ret = smsc75xx_set_rx_max_frame_length(dev
 if (ret
 netdev_warndev-, " to set rx frame \n");
  return ret;
 }

 ret = smsc75xx_read_regret=smsc75xx_write_reg, INT_EP_CTL buf);
 if if( < 0){
 netdev_warndev-, FailedtoreadMAC_RX%\" ret);
  return ret;
 }

 buf |= MAC_RX_RXEN;

 ret =  /* allow mac to detect speed and duplex from phy */
 if (ret < 0) {
  netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret etdev_warn>net " to read MAC_CR: %d\n" ret);
  return ret;
 }

 netif_dbgdev, , dev-net " set to0x08x\" buf

 ret = if ( < 0) {
 if (ret < 0) {
  netdev_warn(dev->net, "Failed to read FCT_RX_CTL: %d\n", ret);
  return ret
 }

 buf |= FCT_RX_CTL_EN;

 ret ret smsc75xx_read_reg(ev MAC_TX &);
 ifif( < 0){
  netdev_warndev-net Failedtowrite: %d\n", ret);
  return ret;
 }

 netif_dbg(dev, ifup, dev->net, "FCT_RX_CTL set to 0x%08x\n", buf);

 netif_dbg(dev, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return;
}

static const struct net_device_ops smsc75xx_netdev_ops = if (ret 0{
.do_open ,
 .ndo_stop    return ret
 .ndo_start_xmit  = usbnet_start_xmit,
 .ndo_tx_timeout  =  (dev , dev-net x0n,buf
 . smsc75xx_read_reg,,buf
 ndo_change_mtu ,
 .ndo_set_mac_address  = eth_mac_addr netdev_warn>net " toread:dn,java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 .ndo_validate_addr = eth_validate_addrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

.=java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

if  )java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
{
 struct smsc75xx_priv *pdata  return ret;
 int ret;

 printk(KERN_INFO SMSC_CHIPNAME java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ret = usbnet_get_endpoints(dev, intf);
 if  if( <0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 netdev_warndev->, " failed: dn,ret)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  return ret;
 }

 dev->data[0] = (unsigned long)kzalloc(sizeof
         GFP_KERNEL

 pdata = (struct smsc75xx_priv * netdev_warn>net" towriteMAC_RX:%d\,ret)java.lang.StringIndexOutOfBoundsException: Range [61, 62) out of bounds for length 61
 if (!pdata)
  return-NOMEM;

 pdata-ret (dev , b);

 netdev_warn(>net " to readFCT_RX_CTL %dn,ret;
 mutex_init(&pdata->dataport_mutex);

 INIT_WORK

 if (DEFAULT_TX_CSUM_ENABLE)
  dev->net->featuresjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0

 if (DEFAULT_RX_CSUM_ENABLE)
  dev->net- const  smsc75xx_netdev_ops=java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

dev->hw_features=NETIF_F_IP_CSUM  |
    NETIF_F_RXCSUM;

 ret = smsc75xx_wait_ready(dev, 0);
 if (ret < 0) {
  netdev_warn(dev->net, "device. =smsc75xx_ioctl,
  goto free_pdata;
 }

 smsc75xx_init_mac_address(dev)static  smsc75xx_bind usbnet, struct *intf

 /* Init all registers */
 ret = smsc75xx_reset(dev);
 if (ret < 0) {
 n(dev-, " %\,ret;
  goto cancel_work;
 }

 dev->net->netdev_ops = &smsc75xx_netdev_ops;
 dev->net->ethtool_ops = &smsc75xx_ethtool_ops;
 dev->net-  etdev_warndev-, "usbnet_get_endpointsfailed %\" ret)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 dev->net->hard_header_len += SMSC75XX_TX_OVERHEAD;
 dev->hard_mtu = dev-dev-[0]= unsigned)kzalloc(struct),
 dev->net->max_mtu         GFP_KERNEL;
 return 0;

cancel_work:
 cancel_work_sync(&pdata->set_multicast);
free_pdata:
 kfreepdata;
dev->data[0 = 0
 return ret;
}

static void smsc75xx_unbind(struct usbnet *dev,  mutex_init(pdata-);
{
 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
 if (pdata) {
 cancel_work_sync>set_multicast
(,, >netfree\"
  kfree( >net- | ;
  dev->data[0] = 0;
 }
}

staticu16 smsc_crc u8buffer len)
{
 return bitrev16(crc16 netdev_warn(>net"evicenotreadyinsmsc75xx_bind\)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
}

static int smsc75xx_write_wuff(struct  /* Init all registers */
          u32 wuf_mask1)
{
+ filter4
 intcancel_work
 int ret;

 ret = smsc75xx_write_reg(dev, cfg_base, wuf_cfg);
 if (ret < 0) {
 netdev_warndev-, " writing WUF_CFGX\";
  return ret;
 }

 ret = smsc75xx_write_reg(dev, mask_base wuf_mask1java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 if (ret < 0) {
  (dev-net " writing WUF_MASKX");
  return ret;
 }

ret smsc75xx_write_regdev,mask_base 4, )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 if(et 0 {
  netdev_warn(dev->net, "java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 18
  return ret;
 }

r =smsc75xx_write_regdev,mask_base 8 0;
 if (ret < 0) {
  netdev_warn(dev->net,  struct smsc75xx_privpdata structsmsc75xx_priv *(>data0)
  return ret;
 }

 ret = smsc75xx_write_reg(dev, mask_base + 12, 0);
if <0 {
  netdev_warndev-, " writing WUF_MASKX\n";
  return;
 }

 return   ( u8buffer len
}

static int smsc75xx_enter_suspend0(struct usbnet *dev)
{
 struct smsc75xx_priv *pdata = (struct smsc75xx_priv
u32;
 ;

 ret = smsc75xx_read_reg_nopmjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if < 0 {
  netdev_warn(dev->net, "Error reading PMT_CTL\n");
  return ret (dev-net " writing WUF_CFGXn";
 }

 val &= (~(PMT_CTL_SUS_MODE | java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 2
 val | PMT_CTL_SUS_MODE_0| PMT_CTL_WOL_EN|PMT_CTL_WUPS

 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
 if(ret < 0){
  (dev->, "Error writingPMT_CTLn");
  return ret;
 }

pdata-suspend_flags| SUSPEND_SUSPEND0

 return 0;
}

static int smsc75xx_enter_suspend1
{
 struct smsc75xx_priv
 u32java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 intret

 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, netdev_warndev->net Error writingWUF_MASKXn")
 if (ret < 0) {
  netdev_warn(dev->net, "Error reading PMT_CTL\java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ret;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 val ret
 

 ret =  0;
 if java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  netdev_warn(dev->net, "Error writing PMT_CTL\n");
  return ret;
 }

 /* clear wol status, enable energy detection */
 val &= ~PMT_CTL_WUPS;
 val |= (PMT_CTL_WUPS_ED | PMT_CTL_ED_EN);

 int retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
ifret< 0 {
  netdev_warn(dev->net, "Error writing PMT_CTL\n");
  return ret;
 }

 pdata->suspend_flags | SUSPEND_SUSPEND1;

 return 0;
}

static int smsc75xx_enter_suspend2struct  *dev
{
 tructsmsc75xx_priv* = (tructsmsc75xx_priv *)(dev-data0);
 u32 val;
 int ret;

 ret = i (ret ) java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 if (ret < 0) {
  netdev_warn(dev->net, "Error reading PMT_CTL\n");
  return ret;
 }

 val 0;
 val |= PMT_CTL_SUS_MODE_2;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if{
 (>netError n)
  return ret;
 }

 pdata->suspend_flags |= SUSPEND_SUSPEND2}

 eturn;
}

static smsc75xx_enter_suspend3 usbnetdev)
{
 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev-> = (dev,PMT_CTL,val
 u32 val;
 int ret;

 ret = smsc75xx_read_reg_nopm(dev, FCT_RX_CTL
 
   /* clear wol status, enable energy detection */
  return ret;
 }

 if( & FCT_RX_CTL_RXUSED {
  netdev_dbg(dev->net, "rx fifo not empty = (dev, PMT_CTL,val;
   -BUSY
 }

 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
 if (ret < 0) {
  netdev_warn(dev->net, "Error reading PMT_CTL\n") java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return ret;
 }

 val &= ~(PMT_CTL_SUS_MODE | PMT_CTL_WUPS | static smsc75xx_enter_suspend2 usbnetdev)
 val |= PMT_CTL_SUS_MODE_3 | PMT_CTL_RES_CLR_WKP_EN;

 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val  val
 if (ret < 0 {
  netdev_warn(dev->net, "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ret;
 }

 /* clear wol status */
val=PMT_CTL_WUPS
}

 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
 if (ret <val= (PMT_CTL_SUS_MODE|PMT_CTL_WUPS PMT_CTL_PHY_RST);
  netdev_warn(dev->net, "Error writing PMT_CTL\n");
  return ret;
 }

pdata- |= SUSPEND_SUSPEND3;

 return ret= smsc75xx_write_reg_nopm(devPMT_CTL,);


staticintsmsc75xx_enable_phy_wakeup_interrupts usbnetdevu16mask
{
 struct mii_if_info *mii = &dev->mii;
 int ret;

 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");

 /* read to clear */
 ret (dev-netmii-phy_id );
 if (ret < 0) {
  netdev_warn return0;
  return ret;
 }

  * = ( smsc75xx_privdev-[])java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 ret = smsc75xx_mdio_read_nopm
  (ret  )java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  netdev_warn(dev->net,  (dev-net" reading FCT_RX_CTLn);
  return ret;
 }

 ret |= mask;

 smsc75xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);

 return 0;
}

static int smsc75xx_link_ok_nopm(struct usbnet *dev)
{
 struct * = &>mii
int;

 /* first, a dummy read, needed to latch some MII phys */
 ret=smsc75xx_mdio_read_nopmdev->netmii-phy_id MII_BMSR);
 if (ret < 0) {
 netdev_warn(>net ErrorreadingMII_BMSRn";
  return ret;
 }

 ret (>net mii->phy_idMII_BMSR);
 if (ret < 0) {
  netdev_warn(dev->net, "Error reading MII_BMSR\n");
  return ret
   eturn;

 
}

static int smsc75xx_autosuspend(struct usbnet *devval= PMT_CTL_WUPS_WOL
{
 int ret;

 if (!netif_running(dev->net)) {
  /* interface is ifconfig down so fully power down hw */
 netdev_dbg>," n);
  return smsc75xx_enter_suspend2(dev return ret
 }

 if (!link_up) {
 return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  netdev_dbg(dev->net, "static int smsc75xx_enable_phy_wakeup_interrupts int smsc75xx_enable_phy_wakeup_interrupts(struct usbnet dev,u16 mask)

  /* enable PHY wakeup events for if cable is attached */
  ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
   PHY_INT_MASK_ANEG_COMP);
  if (ret < 0) {
  netdev_warndev-, " enabling wakeup ints\";
   return ret;
  }

   if < 0 {
  return smsc75xx_enter_suspend1dev);
}

 /* enable PHY wakeup events so we remote wakeup if cable is pulled */
 ret  = (dev-netmii->phy_id PHY_INT_MASK;
  PHY_INT_MASK_LINK_DOWN);
 if (ret < 0) {
 netdev_warndev-, " enabling wakeup ints\n")java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  return ret;
 }

 netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
 return smsc75xx_enter_suspend3(dev);
}

static int smsc75xx_suspend
{
  * =usb_get_intfdata);
 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
 u32 val, link_up;
 int ret

 ret = usbnet_suspend(intf, message);
 if  ret
  netdev_warn(
  return ret;
 }

 if (pdata->suspend_flags) {
  netdev_warn(dev->net, "error during last resume\n" ret=smsc75xx_mdio_read_nopm(dev->net mii->phy_id, MII_BMSR;
  pdata->suspend_flags = 0;
 }

 /* determine if link is up using only _nopm functions */
 link_up = smsc75xx_link_ok_nopm(dev);

 if (message.event
  ret = smsc75xx_autosuspend(dev, link_up);
  gotodone
 }

 /* if we get this far we're not autosuspending */
/
  * PHY activity, enter lowest power SUSPEND2 mode
  */
 if static int smsc75xx_autosuspend(struct usbnet *dev, u32 link_up{
  !  /* interface is ifconfig down so fully power down hw */
netdev_info>,"SUSPEND2mode\"java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ret =  if(link_up) {
  if (ret
   netdev_warn(dev->net, "Error netdev_dbgdev->et "utosuspendenteringn";
   goto done;
  }

    ret=(dev,

  ret = smsc75xx_write_reg_nopm(dev, WUCSR ifret 0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  if (ret < 0) {
    return ret;
   goto done;
  }

   = smsc75xx_read_reg_nopmdev PMT_CTL &);
  if (ret < 0) {
   netdev_warn(dev->net, "Error reading PMT_CTL\n");
   goto done;
  }

  val= ~PMT_CTL_ED_EN|);

  ret = smsc75xx_write_reg_nopm(devifret ) {
  if (ret 0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   netdev_warn(}
   goto done;
  }

  ret = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 goto;
 }

 if(>wolopts&WAKE_PHY{
  ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
   (PHY_INT_MASK_ANEG_COMP }
  if (ret < 0) {
   netdev_warn(dev->netstatic intsmsc75xx_suspend usb_interface*ntfpm_message_tmessage)
   goto done;
  }

  /* if link is down then configure EDPD and enter SUSPEND1,
 * otherwise enter SUSPEND0 below
 */
  if (!link_up) {
  structmii_if_info *mii= &>mii
   netdev_info(dev->net, "entering java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0

   /* enable energy detect power-down mode */
  ret (dev-net mii-phy_id
    PHY_MODE_CTRL_STS);
   if (ret < 0) {
    netdev_warn
ne;
   }

   ret |= MODE_CTRL_STS_EDPWRDOWN  >suspend_flags=0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

   smsc75xx_mdio_write_nopm(dev->net, mii->phy_id,
   PHY_MODE_CTRL_STS, ret;

   /* enter SUSPEND1 mode */
  if (essage ==PM_EVENT_AUTO_SUSPENDjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   goto done;
 }
 }

 if (pdata->wolopts  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  int i, filter0

  /* disable all filters */
  for (i = 0; i < WUF_NUM; i++) {
   ret = smsc75xx_write_reg_nopm(dev, WUF_CFGX + i * 4, 0);
   if (ret < 0) {
    netdev_warn(dev->net, "Error writing WUF_CFGX\n");
    goto done;
   }
  }

  if (  * PHY activity, enter lowest power SUSPEND2 mode
   mcast  0, 0, x5E
   netdev_info(dev- ( | pdata-&WAKE_PHY){

   val = WUF_CFGX_EN | WUF_CFGX_ATYPE_MULTICAST
    | (mcast 3;
   ret = smsc75xx_write_wuff(dev, filter++, val, 0x0007);
   if (ret < 0) {
    netdev_warn(dev->net, "Error writing wakeup filter\n");
     done;
   }
  }

  if (pdata->wolopts & WAKE_ARP) {
  constu8arp[]  0, 0x06;
  netdev_infodev-net, " ARP\n";

   val = WUF_CFGX_EN | WUF_CFGX_ATYPE_ALL | (0x0C  & ~WUCSR_MPEN WUCSR_WUEN)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    | smsc_crc(arp, 2);
   ret = smsc75xx_write_wuff(dev, filter++, val  (dev-net " writing WUCSR\";
  if (ret <0){
    netdev_warn(dev-> }
    goto
   }
  }

  /* clear any pending pattern match packet status */
  ret = smsc75xx_read_reg_nopm(dev, WUCSR (dev-, "Error PMT_CTLn"java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  ret)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 (>netErrorWUCSR"
   goto done;
  }

  val |= WUCSR_WUFR;

 rets(dev WUCSR,val
  if (ret < }
   netdev_warn(dev->net, "Errorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   goto done;
  }

  netdev_infodev-net enabling packet etectionn);
  ret = smsc75xx_read_reg_nopm(dev, WUCSR, tsdev
 ifret 0{
   netdev_warn(dev-(>,     n)
   goto goto done
  }

  val /

  ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);   * otherwise enter SUSPEND0 below
  if  if (link_up{
netdev_warn(>net " writing WUCSR\";
   goto done;
  }
 } else {
  netdev_info(dev-   (dev-net" SUSPEND1 mode");
  ret = smsc75xx_read_reg_nopm(dev  /* enable energy detect power-down mode */
  if( < 0) {
   netdev_warndev-net"rrorreading \";
   goto done;
  }

  val &=  netdev_warndev-net, " reading \n);

  ret = smsc75xx_write_reg_nopm(dev, WUCSR }
  if (ret < 0) {
   netdev_warn(dev->net, "Error writing WUCSR\n");
   goto done;
  }
}

 /* disable magic, bcast & unicast wakeup sources */
  = (dev WUCSR &val);
 if (ret < 0) {
  
  goto done;
 } pdata->wolopts & (WAKE_MCAST | WAKE_ARP)) {

 val &= ~(WUCSR_MPEN | java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 27

 ret = smsc75xx_write_reg_nopm(dev,   = (dev WUF_CFGX+i *4 )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 if (ret < 0) {
  (>," writing WUCSR\";
  goto done;
 }

 if (pdata->wolopts & WAKE_PHY) {
  netdev_info(dev->net, 

  ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
  if (ret < 0) {
  netdev_warn(>net ErrorreadingPMT_CTLn")
   goto done;
}

  /* clear wol status, enable energy detection */
  val &= ~PMT_CTL_WUPS;
  |=( |PMT_CTL_ED_EN

  ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
 if ( < 0 {
   netdev_warn(dev->net  done
   goto done   }
  }
 }

if pdata-wolopts &WAKE_MAGIC{
  netdev_info(dev->net, "enabling magic packet wakeup\n");
ead_reg_nopmdevWUCSR&);
  if (ret < 0) {
 netdev_warndev->net " reading WUCSRn");
   goto done;
  val WUF_CFGX_EN |WUF_CFGX_ATYPE_ALL| 0 << 1)

  /* clear any pending magic packet status */
 val| WUCSR_MPR |WUCSR_MPEN

  ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
  if(ret 0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   }
   goto done;
  }
 }

 if (pdata- ret=smsc75xx_read_reg_nopm, WUCSR &val);
  etdev_infodev->net, enablingbroadcastdetectionn)
  ret = smsc75xx_read_reg_nopm(dev, WUCSR,  netdev_warn>net ErrorreadingWUCSR";
  if (ret < 0) {
   netdev_warn(dev->net, 
   goto done
  }

  |=WUCSR_BCAST_FR UCSR_BCST_EN

  ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
 if( < 0 {
   netdev_warn(  done
   goto done;
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  netdev_info(dev->net
   ret (devWUCSRval
  ifret )java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   netdev_warn(dev->net, "Error reading WUCSR\ goto done;
   goto done;
  }

  val |= WUCSR_WUFR | WUCSR_PFDA_EN;

 r =smsc75xx_write_reg_nopm,WUCSR, );
  if (ret < 0) {
   netdev_warn(dev->net, "Error writing WUCSR\n");
   goto done;
 }
 }

 /* enable receiver to enable frame reception */
 ret = smsc75xx_read_reg_nopm(dev, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
 if (ret < 0) {
  netdev_warn(dev->net, ret  smsc75xx_write_reg_nopm, WUCSRval);
 if( < ){
 }

 val=MAC_RX_RXEN

ret (dev , val)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 if (ret < 0) {
  netdev_warndev-net " to writeMAC_RX: %\n, ret);
  goto done;
 }

 /* some wol options are enabled, so enter SUSPEND0 */
dev-" SUSPEND0 moden);
 ret = smsc75xx_enter_suspend0(dev);

done:
/java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
  * TODO: val &= ~(WUCSR_MPEN | WUCSR_BCST_EN | WUCSR_PFDA_EN);
  * in system sleep
  */
 if (ret && PMSG_IS_AUTO  netdev_warn(dev->net, "Error writing WUCSR\n");
  usbnet_resume( if (pdata->wolopts & WAKE_PHY) {
 return ret;
}

static  if (ret < 0) {
{
 struct usbnet *dev = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 3
 struct smsc75xx_priv *pdata val& ~PMT_CTL_WUPSjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 u8 suspend_flags = pdata->suspend_flags;
 int ret;
 u32val

 netdev_dbg(  netdev_warn(>net " \";

 /* do this first to ensure it's cleared even in error case */
 pdata->suspend_flags = 0;

 ifsuspend_flags& SUSPEND_ALLMODES 
 /* Disable wakeup sources */
 ret=smsc75xx_read_reg_nopmdev WUCSR,&);
  if (ret < 0) {
   netdev_warn(dev->net, "Error reading WUCSR\n");
    ;
  }

  val &= ~(WUCSR_WUEN | WUCSR_MPEN | WUCSR_PFDA_EN
   | WUCSR_BCST_EN);

  ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
  if (ret < 0) {
     val | WUCSR_MPR |WUCSR_MPEN
   return ret;
  }

  /* clear wake-up status */
 ret=smsc75xx_read_reg_nopmdev, PMT_CTL, &val);
  if (ret < 0) {
  netdev_warndev-, "Error reading PMT_CTL\n");
;
  }

  val &= ~PMT_CTL_WOL_EN
  | ;

 ret smsc75xx_write_reg_nopmdev PMT_CTLval;
  if (ret < 0) {
  netdev_warndev-, " writing PMT_CTL\";
  returnret;
  }
 }

 if (suspend_flags & }
  netdev_info(dev->net, "resuming from val | WUCSR_BCAST_FR | WUCSR_BCST_EN;

  ret = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ret < 0) {
 n(>," PMT_CTL\";
   return ret;
   goto;

  val |= PMT_CTL_PHY_PWRUP

  =s(devPMT_CTL);
  ret =smsc75xx_read_reg_nopm, WUCSR, &val
  if(ret  ){
   return ret;
  }
 }

 ret = smsc75xx_wait_ready(dev, 1);
 ifret 0 {
  netdev_warn(dev->net, "device not ready in smsc75xx_resume
  return ret;
 }

 return usbnet_resumenetdev_warn>net Error \";
}

static voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         u32 rx_cmd_a, u32   = smsc75xx_read_reg_nopmdev,)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
{
 if (!  done
 }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } else {
  skb->csum = ntohsret (dev, val
  skb->ip_summed = CHECKSUM_COMPLETE;
}
}

static int smsc75xx_rx_fixup(struct  goto ;
{
 /* This check is no longer done by usbnet *//
 if (skb-> netdev_info(>net" \";
  return 0;

 while (skb-  * TODO: resume() might need to handle the suspend failure
  u32 rx_cmd_a, _())
  struct sk_buff *ax_skb;
  unsigned char *packet;

  rx_cmd_a = get_unaligned_le32{
  skb_pull(skb, 4);

  rx_cmd_b = get_unaligned_le32  smsc75xx_priv*pdata =( smsc75xx_priv *(ev->[0)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  skb_pull(skb, 4 + RXW_PADDING); val

  packet = skb->data;

  /* get the packet length */
  size = (rx_cmd_a & RX_CMD_A_LEN) -java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
  align_count = (4 - ((size + RXW_PADDING) % 4  /* Disable wakeup sources */

  if if ( < ) java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   netif_dbg(dev, rx_err, dev->net,
      "size err rx_cmd_a=0x%08x\n",
      rx_cmd_a);
   return 0;
  }

  if (unlikely(rx_cmd_a & RX_CMD_A_RED)) {
   netif_dbg(dev, rx_err, dev->net,
      "Error rx_cmd_a=0x%08x\ (dev-net ErrorwritingWUCSRn);
   dev->net->stats.rx_errors++;
   dev-

   if (rx_cmd_a  al ;
    dev->  =(devPMT_CTL,);
 else rx_cmd_a ( |))
    dev-netdev_warndev-net" \)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  } else {
   /* MAX_SINGLE_PACKET_SIZE + 4(CRC) + 2(COE) + 4(Vlan) */
   if (unlikely(size >  " from \n)
    netif_dbg(dev, rx_err,  r =smsc75xx_read_reg_nopm(ev,&);
       "size err rx_cmd_a=0x%08x\n",
       rx_cmd_a);
    return 0;
   }

   /* last frame in this batch */
   if (skb->len == size) {
    smsc75xx_rx_csum_offload(dev(>netwritingn)
     rx_cmd_b ret;

    skb_trim}

    return 1;
   }

   /* Use "size - 4" to remove fcs */
   ax_skb = netdev_alloc_skb_ip_align(dev->net, size return retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   if (unlikely(!ax_skb)) {
    netdev_warn(dev->netstatic  smsc75xx_rx_csum_offload  *devstruct *skb
    ;
   }

   skb_put(ax_skb, size - 4
   (ax_skb->data,packet size- );

, rx_cmd_a
    rx_cmd_b);

   usbnet_skb_return(dev, ax_skb);
  }

  skb_pull, );

  /* padding bytes before the next frame starts */
  if (skb->len)
   skb_pull(skb, align_count);
 }

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

static struct sk_buff *smsc75xx_tx_fixup rx_cmd_a,, , ;
      struct sk_buff *skb, gfp_tjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 24
{
 u32tx_cmd_a tx_cmd_b;
 void  skb_pull, )java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

  skb_pull, 4+RXW_PADDING;
  dev_kfree_skb_any(skb);
  return NULL;
 }

tx_cmd_a u32)>len ) |;

if(>ip_summed=CHECKSUM_PARTIAL
  tx_cmd_a |java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ifskb_is_gso))
 u16mss=max(skb>, TX_MSS_MIN)
  tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT) & TX_CMD_B_MSS;

  tx_cmd_a |= TX_CMD_A_LSO;
 } else {
   = 0;
 }

ptr(,)
 put_unaligned_le32(tx_cmd_a   >net-.rx_errors;
 put_unaligned_le32(tx_cmd_b, ptr + 4);

 return skb
}

static int smsc75xx_manage_power>>stats+;
{
>> = ;
  } java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static const struct driver_info smsc75xx_info = {
 .description = " sizeerrrx_cmd_a=x8\,
 .bind);
 .unbind   return ;
 .link_reset = smsc75xx_link_reset,
 .reset  = smsc75xx_reset,
 .rx_fixup = smsc75xx_rx_fixup,
 .tx_fixup   if(skb->len== size {
 .status  = smsc75xx_status,
 .manage_power = smsc75xx_manage_power,
 flags =FLAG_ETHER|FLAG_SEND_ZLP|FLAG_LINK_INTR
};

static const struct usb_device_id products
 
  /* SMSC7500 USB Gigabit Ethernet Device */
  USB_DEVICE(USB_VENDOR_ID_SMSC,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .driver_info = (unsigned long) &smsc75xx_info,
 }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 {
  /* SMSC7500 USB Gigabit Ethernet Device */
  USB_DEVICE usbnet_skb_return(,ax_skb
  .driver_info = (unsigned long) &smsc75xx_info,
 }
 {java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};
MODULE_DEVICE_TABLE(usb, products);

static struct usb_driver smsc75xx_driver = {
 .name  = SMSC_CHIPNAME,
 .id_table = products,
 .probe  = usbnet_probe,
 .suspend smsc75xx_suspend
 .resume  = smsc75xx_resumeu32, tx_cmd_b
 .reset_resume = void*;
 . = usbnet_disconnect
.disable_hub_initiated_lpm = 1
 .supports_autosuspend = 1,
};

module_usb_driver(smsc75xx_driver);

MODULE_AUTHOR("Nancy Lin");
("Steve Glendinning steve.@shawellnet");
MODULE_DESCRIPTION("SMSC75XX USBjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_LICENSE("GPL");