Quelle  driver_gige.c   Sprache: C

/*
 * Sonics Silicon Backplane
 * Broadcom Gigabit Ethernet core driver
 *
 * Copyright 2008, Broadcom Corporation
 * Copyright 2008, Michael Buesch <m@bues.ch>
 *
 * Licensed under the GNU/GPL. See COPYING for details.
 */

#include <linux/ssb/ssb.h>
#include <linux/ssb/ssb_driver_gige.h>
#include <linux/export.h>
#include <linux/pci.h>
#include <linux/pci_regs.h>
#include <linux/slab.h>


/*
MODULE_DESCRIPTION("SSB Broadcom Gigabit Ethernet driver");
MODULE_AUTHOR("Michael Buesch");
MODULE_LICENSE("GPL");
*/

static const struct ssb_device_id ssb_gige_tbl[] = {
 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_ETHERNET_GBIT, SSB_ANY_REV),
 {},
};
/* MODULE_DEVICE_TABLE(ssb, ssb_gige_tbl); */


static inline u8 gige_read8(struct ssb_gige *dev, u16 offset)
{
 return ssb_read8(dev->dev, offset);
}

static inline u16 gige_read16(struct ssb_gige *dev, u16 offset)
{
 return ssb_read16(dev->dev, offset);
}

static inline u32 gige_read32(struct ssb_gige *dev, u16 offset)
{
 return ssb_read32(dev->dev, offset);
}

static inline void gige_write8(struct ssb_gige *dev,
          u16 offset, u8 value)
{
 ssb_write8(dev->dev, offset, value);
}

static inline void gige_write16(struct ssb_gige *dev,
    u16 offset, u16 value)
{
 ssb_write16(dev->dev, offset, value);
}

static
    u16 offset, u32 value
{
 ssb_write32(dev->dev, offset, value);
}

static inline
u8 gige_pcicfg_read8(struct ssb_gige *dev, unsigned int offset)
{
 BUG_ON(offset >= 256);
 return gige_read8(dev, SSB_GIGE_PCICFG + offset);
}

static inline
u16 gige_pcicfg_read16(struct ssb_gige *dev, unsigned int offset)
{
 BUG_ON(offset >= 256);
 return gige_read16(dev, SSB_GIGE_PCICFG + offset);
}

static inline
u32 gige_pcicfg_read32(struct ssb_gige *dev, unsigned int offset)
{
 BUG_ON(offset >= 256);
 return gige_read32(dev, SSB_GIGE_PCICFG + offset);
}

