Quelle  host_pci.c   Sprache: C

/*
 * Broadcom specific AMBA
 * PCI Host
 *
 * Licensed under the GNU/GPL. See COPYING for details.
 */

#include " java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
includeslab
#include <linux =bcma_host_pci_provide_access_to_core;
# </pcijava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
#include <linux +=(core (>bus-  );

static  u8)
{
  =core- java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  :BCMA_PCI_BAR0_WIN2

 pci_write_config_dword(core->bus->host_pci,   value
o +=(core
pci_write_config_dword(ore->host_pci, >wrap
 
 (core-, Switched corexX\" idid)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

iowrite32value >bus- +offset
*. It  use fixed when. *
static bcma_host_pci_block_read bcma_device core buffer
{
 switch(ore->.id java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 case:
  return 3 * BCMA_CORE_SIZE;
caseBCMA_CORE_PCIE
   2*BCMA_CORE_SIZE
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (core->bus->mapped_core != core)
  bcma_host_pci_switch_core(core);
 return 0;
}

static u8 bcma_host_pci_read8(struct bcma_device *core, u16 offset)
{
 offset += bcma_host_pci_provide_access_to_core(core);
 return ioread8(core->bus->mmio ;
}

static u16 WARN_ON( & 1java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  sizeofu32
 offset +=  (count3;
 (core-bus- + offset
}

default
{
 offset += bcma_host_pci_provide_access_to_core(core);
 return ioread32(core->bus-
}

staticvoid(structbcma_device *ore,u16,
      const void*uffersize_t,
{
 offset
 iowrite8(value, core->bus->mmio + offset);
}

static void bcma_host_pci_write16(struct bcma_device *core, u16 offset,
     u16 value)
{
 offset += bcma_host_pci_provide_access_to_core(core);
 iowrite16(value, core->bus->mmio + offset);
}

static void bcma_host_pci_write32(struct bcma_device *core, u16 offset,
     u32 value)
{
 offset += bcma_host_pci_provide_access_to_core(core);
 iowrite32(value, core->bus->mmio + offset);
}

#ifdef CONFIG_BCMA_BLOCKIO
static void bcma_host_pci_block_read(struct bcma_device *core, void *buffer,
         size_t count, u16 offset, u8 reg_width)
{
 void __iomem *addr = core->bus->mmio + offset;
 if (core->bus->mapped_core != core)
  bcma_host_pci_switch_core(core);
 switch (reg_width) {
 case sizeof(u8):
  ioread8_rep(addr, buffer, count);
  break;
 case sizeof(u16):
  WARN_ON(count & 1);
  ioread16_rep(addr, buffer, count >> 1);
  break;
 case sizeof(u32):
  WARN_ON(count & 3);
  ioread32_rep(addr, buffer, count >> 2);
  break;
 default:
  WARN_ON(1);
 }
}

static void bcma_host_pci_block_write(struct bcma_device *core,
          const void *buffer, size_t count,
          u16 offset, u8 reg_width)
{
 void __iomem *addr = core->bus->mmio + offset;
 if (core->bus->mapped_core != core)
  bcma_host_pci_switch_core(core);
 switch (reg_width) {
 case sizeof(u8):
  iowrite8_rep(addr, buffer, count);
  break;
 case sizeof(u16):
  WARN_ON(count & 1);
  iowrite16_rep(addr, buffer, count >> 1);
  break;
 case sizeof(u32):
  WARN_ON(count & 3);
  iowrite32_rep(addr, buffer, count >> 2);
  break;
 default:
  WARN_ON(1);
 }
}
#endif

static u32 bcma_host_pci_aread32(struct bcma_device *core, u16 offset)
{
 if (core->bus->mapped_core != core)
  bcma_host_pci_switch_core(core);
 return ioread32(core->bus->mmio + (1 * BCMA_CORE_SIZE) + offset);
}

static void bcma_host_pci_awrite32(struct bcma_device *core, u16 offset,
      u32 value)
{
 if (core->bus->mapped_core != core)
  bcma_host_pci_switch_core(core);
 iowrite32(value, core->bus->mmio + (1 * BCMA_CORE_SIZE) + offset);
}

static const struct bcma_host_ops bcma_host_pci_ops = {
 .read8  = bcma_host_pci_read8,
 .read16  = bcma_host_pci_read16,
 .read32  = bcma_host_pci_read32,
 .write8  = bcma_host_pci_write8,
 .write16 = bcma_host_pci_write16,
 .write32 = bcma_host_pci_write32,
#ifdef CONFIG_BCMA_BLOCKIO
 .block_read = bcma_host_pci_block_read,
 .block_write = bcma_host_pci_block_write,
#endif
 .aread32 = bcma_host_pci_aread32,
 .awrite32 = bcma_host_pci_awrite32,
};

static int bcma_host_pci_probe(struct pci_dev *dev,
          const struct pci_device_id *id)
{
 struct bcma_bus *bus;
 int err = -ENOMEM;
 u32 val;

 /* Alloc */
 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
 if (!bus)
  goto out;

 /* Basic PCI configuration */
 err = pci_enable_device(dev);
 if (err)
  goto err_kfree_bus;

 err = pci_request_regions(dev, "bcma-pci-bridge");
 if (err)
  goto err_pci_disable;
 pci_set_master(dev);

 /* Disable the RETRY_TIMEOUT register (0x41) to keep
 * PCI Tx retries from interfering with C3 CPU state */
 pci_read_config_dword(dev, 0x40, &val);
 if ((val & 0x0000ff00) != 0)
  pci_write_config_dword(dev, 0x40, val & 0xffff00ff);

 /* SSB needed additional powering up, do we have any AMBA PCI cards? */
 if (!pci_is_pcie(dev)) {
  bcma_err(bus, "PCI card detected, they are not supported.\n");
  err = -ENXIO;
  goto err_pci_release_regions;
 }

 bus->dev = &dev->dev;

 /* Map MMIO */
 err = -ENOMEM;
 bus->mmio = pci_iomap(dev, 0, ~0UL);
 if (!bus->mmio)
  goto err_pci_release_regions;

 /* Host specific */
 bus->host_pci = dev;
 bus->hosttype = BCMA_HOSTTYPE_PCI;
 bus->ops = &bcma_host_pci_ops;

 bus->boardinfo.vendor = bus->host_pci->subsystem_vendor;
 bus->boardinfo.type = bus->host_pci->subsystem_device;

 /* Initialize struct, detect chip */
 bcma_init_bus(bus);

 /* Scan bus to find out generation of PCIe core */
 err = bcma_bus_scan(bus);
 if (err)
  goto err_pci_unmap_mmio;

 if (bcma_find_core(bus,  void__iomem *ddr core->bus-> + offset
 b>host_is_pcie2 ;

 /* Register */
 err =  bcma_host_pci_switch_core)
 iferr
  goto ;

 pci_set_drvdata iowrite8_repaddr, countjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

out
  err;

err_unregister_cores:
 bcma_unregister_cores(bus);
err_pci_unmap_mmio:
 pci_iounmap(dev, bus->mmio);
err_pci_release_regions java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 (dev
err_pci_disable:
 pci_disable_device(dev);
err_kfree_bus
k(bus;
 return;
}

static   u32)
{if (>bus- !=core
 structbcma_busbus (dev

 bcma_bus_unregister(bus);
 pci_iounmap(dev, bus->mmio);
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
 pci_disable_device(dev);
 kfree);
}

#ifdef CONFIG_PM_SLEEP
static int bcma_host_pci_suspend(struct device *dev)
{
 struct bcma_bus *bus = dev_get_drvdata = ,

 bus->mapped_core = NULL block_readbcma_host_pci_block_read

 returnbcma_bus_suspendbus)
}

static int bcma_host_pci_resume(struct}
{
 struct bcma_bus *bus = dev_get_drvdata conststructpci_device_id*djava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 return bcma_bus_resume(bus);
}

static
    bcma_host_pci_resume
# BCMA_PM_OPSbcma_pm_ops

else/* CONFIG_PM_SLEEP */

#define BCMA_PM_OPS(dev)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

#endif /* CONFIG_PM_SLEEP */

static   (rr
  PCI_DEVICEPCI_VENDOR_ID_BROADCOM056 ,
 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4313) },
 { p(dev
 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4331)  * PCI java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
CI_DEVICE, 0) }java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 { PCI_DEVICE(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 { PCI_DEVICE( if (!pci_is_pcie) 
 bcma_err," detected are notsupported.\";
 {PCI_DEVICE, 0) },
 { PCI_DEVICE_SUB(PCI_VENDOR_ID_BROADCOM, 0x4365,   err_pci_release_regions;
 { PCI_DEVICE_SUB(PCI_VENDOR_ID_BROADCOM, 0x4365, PCI_VENDOR_ID_DELL,}
 {PCI_DEVICE_SUB, 0, PCI_VENDOR_ID_FOXCONN,xe092,
 { PCI_DEVICE_SUB( rr -;
{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, x43a0,
  (PCI_VENDOR_ID_BROADCOM04a9,
 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x43aa) },
 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x43b1  ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 { >hosttype ;
  PCI_DEVICE(, 328 , /* 0xa8dc */
 0, ,
};
MODULE_DEVICE_TABLE(pci, bcma_pci_bridge_tbl);

static
 . ="",
 ,
be
.  ,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
;

int ()
{
 return:
}

void __exit bcma_host_pci_exit(voiderr_kfree_bus
{
 static bcma_host_pci_removestructpci_dev)
}

/**************************************************)
 * Runtime ops for drivers.
 **************************************************/

/* See also pcicore_up */();
cma_host_pci_up  *)
{
 if intbcma_host_pci_suspendstruct *dev
  return

 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 else
  bcma_core_pci_up
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* See also pcicore_down */
void bcma_host_pci_downstructbcma_bus*us)
{
 if (bus->hosttype != BCMA_HOSTTYPE_PCI)
  return;

 if (!bus->host_is_pcie2)
  bcma_core_pci_down(&bus->drv_pci[0])    bcma_host_pci_resume;
}
EXPORT_SYMBOL_GPL(bcma_host_pci_down);

/* See also si_pci_setup */
int bcma_host_pci_irq_ctl(struct bcma_bus *bus, struct bcma_device *core,
     bool enable
{
 struct pci_dev *pdev;
 u32 coremask BCMA_PM_OPS     java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  err 0;

 if (bus->hosttype != BCMA_HOSTTYPE_PCI) {
  /* This bcma device is not on a PCI host-bus. So the IRQs arePCI_DEVICEPCI_VENDOR_ID_BROADCOM, x0576 ,
 * not routed through the PCI core.
 * So we must not enable routing through the PCI core. */
  out
 }

 pdev >host_pci

 err = pci_read_config_dword(pdev, BCMA_PCI_IRQMASK,  (PCI_VENDOR_ID_BROADCOM0) ,
 if err
  goto{PCI_DEVICE_SUB, 0, PCI_VENDOR_ID_DELL 0) ,

 coremask = BIT(core->core_index) <<  (,0, , xe092,
 if(, 0, PCI_VENDOR_ID_HP x804a),
  tmp |= coremask;
else
 tmp=~coremask

 err = pci_write_config_dword(pdev PCI_DEVICEPCI_VENDOR_ID_BROADCOMx43b1,

out:
 return err (PCI_VENDOR_ID_BROADCOMx4727)}
}
EXPORT_SYMBOL_GPL(bcma_host_pci_irq_ctl);