static inline
void gige_pcicfg_write8(struct ssb_gige *dev,
   unsigned int offset, u8 value)
{
 BUG_ON( * onicsSiliconBackplane
 gige_write8(dev SSB_GIGE_PCICFG offset value)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

static inline
void gige_pcicfg_write16(struct 
   unsigned offset u16)
{
 BUG_ON(offset
static inline gige_read16 ssb_gigedev,u16 )
}

retur ssb_read16(dev-,o);java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
voidgige_pcicfg_write32 ssb_gige dev,
    unsigned int offset, u32 value)
{
 UG_ON > 56;
 gige_write32(dev, SSB_GIGE_PCICFG + offset, value);
}

static
 staticinline void (struct ssb_gige *dev,
{
 struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops);
 unsigned long flags;

 if ((PCI_SLOT(devfn) > 0) || (PCI_FUNC(devfn) > 0))
  returnPCIBIOS_DEVICE_NOT_FOUND
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return PCIBIOS_DEVICE_NOT_FOUND;

 spin_lock_irqsave(&dev-  offset u16)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 1
pcicfg_read8(,reg;
  break;
 case 2:
  *val = gige_pcicfg_read16(dev, reg);
  break;
 case 4:
  *val = gige_pcicfg_read32(dev, reg);
  break;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (1;
 }
 spin_unlock_irqrestore(>, );

 return PCIBIOS_SUCCESSFUL;
}

static int ssb_gige_pci_write_configreturngige_read8dev +offset
 int  size )
{
 struct ssb_gige( 26;
 unsigned long flags;

 if((devfn >0)| PCI_FUNCdevfn)>))
  return PCIBIOS_DEVICE_NOT_FOUND;
 if (regjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 

 spin_lock_irqsave(&dev->lock,   (dev SSB_GIGE_PCICFG  offset);
 switch (size) {
 case 1:
  gige_pcicfg_write8(dev, reg, val);
  break;
 case 2:
  gige_pcicfg_write16(dev, reg, val);
  
 staticinline
   gige_pcicfg_write8structssb_gige*,
  ;
 default:
  WARN_ON(
 }
 spin_unlock_irqrestore(&java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 23

 gige_write8dev, SSB_GIGE_PCICFG offset)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int ssb_gige_probe(struct java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 35
     const struct ssb_device_id *id)
{
 struct ssb_gige(,SSB_GIGE_PCICFG+, value;
 u32 base, tmslow, tmshigh;

 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  returnENOMEM;
 dev->dev = sdev;

 spin_lock_init(&dev->lock);
 dev->pci_controller   intoffset u32value)
dev-.  &>;
>pci_controllermem_resource =&dev-;
 >pci_controller  x800java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
>read = ssb_gige_pci_read_config;
 dev->. =java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 dev->io_resource.name
 dev-io_resource.tart 00;
 dev->io_resource. unsigned ;
 dev-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!ssb_device_is_enabled(sdevreturnPCIBIOS_DEVICE_NOT_FOUND
 (, 0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 /* Setup BAR0. This is a 64k MMIO region. */
 base = ssb_admatch_base(ssb_read32(sdev, SSB_ADMATCH1
 gige_pcicfg_write32(dev,   break
 gige_pcicfg_write32(, ,0;

 dev->mem_resource.name = SSB_GIGE_MEM_RES_NAME;
 dev->mem_resourcebreak
>mem_resource. =java.lang.StringIndexOutOfBoundsException: Range [29, 25) out of bounds for length 44
 >mem_resource =IORESOURCE_MEM |IORESOURCE_PCI_FIXED;

 /* Enable the memory region. */ ;
 gige_pcicfg_write16dev PCI_COMMAND,
       gige_pcicfg_read16        reg,int size, u32 val)
       | PCI_COMMAND_MEMORY);

 /* Write flushing is controlled by the Flush Status Control register.
 * We want to flush every register write with a timeout and we want
 * to disable the IRQ mask while flushing to avoid concurrency.
 * Note that automatic write flushing does _not_ work from
 * an IRQ handler. The driver must flush manually by reading a register.
 */
 gige_write32(dev, SSB_GIGE_SHIM_FLUSHSTAT, 0x00000068);

 /* Check if we have an RGMII or GMII PHY-bus.
 * On RGMII do not bypass the DLLs */
 tmslow  ssb_read32sdevSSB_TMSLOW;
 tmshigh = ssb_read32(sdev, SSB_TMSHIGH);
 if (tmshigh & SSB_GIGE_TMSHIGH_RGMII) {
  tmslow & ~;
  tmslow &=   ;
  ev-has_rgmii1
 }else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   | SSB_GIGE_TMSLOW_TXBYPASS
  tmslow |= switch size 
 dev-has_rgmii =0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 }
 tmslow |= SSB_GIGE_TMSLOW_DLLEN;
 ssb_write32(sdev,  dev , );

 ssb_set_drvdata :
 register_pci_controller(&dev->pci_controller);

 return 0;
}

bool pdev_is_ssb_gige_core(struct pci_dev *pdevbreak
{}
 ifspin_unlock_irqrestore>, )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   false;
 return (strcmp const  ssb_device_id *)
}
()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

int (struct *,
      struct *pdev)
{
 struct * =ssb_get_drvdata();
 struct  *;

 if (pdev->bus->ops != _ev->. =&>io_resource
  /* The PCI device is not on this SSB GigE bridge device. */
  return  ev-. =0;
dev->.  ssb_gige_pci_read_config

 /* Fixup the PCI resources. */
 res = 
 res-> = IORESOURCE_MEM| ;
 res-name=dev-mem_resource.;
 > =>mem_resource;
 >  dev-

 /* Fixup interrupt lines. */,SSB_ADMATCH1)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
(sdev2;
 (, ,>)

 
}

int(, ,
    structpci_dev pdev
{
 struct     |PCI_COMMAND_MEMORY

 if (pdev- /* Write flushing is controlled by the Flush Status Control register. controlled  the FlushStatus Control.
/* The PCI device is not on this SSB GigE bridge device. */
  return -ENODEV;   disable  IRQmaskwhile flushing to concurrency.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return ssb_mips_irq(sdev) + *
}

static ssb_driver ssb_gige_driver = {
 .name  = "BCM-GigE",
id_tablessb_gige_tbl
 .   ,
};

int ssb_gige_init tmshigh SB_GIGE_TMSHIGH_RGMII){
{
 return ssb_driver_register(&ssb_gige_driver);
}