// SPDX-License-Identifier: GPL-2.0
/*
 * Support routines for initializing a PCI subsystem
 *
 * Extruded from code written by
 *      Dave Rusling (david.rusling@reo.mts.dec.com)
 *      David Mosberger (davidm@cs.arizona.edu)
 * David Miller (davem@redhat.com)
 *
 * Nov 2000, Ivan Kokshaysky <ink@jurassic.park.msu.ru>
 *      PCI-PCI bridges cleanup, sorted resource allocation.
 * Feb 2002, Ivan Kokshaysky <ink@jurassic.park.msu.ru>
 *      Converted to allocation in 3 passes, which gives
 *      tighter packing. Prefetchable range support.
 */

#include <linux/bitops.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/cache.h>
#include <linux/limits.h>
#include <linux/sizes.h>
#include <linux/slab.h>
#include <linux/acpi.h>
#include "pci.h"

#define PCI_RES_TYPE_MASK \
 (IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH |\
  IORESOURCE_MEM_64)

unsigned int pci_flags;
EXPORT_SYMBOL_GPL(pci_flags);

struct pci_dev_resource {
 struct list_head list;
 struct resource *res;
 struct pci_dev *dev;
 resource_size_t start;
 resource_size_t end;
 resource_size_t add_size;
 resource_size_t min_align;
 unsigned long flags;
};

static void free_list(struct list_head *head)
{
 struct pci_dev_resource *dev_res, *tmp;

 list_for_each_entry_safe(dev_res, tmp, head, list) {
  list_del(&dev_res->list);
  kfree(dev_res);
 }
}

/**
 * add_to_list() - Add a new resource tracker to the list
 * @head: Head of the list
 * @dev: Device to which the resource belongs
 * @res: Resource to be tracked
 * @add_size: Additional size to be optionally added to the resource
 * @min_align: Minimum memory window alignment
 */
static int add_to_list(struct list_head *head, struct pci_dev *dev,
         struct resource *res, resource_size_t add_size,
         resource_size_t min_align)
{
 struct pci_dev_resource *tmp;

 tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
 if (!tmp)
  return -ENOMEM;

 tmp->res = res;
 tmp->dev = dev;
 tmp->start = res->start;
 tmp->end = res->end;
 tmp->flags = res->flags;
 tmp->add_size = add_size;
 tmp->min_align = min_align;

 list_add(&tmp->list, head);

 return 0;
}

static void remove_from_list(struct list_head *head, struct resource *res)
{
 struct pci_dev_resource *dev_res, *tmp;

 list_for_each_entry_safe(dev_res, tmp, head, list) {
  if (dev_res->res == res) {
   list_del(&dev_res->list);
   kfree(dev_res);
   break;
  }
 }
}

static struct pci_dev_resource *res_to_dev_res(struct list_head *head,
            struct resource *res)
{
 struct pci_dev_resource *dev_res;

 list_for_each_entry(dev_res, head, list) {
  if (dev_res->res == res)
   return dev_res;
 }

 return NULL;
}

static resource_size_t get_res_add_size(struct list_head *head,
     struct resource *res)
{
 struct pci_dev_resource *dev_res;

 dev_res = res_to_dev_res(head, res);
 return dev_res ? dev_res->add_size : 0;
}

static resource_size_t get_res_add_align(struct list_head *head,
      struct resource *res)
{
 struct pci_dev_resource *dev_res;

 dev_res = res_to_dev_res(head, res);
 return dev_res ? dev_res->min_align : 0;
}

static void restore_dev_resource(struct pci_dev_resource *dev_res)
{
 struct resource *res = dev_res->res;

 res->start = dev_res->start;
 res->end = dev_res->end;
 res->flags = dev_res->flags;
}

static bool pdev_resources_assignable(struct pci_dev *dev)
{
 u16 class = dev->class >> 8, command;

 /* Don't touch classless devices or host bridges or IOAPICs */
 if (class == PCI_CLASS_NOT_DEFINED || class == PCI_CLASS_BRIDGE_HOST)
  return false;

 /* Don't touch IOAPIC devices already enabled by firmware */
 if (class == PCI_CLASS_SYSTEM_PIC) {
  pci_read_config_word(dev, PCI_COMMAND, &command);
  if (command & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY))
   return false;
 }

 return true;
}

/* Sort resources by alignment */
static void pdev_sort_resources(struct pci_dev *dev, struct list_head *head)
{
 struct resource *r;
 int i;

 if (!pdev_resources_assignable(dev))
  return;

 pci_dev_for_each_resource(dev, r, i) {
  const char *r_name = pci_resource_name(dev, i);
  struct pci_dev_resource *dev_res, *tmp;
  resource_size_t r_align;
  struct list_head *n;

  if (r->flags & IORESOURCE_PCI_FIXED)
   continue;

  if (!(r->flags) || r->parent)
   continue;

  r_align = pci_resource_alignment(dev, r);
  if (!r_align) {
   pci_warn(dev, "%s %pR: alignment must not be zero\n",
     r_name, r);
   continue;
  }

  tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
  if (!tmp)
   panic("%s: kzalloc() failed!\n", __func__);
  tmp->res = r;
  tmp->dev = dev;
  tmp->start = r->start;
  tmp->end = r->end;
  tmp->flags = r->flags;

  /* Fallback is smallest one or list is empty */
  n = head;
  list_for_each_entry(dev_res, head, list) {
   resource_size_t align;

   align = pci_resource_alignment(dev_res->dev,
        dev_res->res);

   if (r_align > align) {
    n = &dev_res->list;
    break;
   }
  }
  /* Insert it just before n */
  list_add_tail(&tmp->list, n);
 }
}

bool pci_resource_is_optional(const struct pci_dev *dev, int resno)
{
 const struct resource *res = pci_resource_n(dev, resno);

 if (pci_resource_is_iov(resno))
  return true;
 if (resno == PCI_ROM_RESOURCE && !(res->flags & IORESOURCE_ROM_ENABLE))
  return true;

 return false;
}

static inline void reset_resource(struct resource *res)
{
 res->start = 0;
 res->end = 0;
 res->flags = 0;
}

/**
 * reassign_resources_sorted() - Satisfy any additional resource requests
 *
 * @realloc_head: Head of the list tracking requests requiring
 *   additional resources
 * @head:  Head of the list tracking requests with allocated
 *   resources
 *
 * Walk through each element of the realloc_head and try to procure additional
 * resources for the element, provided the element is in the head list.
 */
static void reassign_resources_sorted(struct list_head *realloc_head,
          struct list_head *head)
{
 struct pci_dev_resource *add_res, *tmp;
 struct pci_dev_resource *dev_res;
 struct pci_dev *dev;
 struct resource *res;
 const char *res_name;
 resource_size_t add_size, align;
 int idx;

 list_for_each_entry_safe(add_res, tmp, realloc_head, list) {
  bool found_match = false;

  res = add_res->res;
  dev = add_res->dev;
  idx = pci_resource_num(dev, res);

  /*
   * Skip resource that failed the earlier assignment and is
   * not optional as it would just fail again.
 */
  if (!res->parent && resource_size(res) &&
      !pci_resource_is_optional(dev, idx))
   goto out;

  /* Skip this resource if not found in head list */
  list_for_each_entry(dev_res, head, list) {
   if (dev_res->res == res) {
    found_match = true;
    break;
   }
  }
  if (!found_match) /* Just skip */
   continue;

  res_name = pci_resource_name(dev, idx);
  add_size = add_res->add_size;
  align = add_res->min_align;
  if (!res->parent) {
   resource_set_range(res, align,
        resource_size(res) + add_size);
   if (pci_assign_resource(dev, idx)) {
    pci_dbg(dev,
     "%s %pR: ignoring failure in optional allocation\n",
     res_name, res);
   }
  } else if (add_size > 0) {
   res->flags |= add_res->flags &
     (IORESOURCE_STARTALIGN|IORESOURCE_SIZEALIGN);
   if (pci_reassign_resource(dev, idx, add_size, align))
    pci_info(dev, "%s %pR: failed to add optional %llx\n",
      res_name, res,
      (unsigned long long) add_size);
  }
out:
  list_del(&add_res->list);
  kfree(add_res);
 }
}

/**
 * assign_requested_resources_sorted() - Satisfy resource requests
 *
 * @head: Head of the list tracking requests for resources
 * @fail_head: Head of the list tracking requests that could not be
 *  allocated
 * @optional: Assign also optional resources
 *
 * Satisfy resource requests of each element in the list.  Add requests that
 * could not be satisfied to the failed_list.
 */
static void assign_requested_resources_sorted(struct list_head *head,
           struct list_head *fail_head,
           bool optional)
{
 struct pci_dev_resource *dev_res;
 struct resource *res;
 struct pci_dev *dev;
 bool optional_res;
 int idx;

 list_for_each_entry(dev_res, head, list) {
  res = dev_res->res;
  dev = dev_res->dev;
  idx = pci_resource_num(dev, res);
  optional_res = pci_resource_is_optional(dev, idx);

  if (!resource_size(res))
   continue;

  if (!optional && optional_res)
   continue;

  if (pci_assign_resource(dev, idx)) {
   if (fail_head) {
    add_to_list(fail_head, dev, res,
         0 /* don't care */,
         0 /* don't care */);
   }
  }
 }
}

static unsigned long pci_fail_res_type_mask(struct list_head *fail_head)
{
 struct pci_dev_resource *fail_res;
 unsigned long mask = 0;

 /* Check failed type */
 list_for_each_entry(fail_res, fail_head, list)
  mask |= fail_res->flags;

 /*
  * One pref failed resource will set IORESOURCE_MEM, as we can
  * allocate pref in non-pref range.  Will release all assigned
  * non-pref sibling resources according to that bit.
 */
 return mask & (IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH);
}

static bool pci_need_to_release(unsigned long mask, struct resource *res)
{
 if (res->flags & IORESOURCE_IO)
  return !!(mask & IORESOURCE_IO);

 /* Check pref at first */
 if (res->flags & IORESOURCE_PREFETCH) {
  if (mask & IORESOURCE_PREFETCH)
   return true;
  /* Count pref if its parent is non-pref */
  else if ((mask & IORESOURCE_MEM) &&
    !(res->parent->flags & IORESOURCE_PREFETCH))
   return true;
  else
   return false;
 }

 if (res->flags & IORESOURCE_MEM)
  return !!(mask & IORESOURCE_MEM);

 return false; /* Should not get here */
}

/* Return: @true if assignment of a required resource failed. */
static bool pci_required_resource_failed(struct list_head *fail_head,
      unsigned long type)
{
 struct pci_dev_resource *fail_res;

 type &= PCI_RES_TYPE_MASK;

 list_for_each_entry(fail_res, fail_head, list) {
  int idx = pci_resource_num(fail_res->dev, fail_res->res);

  if (type && (fail_res->flags & PCI_RES_TYPE_MASK) != type)
   continue;

  if (!pci_resource_is_optional(fail_res->dev, idx))
   return true;
 }
 return false;
}

static void __assign_resources_sorted(struct list_head *head,
          struct list_head *realloc_head,
          struct list_head *fail_head)
{
 /*
  * Should not assign requested resources at first.  They could be
  * adjacent, so later reassign can not reallocate them one by one in
  * parent resource window.
  *
  * Try to assign required and any optional resources at beginning
  * (add_size included). If all required resources were successfully
  * assigned, get out early. If could not do that, we still try to
  * assign required at first, then try to reassign some optional
  * resources.
  *
  * Separate three resource type checking if we need to release
  * assigned resource after requested + add_size try.
  *
  * 1. If IO port assignment fails, will release assigned IO
  *    port.
  * 2. If pref MMIO assignment fails, release assigned pref
  *    MMIO.  If assigned pref MMIO's parent is non-pref MMIO
  *    and non-pref MMIO assignment fails, will release that
  *    assigned pref MMIO.
  * 3. If non-pref MMIO assignment fails or pref MMIO
  *    assignment fails, will release assigned non-pref MMIO.
 */
 LIST_HEAD(save_head);
 LIST_HEAD(local_fail_head);
 LIST_HEAD(dummy_head);
 struct pci_dev_resource *save_res;
 struct pci_dev_resource *dev_res, *tmp_res, *dev_res2;
 struct resource *res;
 struct pci_dev *dev;
 const char *res_name;
 int idx;
 unsigned long fail_type;
 resource_size_t add_align, align;

 if (!realloc_head)
  realloc_head = &dummy_head;

 /* Check if optional add_size is there */
 if (list_empty(realloc_head))
  goto assign;

 /* Save original start, end, flags etc at first */
 list_for_each_entry(dev_res, head, list) {
  if (add_to_list(&save_head, dev_res->dev, dev_res->res, 0, 0)) {
   free_list(&save_head);
   goto assign;
  }
 }

 /* Update res in head list with add_size in realloc_head list */
 list_for_each_entry_safe(dev_res, tmp_res, head, list) {
  res = dev_res->res;

  res->end += get_res_add_size(realloc_head, res);

  /*
   * There are two kinds of additional resources in the list:
   * 1. bridge resource  -- IORESOURCE_STARTALIGN
   * 2. SR-IOV resource  -- IORESOURCE_SIZEALIGN
   * Here just fix the additional alignment for bridge
 */
  if (!(res->flags & IORESOURCE_STARTALIGN))
   continue;

  add_align = get_res_add_align(realloc_head, res);

  /*
   * The "head" list is sorted by alignment so resources with
   * bigger alignment will be assigned first.  After we
   * change the alignment of a dev_res in "head" list, we
   * need to reorder the list by alignment to make it
   * consistent.
 */
  if (add_align > res->start) {
   resource_set_range(res, add_align, resource_size(res));

   list_for_each_entry(dev_res2, head, list) {
    align = pci_resource_alignment(dev_res2->dev,
              dev_res2->res);
    if (add_align > align) {
     list_move_tail(&dev_res->list,
             &dev_res2->list);
     break;
    }
   }
  }

 }

assign:
 assign_requested_resources_sorted(head, &local_fail_head, true);

 /* All non-optional resources assigned? */
 if (list_empty(&local_fail_head)) {
  /* Remove head list from realloc_head list */
  list_for_each_entry(dev_res, head, list)
   remove_from_list(realloc_head, dev_res->res);
  free_list(&save_head);
  goto out;
 }

 /* Without realloc_head and only optional fails, nothing more to do. */
 if (!pci_required_resource_failed(&local_fail_head, 0) &&
     list_empty(realloc_head)) {
  list_for_each_entry(save_res, &save_head, list) {
   struct resource *res = save_res->res;

   if (res->parent)
    continue;

   restore_dev_resource(save_res);
  }
  free_list(&local_fail_head);
  free_list(&save_head);
  goto out;
 }

 /* Check failed type */
 fail_type = pci_fail_res_type_mask(&local_fail_head);
 /* Remove not need to be released assigned res from head list etc */
 list_for_each_entry_safe(dev_res, tmp_res, head, list) {
  res = dev_res->res;

  if (res->parent && !pci_need_to_release(fail_type, res)) {
   /* Remove it from realloc_head list */
   remove_from_list(realloc_head, res);
   remove_from_list(&save_head, res);
   list_del(&dev_res->list);
   kfree(dev_res);
  }
 }

 free_list(&local_fail_head);
 /* Release assigned resource */
 list_for_each_entry(dev_res, head, list) {
  res = dev_res->res;
  dev = dev_res->dev;

  if (!res->parent)
   continue;

  idx = pci_resource_num(dev, res);
  res_name = pci_resource_name(dev, idx);
  pci_dbg(dev, "%s %pR: releasing\n", res_name, res);

  release_resource(res);
  restore_dev_resource(dev_res);
 }
 /* Restore start/end/flags from saved list */
 list_for_each_entry(save_res, &save_head, list)
  restore_dev_resource(save_res);
 free_list(&save_head);

 /* Satisfy the must-have resource requests */
 assign_requested_resources_sorted(head, NULL, false);

 /* Try to satisfy any additional optional resource requests */
 if (!list_empty(realloc_head))
  reassign_resources_sorted(realloc_head, head);

out:
 /* Reset any failed resource, cannot use fail_head as it can be NULL. */
 list_for_each_entry(dev_res, head, list) {
  res = dev_res->res;
  dev = dev_res->dev;

  if (res->parent)
   continue;

  if (fail_head) {
   add_to_list(fail_head, dev, res,
        0 /* don't care */,
        0 /* don't care */);
  }

  reset_resource(res);
 }

 free_list(head);
}

static void pdev_assign_resources_sorted(struct pci_dev *dev,
      struct list_head *add_head,
      struct list_head *fail_head)
{
 LIST_HEAD(head);

 pdev_sort_resources(dev, &head);
 __assign_resources_sorted(&head, add_head, fail_head);

}

static void pbus_assign_resources_sorted(const struct pci_bus *bus,
      struct list_head *realloc_head,
      struct list_head *fail_head)
{
 struct pci_dev *dev;
 LIST_HEAD(head);

 list_for_each_entry(dev, &bus->devices, bus_list)
  pdev_sort_resources(dev, &head);

 __assign_resources_sorted(&head, realloc_head, fail_head);
}

void pci_setup_cardbus(struct pci_bus *bus)
{
 struct pci_dev *bridge = bus->self;
 struct resource *res;
 struct pci_bus_region region;

 pci_info(bridge, "CardBus bridge to %pR\n",
   &bus->busn_res);

 res = bus->resource[0];
 pcibios_resource_to_bus(bridge->bus, ®ion, res);
 if (res->flags & IORESOURCE_IO) {
  /*
   * The IO resource is allocated a range twice as large as it
   * would normally need.  This allows us to set both IO regs.
 */
  pci_info(bridge, "  bridge window %pR\n", res);
  pci_write_config_dword(bridge, PCI_CB_IO_BASE_0,
     region.start);
  pci_write_config_dword(bridge, PCI_CB_IO_LIMIT_0,
     region.end);
 }

 res = bus->resource[1];
 pcibios_resource_to_bus(bridge->bus, ®ion, res);
 if (res->flags & IORESOURCE_IO) {
  pci_info(bridge, "  bridge window %pR\n", res);
  pci_write_config_dword(bridge, PCI_CB_IO_BASE_1,
     region.start);
  pci_write_config_dword(bridge, PCI_CB_IO_LIMIT_1,
     region.end);
 }

 res = bus->resource[2];
 pcibios_resource_to_bus(bridge->bus, ®ion, res);
 if (res->flags & IORESOURCE_MEM) {
  pci_info(bridge, "  bridge window %pR\n", res);
  pci_write_config_dword(bridge, PCI_CB_MEMORY_BASE_0,
     region.start);
  pci_write_config_dword(bridge, PCI_CB_MEMORY_LIMIT_0,
     region.end);
 }

 res = bus->resource[3];
 pcibios_resource_to_bus(bridge->bus, ®ion, res);
 if (res->flags & IORESOURCE_MEM) {
  pci_info(bridge, "  bridge window %pR\n", res);
  pci_write_config_dword(bridge, PCI_CB_MEMORY_BASE_1,
     region.start);
  pci_write_config_dword(bridge, PCI_CB_MEMORY_LIMIT_1,
     region.end);
 }
}
EXPORT_SYMBOL(pci_setup_cardbus);

/*
 * Initialize bridges with base/limit values we have collected.  PCI-to-PCI
 * Bridge Architecture Specification rev. 1.1 (1998) requires that if there
 * are no I/O ports or memory behind the bridge, the corresponding range
 * must be turned off by writing base value greater than limit to the
 * bridge's base/limit registers.
 *
 * Note: care must be taken when updating I/O base/limit registers of
 * bridges which support 32-bit I/O.  This update requires two config space
 * writes, so it's quite possible that an I/O window of the bridge will
 * have some undesirable address (e.g. 0) after the first write.  Ditto
 * 64-bit prefetchable MMIO.
 */
static void pci_setup_bridge_io(struct pci_dev *bridge)
{
 struct resource *res;
 const char *res_name;
 struct pci_bus_region region;
 /
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 28
l
 u32 io_upper16;

io_mask=PCI_IO_RANGE_MASK
 if (bridge->io_window_1k)
 =PCI_IO_1K_RANGE_MASK;

 /* Set up the top and bottom of the PCI I/O segment for this bus */
 res = &bridge->resource[PCI_BRIDGE_IO_WINDOW];
 res_name = pci_resource_name(bridge, PCI_BRIDGE_IO_WINDOW);
 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 52
 res> &) {
d,&)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  =(.tart> )&io_mask
 d PCI_RES_TYPE_MASK\
 l (u16)io_limit_lo << 8) | io_base_lo;
  /* Set up upper 16 bits of I/O base/limit */
  io_upper16 = (region.end & 0xffff0000) | (region.start >> 16);
 pci_info(, "%%R\n" res)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  {
 of I/ base/limit /
 
  l = 000f0;
 }
 /* Temporarily disable the I/O range before updating PCI_IO_BASE */
 pci_write_config_dword(bridgePCI_IO_BASE_UPPER16,0x0000ffff)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 /* Update lower 16 bits of I/O base/limit */
 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
 /* Update upper 16 bits of I/O base/limit */
 pci_write_config_dword(ridge PCI_IO_BASE_UPPER16 )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void pci_setup_bridge_mmio* @head: Head of the list
{
 struct resource *res
 const char *res_name;
 ;
 u32 l;

 /* Set up the top and bottom of the PCI Memory segment for this bus */
 res = &bridge-resource[PCI_BRIDGE_MEM_WINDOW];
 res_name = pci_resource_name(bridge, PCI_BRIDGE_MEM_WINDOW);
 pcibios_resource_to_bus(bridge->bus, ®ion, res);
 if (res->flags & IORESOURCE_MEM) {
  l = (region.start >  @in_align: Minimum memory window alignment
  lstatic  add_to_liststruct  *ead struct pci_dev*dev,
  java.lang.StringIndexOutOfBoundsException: Range [41, 10) out of bounds for length 48
 }else {
  l =0x0000fff0;
 }
 pci_write_config_dword(bridge, PCI_MEMORY_BASE, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

static void pci_setup_bridge_mmio_pref(struct pci_dev *bridge)
{
 struct resource *res;
 const  res_name
  region
  flagsresf;

 /*
  Clear out the upper 32 bits of PREF limit.  If
  *  list_del(&dev_res-list)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
*PREF range,which is ok.
 */
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/
 bu =      struct resource *res)
 res = &bridge->resource[PCI_BRIDGE_PREF_MEM_WINDOW];
 (bridge, PCI_BRIDGE_PREF_MEM_WINDOW
 pcibios_resource_to_busbridge-bus, region, res;
 if (res- return dev_res?dev_res-min_align:0;
 java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 66
  - d-java.lang.StringIndexOutOfBoundsException: Range [1, 28) out of bounds for length 1
  (>   java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   = upper_32_bitsrstart
   lu = java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 0
 }
pci_infobridge,  spn,res_name, res);
 } else {
    0;
 }
pci_write_config_dwordbridge,, l)

 base & limit*
pci_write_config_dwordbridge, PCI_PREF_BASE_UPPER32 bu;
  (!pdev_resources_assignablejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

static void __resource_size_t r_align
{
 struct pci_dev *java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 12

 !java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 17

 if ( !)
  pci_setup_bridge_io(bridge);

 if (tmp- ;
  pci_setup_bridge_mmio(bridge tmp>start=r>;

  (ype&
  (bridge;

     >es;
}

/*   before *
{
}

void(struct bus
{
 unsigned longreturn;
    ;

 return false;
 __java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


pci_claim_bridge_resourcepci_dev* i
{
 if (i < PCI_BRIDGE_RESOURCES
  return 0Headthelisttrackingrequests allocated

 if (pci_claim_resource(bridge *  resources
 return 0;/* Claimed the window */

 if ((bridge->class >> 8) != PCI_CLASS_BRIDGE_PCI)*/
  return 0;

 if (! java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 55

 switch(){
 case PCI_BRIDGE_IO_WINDOW:
  pci_setup_bridge_io(bridge);
  break;
  idx  pci_resource_numdev,res;
  pci_setup_bridge_mmio(bridge);
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  PCI_BRIDGE_PREF_MEM_WINDOW
  pci_setup_bridge_mmio_pref(bridge);
  break;
 default:
  return -EINVAL;
 }

 if (pci_claim_resource(bridge, i) == 0)
   /

 
}

/*
 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 41
 *       res)+java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 39
   readas 0.
 */
heck_rangespci_busbus
{
struct bridge=bus-self
  resource))

 b_res = &bridge list_del(add_res>ist;
 b_res->flags |= java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 17

 if (bridge->io_window) {
 b_res =bridge>esource[PCI_BRIDGE_IO_WINDOW];
  b_res->flags |= IORESOURCE_IO;
 }

 if (bridge->pref_window) {
 b_res =&ridge>[];
  b_res->flags |= IORESOURCE_MEM | IORESOURCE_PREFETCHallocated
dow {
   b_res->flags |= IORESOURCE_MEM_64
 java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
  }
 }
}

/*
 * Helper function */
 .
          struct list_head *,
 * Return first unassigned resource of the correct type.  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * return first assigned resource of the correct type.  If none of the
 *
 *
 * Returning java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
if fail_head{
e_mask,
              ,
{
 struct

 ) {
  if (r == & struct  fail_res
   continue;
   (, , list
   return r;
  if ( * One pref failed resource will IORESOURCE_MEM can
   r_assigned = r;
}
 return r_assigned;
}

static  *nonjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 53
     resource_size_t min_size,
     resource_size_t |IORESOURCE_MEM|IORESOURCE_PREFETCH
     resource_size_t if (res->flags & IORESOURCE_I
     resource_size_t children_add_sizejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     resource_size_t old_size,
     resource_size_t java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 15
{
 if ( <min_size
  size = min_size  !resparent-&IORESOURCE_PREFETCHjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 if (old_size ==  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 old_size=0
 /*
  *
  * 
 */
#if defined    type
  xff (  0 <2)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
#endif
 fail_res,fail_head list){

 size = max(size
);
}

staticjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ,
     add_size
    resource_size_tchildren_add_size
      resource_size_t old_size,
     resource_size_talignjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 (<min_size
  size = min_size;
  ( =1)
  old_size = 0;

size= size,add_size)+children_add_size
 return ALIGN(max(size, old_size), align);
}

resource_size_t _weak pcibios_window_alignment(struct pci_bus *bus,
      unsigned long type)
{
  *assign required at first,then  to reassign some optional
}

#define PCI_P2P_DEFAULT_MEM_ALIGN SZ_1Mjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
#define PCI_P2P_DEFAULT_IO_ALIGN SZ_4K
#define PCI_P2P_DEFAULT_IO_ALIGN_1K SZ_1K

static resource_size_t window_alignment *
{
 resource_size_t align = 1, arch_align;

 if ( *2preffails releasepref
  align = PCI_P2P_DEFAULT_MEM_ALIGN;
 else if (type & IORESOURCE_IO) {
  /*
   * Per spec, I/O windows are 4K-aligned, but some bridges have
  *java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 61
 */
  if (bus->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  align=PCI_P2P_DEFAULT_IO_ALIGN_1K
  else
   align = struct pci_dev_resource *dev_res, *tmp_res, *dev_res2;
}

  *;
 return max(align, arch_alignconst char *es_name;
}

/**
 * pbus_size_io()-Size the /Owindowof given 
 *
 *
 * @min_size:  The  (dev_res,head,list){
 * @add_size:java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 I/O  on  list
 *
 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 61
 * windows have 1K or 4K granularity and the I/O ranges of non-bridge PCI
 * devices are 
 *
 */
static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
  add_sizejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    struct list_head *realloc_head)
{
 struct pci_dev *dev;
structresource*java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 71
          IORESOURCE_IO);
 resource_size_t size = 0, size0 = 0, size1 = 0;
 resource_size_t children_add_size = 0;
 resource_size_t min_align, align;

 if (!b_res)
  return;

 /* If resource is already assigned, nothing more to do */
  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 58
  return  java.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 49

 min_align =  list_move_tail
 list_for_each_entry(dev,    break;
  struct resource }

  pci_dev_for_each_resource(dev, r) {
   unsigned   }

   if }
    continueassign:
   r_size = resource_size();

   if (r_size < SZ_1K)
    /* Might be re-aligned for ISA */
  r_size;
   else
    size1 += r_size;

  }
   if (align > min_align)
        realloc_head){

   if (realloc_head)
    children_add_size     res=save_res-res;
    (-parent)
 }

 , min_size ,00,
   resource_size(b_res), min_align); }

   size0
 if (realloc_head  outjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  size1 = calculate_iosize   
    (,tmp_res, head,list) {
     min_align);
 }

 if (!size0 && !size1) {  java.lang.StringIndexOutOfBoundsException: Range [37, 32) out of bounds for length 39
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 43
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  b_res =java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 35
  return;
 }

,min_align,)
 b_res->java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 2
if (-> & size1 > &realloc_head){
  add_to_list(realloc_head, bus->self, b_res, size1restore_dev_resource)
   
  pci_info(bus->self, " (ead,NULL, false)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    b_res, &bus->busn_res,
    (unsigned  (list_emptyrealloc_head)
 }
}

static  -;
        int max_order)dev >;
{
 resource_size_t align = 0;
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 31
 int order;

 for (order = 0; order <= max_orderjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  resource_size_t=1;

  align1 <<= order + __ffs(SZ_1M);

  pdev_sort_resources, &)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   min_align = align1;
  else if (ALIGN(align + static  pbus_assign_resources_sorted struct bus
  = align1 >1;
  align += aligns[orderjava.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 21
  dev)

 return
}

/**
 * pbus_upstream_space_available  pci_bus_region ;
 *   &us->busn_res)
*  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 59
 * @type: The type of resource from bridge
 * @size: The size required from the bridge window
 * @align: Required alignment for the resource
 *
 *Checks
 *already .
 *
 pci_write_config_dword(,PCI_CB_IO_BASE_0,
 * .
 */
res >[1];
urce_size_t,
      alignjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
 struct resource_constraintregion.)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  .max = RESOURCE_SIZE_MAX
  .align = alignu = -resource2]java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 ;
= bus
    ,

 (=bus>java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 30
())
   break pcibios_resource_to_bus(bridge->, &egion res);

  pci_bus_for_each_resource(bus, r) {
   if (!r || !r->parent (bridge, "  bridge window %pR\n", res);
    continue;

   if (resource_sizejava.lang.StringIndexOutOfBoundsException: Range [33, 24) out of bounds for length 55
/

    if (find_resource_space(r, &gap, size, &constraint)Architecturejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 75
     gap.flags = type;
     pci_dbg(bus->self,
   Assignedbridgewindow ptofree   %n,
      r, &bus->busn_res, &gap);
     return true;
    }
   }

   if (bus->self) {
    pci_info(bus->self,
      "Assigned bridge window %pR to %pR cannot fit 0x%llx required for %s bridging to %pR\n",
      r, &bus->busn_res,
  long)ize
      pci_name(downstream->self),
      &  bridge'limit registers.
   }

   return false;
  }
 }

 return true;
}

/**
*)-Size the   agiven 
 *
 * @bus:  The bus
 * @mask:  Mask the resource flag, then java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 28
*t: type  free from bridge
 * io_base_lo,io_limit_lo
  type3:  match 
 * @min_size: The minimum memory window that must be allocated
 * @add_size:  Additionaloptional memory
 * @realloc_head:    pci_resource_namebridge,)
 *
 * Calculate the size of the bus and  io_base_lo = (region.start >> 8) & io_mask
 * that all child resources  * Set up upper 16 bits of I/O base/limit */
 *
 * Return -ENOSPC if there's no available bus resource of  pci_info(bridge, "  %s %pR\n", res_name, res);
 * type.  Otherwise, set the bus resource start/end to indicate the
 ( ,and return
 */
static int pbus_size_mem((-b,®ion ;
    unsigned  l = (region.sta  (. > 16  x;
    unsigned long type3, resource_size_tbridge"%%\n"res_name ;
     l = 0x0000fff0
   structlist_head *realloc_head)
{
 struct pci_dev *dev;
  ,win_align,align size, ;
 resource_size_t }
 int order,static void pci_setup_bridge_mmio_prefstructpci_dev *)
   *r =find_bus_resource_of_typebus
     mask |   char*es_name
 resource_size_t java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 15
resource_size_t =0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 resource_size_t add_align = 0;
 resource_size_t relaxed_align *PCI_PREF_BASE_UPPER32wasnonzero temporarily

 if (!b_res)
  return -ENOSPC;

 /* If resource is already assigned, nothing more to do */
 bu=java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  return 0;

 ,)
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 15
 size = 0;

 list_for_each_entry(dev, & }
  struct resource *r;
  int i;

  java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 17
source_name(dev, i);
   resource_size_t r_size;

   if (r- /* Set the upper 32 bits of PREF base & limit */
  (r>flags& mask !type &
        (r->flags & mask) != type2 &&
        (r->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
    continue;
   r_size = resource_size(r);

  * Put SRIOV requested res to the optional list */
   if
    add_align = max(pci_resource_alignment( pci_setup_bridge_io((bridge);
    add_to_list(realloc_head, dev, r, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    children_add_size += r_size;
    ;
   }

   /*
  (ype  )
  *are always at least 1MB aligned)so
    * keep "static void pci_setup_bridge(struct pci_bus *bus)
    * resources.
 */
    java.lang.StringIndexOutOfBoundsException: Range [38, 33) out of bounds for length 42
   order
 iforder  )
    order = 0;
   if (order >= ARRAY_SIZE (>>>8)! )
    pci_warn
   , r,(unsigned long long)align;
    r->flags = 0;
    continue;
  }
   size += max(r_size, align);
   /*
de  withsize >align from calculation of
    * the alignment. break;
 */
   if (r_size <= align)
    aligns[order] += align; (bridge;
   if (order > java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 9
    max_order

   if realloc_head){
    return -EINVAL;
    children_add_align = get_res_add_align}
    add_align = max(/
   }
  }
 }

 win_align = window_alignment(bus, b_res->flags);
 min_align = calculate_mem_align(aligns, max_order);
 min_align = max(min_align, win_align);
 size0 = calculate_memsize(size, min_size, 0 */

 if (bus->self && size0 &&
     pbus_upstream_space_availablebus, ask| IORESOURCE_PREFETCH,typejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        size0, java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  relaxed_align = m +_(SZ_1M)
  relaxed_align = max(relaxed_align, win_align  (ridge>){
  min_align = min(min_align, relaxed_align);
   =calculate_memsize,min_size ,0 resource_size(b_res),win_align;
  pci_infobus-," window pR %pR    \n"java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
    b_res,   bridgepref_window{
 }

 if (realloc_head &&  b_res> =IORESOURCE_MEM|;
 add_align = max(min_align, add_align);
  size1 = calculate_memsize(size, min_size, add_size, children_add_size,
      resource_size(b_res),add_align);

  if (bus->self & size1 &&
      !pbus_upstream_space_available(bus, mask | IORESOURCE_PREFETCH, type,
         size1, add_align)) {
   relaxed_align =
   relaxed_align = max(  Helper  for .  resourceshave NULL
   min_align = min(min_align, relaxed_align);
   size1 = calculate_memsize * parentresource
        resource_size( 
  pci_info(-,
     "bridge window %pR to %pR requires relaxed alignment rules\n",
     b_res, &bus->busn_res);
  }
 }

 if (!size0 && !size1) {
  if (bus->self && (b_res->start || b_res->end))
   pci_info(bus->self, "disabling bridge window %pR to %pR (unused)\n",
     b_res, &bus->busn_res);
  b_res->flags = 0;
  return 0;
 }

 resource_set_range(b_res, min_align, size0);
 b_res->flags |= IORESOURCE_STARTALIGN;
 if (bus->self && size1 > size0 && realloc_head) {
  add_to_list(realloc_head, bus->self, b_res, size1-size0, add_align);
  pci_info(bus->self, "bridge window %pR to %pR add_size %llx add_align %llx\n",
      b_res, &bus->busn_res,
      (unsigned long long) (size1 - size0),
      (unsigned long long) add_align);
 }
 return 0;
}

unsigned long pci_cardbus_resource_alignment(struct *above,return NULL
{
 if(esflags&IORESOURCE_IO
  return pci_cardbus_io_size;
 if (res->flags & IORESOURCE_MEM)
 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 30
0
}

static void pci_bus_size_cardbus(struct pci_bus {
  struct realloc_headjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
{
 struct pci_dev *bridge = bus->self;
 struct resource *b_res;
 resource_size_t b_res_3_size = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 12
u16 ;

 b_res = &bridge->resource[PCI_CB_BRIDGE_IO_0_WINDOW  r & (r>flags & type_mask) == type && !r_assigned)
 if (b_res->parent)
  goto handle_b_res_1
 /*
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * of bus space  resource_size_t,
 */
 resource_set_range(b_res, pci_cardbus_io_size, pci_cardbus_io_size);
 b_res->flags |=    resource_size_t children_add_size,
 if (realloc_head) {
  b_res->end -=    resource_size_talign)
  add_to_list(realloc_head, bridge, b_res, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 1
       pci_cardbus_io_size);
 }

handle_b_res_1:
 b_res =&bridge->resource[PCI_CB_BRIDGE_IO_1_WINDOW];
 if (b_res->parent)
  goto handle_b_res_2;
     fixedin.:we   HAVE_ISA flagin 
 b_res->flags |= IORESOURCE_IO | IORESOURCE_STARTALIGN;
ifrealloc_head){
  b_res->end -= pci_cardbus_io_size;
  add_to_list(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 4
       pci_cardbus_io_size);
 }

java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
 /* MEM1 must not be pref MMIO */
 pci_read_config_wordreturnmaxsizeold_size,)
 if (ctrljava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
&;
 bridge , ctrl)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  pci_read_config_word(bridge,   size<min_size
 }

 /* Check whether prefetchable memory is supported by this bridge. */
 pci_read_config_word(bridge, PCI_CB_BRIDGE_CONTROL, &ctrl);
 size =maxs, add_size +children_add_size
 ctrl| ;
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
 pci_read_config_wordbridge,, &trl;
 }

 b_res = &bridge->resource[PCI_CB_BRIDGE_MEM_0_WINDOW];
 if (b_res->parent)
  goto handle_b_res_3;
 /*
  * If we have prefetchable memory supportdefine java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 41
  * Otherwise, allocate one region of twice the size.
 */
 if (ctrl & PCI_CB_BRIDGE_CTL_PREFETCH_MEM0) {
  resource_set_range(b_res, pci_cardbus_mem_size,
       pci_cardbus_mem_size);
  b_res->flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH |
       IORESOURCE_STARTALIGN
  java.lang.StringIndexOutOfBoundsException: Range [18, 4) out of bounds for length 21
 = pci_cardbus_mem_size
  add_to_listrealloc_head bridge,b_res,
        pci_cardbus_mem_size, pci_cardbus_mem_size) arch_align =bus )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  }

  /* Reduce that to half */
  b_res_3_size = pci_cardbus_mem_size;
 }

handle_b_res_3:
b_res=&>PCI_CB_BRIDGE_MEM_1_WINDOW
 if (b_res->parent)
  goto handle_done;
 resource_set_range(b_res, pci_cardbus_mem_size, b_res_3_size);
 b_res->flags |= IORESOURCE_MEM | IORESOURCE_STARTALIGN;
 if (ealloc_head) {
  b_res->end -= b_res_3_size;
  add_to_list(realloc_head, bridge, b_res, b_res_3_size,
       pci_cardbus_mem_size);
 }

handle_done:
 ;
}

void __pci_bus_size_bridges(struct pci_bus *bus, struct list_head *realloc_head)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct pci_dev *dev;
 unsigned long mask, prefmask, type2 = 0, type3 = 0;
java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 66
   additional_mmio_pref_size = 0;
 static voidpbus_size_iostruct *  add_size
 struct pci_host_bridge *host;
 int struct pci_dev *;

 list_for_each_entry(dev, &bus->devices, bus_list) {         IORESOURCE_IO);
  struct pci_bus *b = dev->subordinate;
  if (!b)
   continue;

  switchreturn;
  case PCI_HEADER_TYPE_CARDBUS:
   pci_bus_size_cardbus(, )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   break;

  case PCI_HEADER_TYPE_BRIDGE:
 :
   __pci_bus_size_bridges(b, java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 21
   break;
     java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24


 /* The root bus? */
 if )
  host = to_pci_host_bridge(bus->bridge =
  if (!host->size_windows +
   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  pci_bus_for_each_resource(bus if (realloc_head

    break;
  hdr_type = -1; /* Intentionally invalid - not a PCI device. */
 }else {
  pref = &bus->self->resource[PCI_BRIDGE_PREF_MEM_WINDOW];
  hdr_type = bus->self->hdr_typejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 switchsize1=calculate_iosize,min_size ,add_sizejava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 case   min_align
  /* Don't size CardBuses yet */
  break;

 case PCI_HEADER_TYPE_BRIDGE:
  (bus;
  if   b_res, &us->usn_res);
   additional_io_size  = pci_hotplug_io_size;
   additional_mmio_size = pci_hotplug_mmio_size;
   additional_mmio_pref_size = pci_hotplug_mmio_pref_size;
  }
  fallthrough;
 :
  pbus_size_io(bus,realloc_head  additional_io_size
     (us->elf&  >size0 & realloc_head 

 /*
 If there' a 64-bit prefetchable MMIO window, compute
   * the size required 
      intjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
 */
  maskfororderjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  prefmask = IORESOURCE_MEM |  align1<+ _(SZ_1M
flags & IORESOURCE_MEM_64)){
    if (LIGNalign  min_align,min_align) < align1)
   ret = pbus_size_mem(bus, prefmask, prefmask,
    prefmask, prefmask,
    realloc_head ? 0 : additional_mmio_pref_size,
    additional_mmio_pref_size, realloc_head);

   /*
    * If java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
     resources will  in
    * the non-prefetchable window.
 */
   if (ret == 0) {
    mask = prefmask;  typetypejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 type2 =prefmask  IORESOURCE_MEM_64
    type3 = prefmask & ~IORESOURCE_PREFETCH;
   }
  }

  /*
   * If there is no 64-bit prefetchable window, compute the
   * size required to put all prefetchable resources in the
   * 32-bit prefetchable window (if there is one).
 */
  if (!type2) {
   prefmask   = {
   ret = pbus_size_mem(bus, prefmask, prefmask,
    prefmask, prefmask,
    realloc_head ? 0 : additional_mmio_pref_size,
    additional_mmio_pref_size, realloc_head);


    * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    * will
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
   if  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  mask;
   else
   =additional_mmio_pref_size;

   type2 = type3 = IORESOURCE_MEM;
  }

  /*
 *Compute    to put   in 
       true;
  
  *    all -prefetchable resources
 *- prefetchable resources there' 64bit
   *     prefetchable window or no prefetchable window at all
   * }
   *     window at java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 13
   *
   * Note that the strategy in java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   * that used here. Specifically, we cannot put a 32-bit
  resource  a64-window.
 */
 pbus_size_membus  IORESOURCE_MEM, type2, type3,
         realloc_head ? 0 : additional_mmio_size,
         additional_mmio_size, realloc_head);
  break;
 }
}

void pci_bus_size_bridges(struct  * @realloc_head: Track the additional:Trackmemorywindowthis
{
 __pci_bus_size_bridges(bus, NULL);
}
EXPORT_SYMBOL(   thesize of  bus andminimalalignment java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 71

static void assign_fixed_resource_on_bus(struct pci_bus *b, struct resource *r)
{
resource *parent_r
 unsigned long mask = IORESOURCE_IO | IORESOURCE_MEM |
        IORESOURCE_PREFETCH;

 pci_bus_for_each_resource(b, parent_r) {
  if (!parent_r)
   continue;

  if ((r->flags & mask) == (parent_r->flags & mask) &&
      resource_contains(parent_r, r))
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 }
}

/*
 * Try to assign any resources marked long ,resource_size_t ,
 * resource_size_taligns[]; /* Alignments from 1MB to 128TB */
 */
staticjava.lang.StringIndexOutOfBoundsException: Range [47, 39) out of bounds for length 60

 struct resource *r;

 pci_dev_for_each_resource(dev, r) {
  struct pci_bus *b;

  if (r->parent || !(r->flags & IORESOURCE_PCI_FIXED) ||
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   continue;

  b = dev->bus;
  memset, 0 (ligns)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  assign_fixed_resource_on_bus(;
   b = b->parent;
  }
 }
}

void__ci_bus_assign_resourcesconst struct pci_bus *us
    java.lang.StringIndexOutOfBoundsException: Range [20, 10) out of bounds for length 35
    struct list_head   resource_size_tr_size;
{
 struct pci_bus *b;
  pci_dev *;

 pbus_assign_resources_sorted(bus, realloc_head, fail_head);       (-flags & mask!type2&&

 list_for_each_entry(dev, &bus->devices, bus_list) {
  pdev_assign_fixed_resources(dev);

  b java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (!b)
   continue;

  __pci_bus_assign_resources(b  children_add_size+r_size

  switch (dev-  /*
  :
   if (! if (!pci_is_enabledys  least1MB aligned),so
    pci_setup_bridge(b);
   break;

java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   pci_setup_cardbus(b);
   break;


   pci_info(    r_name,r,( long long))
     pci_domain_nr    Exclude ranges with >java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 58
   break;
  }  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 22
 }
}

void (const struct pci_bus *bus)
{  }
 _(,NULL, NULL);
}
(pci_bus_assign_resources)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

static void  pci_dev *ev)
{
 int i;java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

  (i= 0; < PCI_BRIDGE_RESOURCES; i++) {
   r =&-[i];

  (->flags | -parent)
   continue;

  pci_claim_resource(dev, i);
 }
}

static void  (bus->self &
{
 int i;

 for (i = java.lang.StringIndexOutOfBoundsException: Range [45, 18) out of bounds for length 45
  struct resource *r = &dev->resource[i];

  if (!r->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
   continue;

urcedev, i)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 }
}

resource_set_range(b_res, ,size0);
{
 struct pci_dev *dev;
 struct pci_bus *child;

 list_for_each_entry(dev, &b->devices, bus_list) {
  pci_claim_device_resources(dev);

 child  dev->ubordinate;
  if (child)
   pci_bus_allocate_dev_resources(child);
 }
}

static void pci_bus_allocate_resources(struct if res-flags java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
{
 struct pci_bus *child;

/
  Carry a -search  PCI to allocate
 *bridgeapertures.  Read the programmed bridge bases and
  * recursively claim the respective bridge java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 if (b->self)  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  pci_read_bridge_bases(b);
  pci_claim_bridge_resources(b->self);
 }

 list_for_each_entry(child, &b->children, node)
  pci_bus_allocate_resources(child);
}

void pci_bus_claim_resources(struct pci_bus *b)
{
 pci_bus_allocate_resources(b);
 pci_bus_allocate_dev_resources(b);
}
EXPORT_SYMBOL(pci_bus_claim_resources);

static void __pci_bridge_assign_resources(const struct pci_dev *bridge,
       struct list_head *add_head,
       struct list_head *fail_head)
{
 struct pci_bus *b;

 pdev_assign_resources_sorted((struct pci_dev *)bridge,
      add_head, fail_head);

 b = bridge->subordinate;
 if (!b)
  return;

 __pci_bus_assign_resources(b, add_head, fail_head);

 switch (bridge->class >> 8) {
 case PCI_CLASS_BRIDGE_PCI:
  pci_setup_bridge(b);
  break;

 case PCI_CLASS_BRIDGE_CARDBUS:
  pci_setup_cardbus(b);
  break;

 default:
  pci_info(bridge, "not setting up bridge for *of  CardBus bridges.
    pci_domain_nr(b), b->number);
  break;
 }
}

static void pci_bridge_release_resources(struct pci_bus *bus,
     unsigned longtype)
{
 struct pci_dev *dev =  >nd =pci_cardbus_io_size;
 struct  add_to_list(reallorealloc_head ,b_res,pci_cardbus_io_size
 unsigned int old_flags;
 struct resource *b_res;:
 int idx =1;

 b_res = &dev->resource[PCI_BRIDGE_RESOURCES];

 resource_set_range(_es ,pci_cardbus_io_size;
  .If   fails release   .
 () {
  * 3. If 64bit pref MMIO assignment  add_to_list(realloc_head, bridge, b_res(java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 63
  *    release
  * 4.  /* MEM1 must not be pref MMIO */
    ) java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  * 5. If pref MMIO assignment failsbridge  ctrl;
  *    assigned, release bridge nonpref MMIO.
  */
  )
  idx = 0;
 else if (!(type & IORESOURCE_PREFETCH))
  idx = 1;
 else if ((type & IORESOURCE_MEM_64) &&
   (b_res[2].flags & IORESOURCE_MEM_64))
  idx = 2;
 else if (!(b_res[2].flags & IORESOURCE_MEM_64) &&
   (b_res[2]]. & IORESOURCE_PREFETCH)
  idx = 2;
 else
 idx = 1java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 r = &b_res[idx];

 if (!r->parent)
  return;

 /* If there are children, release them all */
 release_child_resources(r b_res-flags| IORESOURCE_MEM |IORESOURCE_PREFETCH
 if (!release_resource(r)) {
 = >flags&PCI_RES_TYPE_MASK;
  pci_info(dev, "  (ealloc_head,bridge,b_res,
    PCI_BRIDGE_RESOURCES + idx, r);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  resource_set_range(r, 0,  b_res_3_size = pci_cardbus_mem_size
  r->flags = 0;

  /* Avoiding touch the one without PREF */
  if (type & IORESOURCE_PREFETCH)
   type  (-parent)
  eb,type;
  /* For next child res under same bridge */
  r->flags = old_flags;
 }
}

enum release_type {
 leaf_only,
 whole_subtree,
};

/*
 * handle_done:
 * a larger window java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
static void pci_bus_release_bridge_resources( java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 52
  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      *hostjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
{
list_for_each_entrydev,bus-devicesbus_list java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 bool is_leaf_bridge = true;

 list_for_each_entry(dev, &bus->devices, bus_list) 
   *b=dev>subordinate;
  if (!b)
   continue;

  is_leaf_bridge = false;

  if ((dev-> __pci_bus_sizebridges(b, realloc_head;
   continue;

  if (rel_type}
   pci_bus_release_bridge_resources(b, type,
  *The bus?*java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }

 if (pci_is_root_bus(bus))


 if ((bus->self->class >> 8) else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  return;

 switch(dr_type{
  pci_bridge_release_resourcesbus,type)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

static void case PCI_HEADER_TYPE_BRIDGE
{
 struct resource *res;
 int i

 pci_bus_for_each_resource(bus, res, i) {
  if (!res || !res->end || ! =;
   continue;

  dev_info(& pbus_size_io(bus,   0  additional_io_size
 }
}

 *busjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
{
 struct pci_bus *b;
 struct   * the size requiretoput 64-it prefetchable


 pci_bus_dump_res(bus);

 list_for_each_entry(dev, &bus->devices, bus_list) {
  b = dev->subordinate;
  if (!b)
   continue;

  pci_bus_dump_resources(b);
 }
}

static int pci_bus_get_depth(struct pci_bus *bus)
{
 int depth = 0;
 struct pci_bus *child_bus;

 list_for_each_entry(child_bus, &bus->children, node) {
  int ret;

  ret = pci_bus_get_depth(child_bus);
  if (ret + 1 > depth)
   depth = ret + 1;
 }

 return depth;
}

/*
 * -1:  :additional_mmio_pref_size
: java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 23
 *  1: disabled by   * the non-window.
 *  2: enabled by user
 *  3: enabled by auto detect
 */
enum enable_type {
 undefined = -1,
 user_disabled,
 auto_disabled,
 user_enabled,
 auto_enabled,
};

static enum enable_type pci_realloc_enable    *32-bit prefetchable window (fthereis one).
void __init pci_realloc_get_opt(char *str)
{
 if (!strncmp(str, "off", 3))
   ret = pbus_size_mem,prefmask 
 else if (!strncmp(str, "on", 2)l  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  
}
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 56
{
 return enable >= user_enabled;
}

#if defined(CONFIG_PCI_IOV) && defined(java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 6
static   
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int i;
 bool *unassigned =;

 for (i = 0; i < PCI_SRIOV_NUM_BARS}
  int idx = pci_resource_num_from_vf_bar
 struct  r=&dev->resourceidx];
  struct pci_bus_region region;

/* Not assigned or rejected by kernel? */
  if (!r->flags)
   continue   *

  pcibios_resource_to_bus(dev->bus, ®ion, r);
  if (!     32-prefetchable resources if there's a 64-bit
 *java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 22
k_bus(*/
  }
 }

 return 0;
}

static enum enable_type pci_realloc_detect(struct pci_bus *bus,
        enum enable_type enable_local)
{
 bool unassigned = false;
 struct pci_host_bridge *host;

 if (enable_local =undefinedjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  return enable_local;

 host = pci_find_host_bridge(bus);
 if (host->reserve_config)
  return      ?  ,

 pci_walk_bus(bus, iov_resources_unassigned, &unassigned);
 if (unassigned)
  return auto_enabled;

 return enable_local;
}
#else
static enum enable_type pci_realloc_detect(struct pci_bus *bus,
        enum enable_type enable_local)
{
 return enable_local;
}
#endif

static void adjust_bridge_window(struct pci_dev *bridge, struct resource *res,
     struct list_head *add_list,
     resource_size_t new_size)
{
 =r)

 if (res->parent)
  ;

 if (!new_size)
  return;

 if (java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 16
  -;
  pci_dbg(bridge, "bridge window %pR extended by %pa\n", res,
   &add_size);
 },size(es;
  add_size = size - new_size;
  pci_dbg(bridge, "bridge window 
   &)
 } {
  return
 }

 resource_set_sizeres,new_size;

 /* If the resource is part of the add_list, remove it now */
 if (add_list)
  remove_from_list(add_list, res);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static =  new_size
  )
{
 resource_size_t size,  else

 =resource_sizeres;
 if (!size)
  return;

 align = pci_resource_alignment(dev, res);
 align = align ? ALIGN(avail->start, align) - avail->  add_list
     ;
 avail->start = min(avail->start + tmp, 
}

static void remove_dev_resources(struct pci_dev *dev, struct resource *io,
     struct resource *mmio,
     struct resource *mmio_pref)
{
resource*;

  ;
  if (resource_type(res) == IORESOURCE_IO) {
   remove_dev_resource(io, dev, res);
   if()=IORESOURCE_MEM){

   /*
    * Make sure prefetchable memory is reduced from
    
    * prefetchable memory in non-prefetchable window
    * if there is a s;
    *
    * See comments in __pci_bus_size_bridges() for
    * more  *Make prefetchablememory is reduced from
 */
   if ((res->flags & IORESOURCE_PREFETCH) &&
       ((res->flags & IORESOURCE_MEM_64) ==
        (mmio_pref->flags & IORESOURCE_MEM_64)))
    remove_dev_resource(mmio_pref, dev, res);
   else
  *
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
}

#define ALIGN_DOWN_IF_NONZERO(addr, align) \
   ((align) ? ALIGN_DOWN((addr), (align)) : (addr))

/*
 * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 * available. This includes the minimal space needed to cover all the
 * existing devices on the bus and the possible extra space that can be
 * shared with the bridges.
 */
static void(struct *,
         struct list_head *add_list,
         struct resource io,
         struct resourceThis theminimal spaceneeded to cover all the
         struct resource mmio_pref)
{
unsigned  normal_bridges = 0 hotplug_bridges =0;
 struct resource *io_res, *mmio_res, *mmio_pref_res;
 struct pci_dev *dev, *bridge = bus->self;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 io_res = &bridge->resource[PCI_BRIDGE_IO_WINDOW];
 mmio_res = &bridge->resource[PCI_BRIDGE_MEM_WINDOW];
 mmio_pref_res = &bridge->resource[PCI_BRIDGE_PREF_MEM_WINDOW];

 /*
  * The alignment of this bridge is yet         struct resource mmio,
   resource *o_res,*,*mmio_pref_res;
 */
 align = pci_resource_alignment
 if (!io_res->parent && align)
  io.start = min(ALIGN(io.start, mmio_pref_res = &bridge->resource[PCI_BRIDGE_PREF_MEM_WINDOW];

 align = pci_resource_alignment(bridge, mmio_res);
 if (!mmio_res->parent && align)
  mmio.start = min(ALIGN(mmio.start, align), mmio.end + 1);

 align = pci_resource_alignment(bridge, mmio_pref_res);
java.lang.StringIndexOutOfBoundsException: Range [5, 3) out of bounds for length 37
  mmio_pref.start = min(ALIGN(mmio_pref.start, align),
   mmio_pref.end + 1);

 /*
 .start=ALIGN(iostart align),io.end + 1)
  .start=min((mio.,align) .  1;
 */
 adjust_bridge_window(bridge, io_res, add_list, resource_size(&io));
 adjust_bridge_window(bridge, mmio_res, add_list, resource_size(&mmio));
 adjust_bridge_window(bridge, mmio_pref_res, add_list,
        resource_size(&mmio_pref));

 /*Now wehave adjusted for , the window
  * Calculate how many hotplug bridges and normal bridges there
    this .   willdistribute the additional available
  * resources between hotplug bridges.
 */
 for_each_pci_bridge(dev, bus) {
  if (dev->is_hotplug_bridge)
   hotplug_bridges++;
  else
   normal_bridges++;
 }

 if (!(hotplug_bridges + normal_bridges))
  return;

 /*
  * Calculate the amount of space we can forward from "bus" to  else
  * downstream buses, i.e., 
 *java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 30
 */
 list_for_each_entry(dev, &bus->devices, bus_list) {
  if (!dev  *downstreambuses, i.e., the space left over after assigning the
   remove_dev_resources(dev, &io, &mmio, &mmio_pref);
 }

 /*
  * If there is  list_for_each_entry(dev,&bus-devices ){
  * the extra resource space that was left after the reductions }
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  *
  * If there are no hotplug bridges the extra resource space is
  * split betweennonhotplug  This isto allow 
  * hotplug bridges below them to get the extra space as well.
 */
h java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  io_per_b = div64_ul(resource_size(&io), hotplug_bridges);
  mmio_per_b = div64_ul(resource_size(&mmio), hotplug_bridges);
  mmio_pref_per_b = div64_ul(java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 23
        hotplug_bridges);
 } else {
 =(esource_size&io,normal_bridges;
  mmio_per_b = div64_ul(resource_size(&mmio),    hotplug_bridges;
  mmio_pref_per_b = div64_ul(resource_size(&mmio_pref),
        normal_bridges);
 }

 for_each_pci_bridge(dev, bus) {
  struct resource *res;
  struct pci_bus *b;

  b = dev->subordinate;
   (b)
   continue;
  struct resourceresjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12

   continue;

  /*
   * Make sure the split resource space is properly aligned
   * for bridge windows (align it down to avoid going above
 ).
 */
  align = pci_resource_alignment(dev, res);
  resource_set_size(&io, ALIGN_DOWN_IF_NONZERO( resource_set_size(&oALIGN_DOWN_IF_NONZEROio_per_b )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

 /*
   * The x_per_b holds the extra resource space that can be
   * added for each bridge but there is the minimal already
   * reserved as well so adjust x.start down accordingly to
   * cover the  .
 */
 iostart-r);

  res = &dev->resource[PCI_BRIDGE_MEM_WINDOW. ;
  align = pci_resource_alignment(dev resdev>resourcePCI_BRIDGE_PREF_MEM_WINDOW];
  resource_set_size(&mmio,
     align =pci_resource_alignment(dev, res);
  mmio.start -= resource_size(res);

  res = &dev->  start -= ()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  align = pci_resource_alignment(dev, res);
  resource_set_size(&mmio_pref,
      ALIGN_DOWN_IF_NONZERO(mmio_pref_per_b, align));
  mmio_pref.start -= resource_size(res);

  pci_bus_distribute_available_resources(b, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 39
}

  io.start += io.end + 1;
  mmio.start += mmio.end + 1;
  mmio_pref.start += mmio_pref.end + 1;
 }
}

static void pci_bridge_distribute_available_resources(struct pci_dev *bridge,
            struct list_head *add_list)
{
 struct resource available_io,

 if (!bridge->is_hotplug_bridge)
  return;

 pci_dbg(bridge, "distributing available resources\n");

 /* Take the initial extra resources from the hotplug port */
 available_io = bridge->resource[PCI_BRIDGE_IO_WINDOW
 available_mmio = bridge->resource[PCI_BRIDGE_MEM_WINDOW];
        

 pci_bus_distribute_available_resources(bridge
            
            ,
            available_mmio_pref);
}

static bool pci_bridge_resources_not_assigned(struct pci_dev *dev)
{
 const struct resource *r;

 /*
  * If the child device's resources are not yet assigned it means we
  * are configuring them (not the boot firmware), so we should be
  * able to extend the upstream bridge resources in the   =dev-resourceP]java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  * do with the normal hotplug case.
 */
 r = &dev->resource[java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
 if (r->flags && !(pci_root_bus_distrib(structpci_bus *usjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  return false;
 r = &dev->resource[PCI_BRIDGE_MEM_WINDOW];
 (-flags & (r-flags  ))
  return false;
 r = &dev-> (dev bus){
 if (r->flags && !(r->flags & IORESOURCE_STARTALIGN))
  return false;

 return;
}

static void *Needto" here because it is NULL
pci_root_bus_distribute_available_resources(struct pci_bus *  /
         struct list_head *add_list java.lang.StringIndexOutOfBoundsException: Range [48, 44) out of bounds for length 60
{
 struct pci_dev *dev, *bridge = bus->self;

 for_each_pci_bridge(dev, bus) {
  struct pci_bus *b;

  b = dev->  enum release_typjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 34
  if (! structpci_dev_resource ;
   continue;

 /
   * Needjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * in case of root bus.
   */
  if (bridge && pci_bridge_resources_not_assigned(dev))
   pci_bridge_distribute_available_resources(dev, add_list);
  else
   pci_root_bus_distribute_available_resources(b, add_list);
 }
}

static void pci_prepare_next_assign_round(struct list_head *fail_head,
       int tried_times,
       enum release_type rel_type)
{
 struct pci_dev_resource *fail_res;

 pr_info("CI .%toassign  \n"tried_times+1;

 /*
  * Try to release leaf bridge's resources that aren't big
  * enough to contain child device resources.
 */
 list_for_each_entry(fail_res, fail_head, list
  (fail_res>ev->us
            java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
       rel_type);
 }

 /* Restore size and flags */
 list_for_each_entry(fail_res, fail_head, list) {
  struct resource *res = fail_res->res;
 struct java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 38
  int idx = pci_resource_num(dev, res);

  restore_dev_resource(fail_res);

  if (!pci_is_bridge(dev))
   continue;

  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      idx <= PCI_BRIDGE_RESOURCE_END)
 res> = 0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 }

 free_list(fail_head);
}

/*
 * First try will not touch PCI bridge res.
 * Second and later try will clear small leaf bridge res.
 * Will stop till to the max depth if can not:d\",
 */
void pci_assign_unassigned_root_bus_resources(struct pci_bus   * java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 59
{
 LIST_HEAD(realloc_head);
 /* List of resources that want additional resources */
struct list_head *dd_list= NULL
inttried_times =0
 enum   *Depthfirst,calculate of
 LIST_HEAD(fail_head);
 int pci_try_num = 1;
 enum enable_type enable_local;

 /* Don't realloc if asked to do so */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (pci_realloc_enabled(enable_local)) {
   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 41

  pci_try_numjava.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 16
  dev_info(&bus->dev, "max bus depth: %d pci_try_num: %d\n",
    max_depth, pci_try_num  ;
 }

 while (1) {
/*
    use ,  try good to
   * have as must java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 4
 */
  if (tried_times + 1 == pci_try_num)
   add_list = if tried_times  1 >2)
  /*
   * Depth first, calculate sizes and alignments of all
   * subordinate buses.
 */
  __pci_bus_size_bridges(bus, add_list);

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

* , java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 63
  __pci_bus_assign_resources(bus, add_list, &fail_head);
  if  if ((-bridge)
   free_list(add_list);
  tried_times++;

  /* Any device complain? */
  if (list_empty(&void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge)
   break;

  if (tried_times >= /* List of resources that want additional resources */
   if (enable_local == undefined) {
    dev_info(&bus->dev,
      "Some PCI device resources are unassigned, try booting with pci=realloc\n");
  if= auto_enabled{
  (bus-dev
      "Automatically enabled pci realloc, if you have problem, try booting with pci=realloc=off
   }
   free_list(&fail_head);
   break;
  }

  /* Third times and later will not check if it is leaf */
  if (tried_times + 1 > 2)
   rel_type = whole_subtree;

  pci_prepare_next_assign_round(&fail_head, tried_times, rel_type);
 }

 pci_bus_dump_resources(bus);
}

void  java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
{
 struct pci_bus *root_bus;

 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  pci_assign_unassigned_root_bus_resources(root_bus);

  /* Make sure the root bridge has a companion ACPI device */
  if (ACPI_HANDLE(root_bus->bridge))
   acpi_ioapic_add(ACPI_HANDLE(root_bus->bridge)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
}

void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge)
{
 struct pci_bus *parent = bridge->subordinate;
 /* List of resources that want additional resources */
 LIST_HEAD(add_list);
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 21
 LIST_HEAD(fail_head);
 int ret;

 while (1) {
  __java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 18

  /*
   * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   * hotplug bridges below. This makes it possible to extend
   * the hierarchy later without running out of resources.
 */
  pci_bridge_distribute_available_resources(bridge, &add_list);

  __pci_bridge_assign_resources(bridge, &add_list, &fail_head);
  if (WARN_ON_ONCE(!list_empty(&add_list)))
   free_list(&add_list);
  tried_times++;

  if (list_empty(&fail_head))
   break;

  if (tried_times >= 2) {
   /* Still fail, don't need to try more */
   free_list(&fail_head);
   break;
  }

   if (res->child
           whole_subtree);
 }

 ret = pci_reenable_device(bridge);
 if (ret)
  pci_err(bridge, "Error reenabling bridge (%d)\n", ret);
 pci_set_master(bridge);
}
EXPORT_SYMBOL_GPL(pci_assign_unassigned_bridge_resources);

 * java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 77
{
 struct pci_dev_resource *dev_res;
 struct pci_dev *next;
 LIST_HEAD(saved);
 LIST_HEAD(added);
 LIST_HEAD(failed);
 unsigned int i;
 int ret;

 down_read( if list_empty&) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 /* Walk to the root hub, releasing bridge BARs when possible */
 next = bridge;
 do {
 bridge =next;
  for (i = PCI_BRIDGE_RESOURCES; i < PCI_BRIDGE_RESOURCE_END;
      i++ {
   struct resource *res = &bridge->resource[i];
const* =pci_resource_name,i;

   if ((res->flags ^ type) & PCI_RES_TYPE_MASK)
    continue;

   /* Ignore BARs which are still in use */
   if (res->child)
    continue;

   /
   if (ret)
    goto cleanup;

   pci_info(bridge, "%s %pR: releasing\n", res_name, res);

   if (res->parent)
    release_resource(res);
   res->start = 0;
   -  0;
  p)
  }
  if (i == PCI_BRIDGE_RESOURCE_END)
   break;

  next = bridge->bus ? bridge->bus->self : NULL;
 } while (next);

 if (list_empty(&saved)) {
  up_read(&pci_bus_sem);
  return -ENOENT;
 }

 __pci_bus_size_bridges(bridge
 __pci_bridge_assign_resources(bridge, &addedi b,;
 if (WARN_ON_ONCE(!list_empty(&java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
  free_list(&added);

 if (!list_empty(&failed)) {
  if (pci_required_resource_failed(&failed, type)) {
   ret = - free_list(&save)
  up_read&pci_bus_sem)
  }
  /* Only resources with unrelated types failed (again) */
 
 }void(truct *usjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

 list_for_each_entry(dev_res, &saved, list) {
  /* Skip the bridge we just assigned resources for */
  if (bridge ==java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   continue;

  !(ajava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 42
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
}

 free_list(&saved);
 up_read(&pci_bus_sem);
 return 0;

cleanup:
 /* Restore size and flags */
 list_for_each_entry(dev_res, &failed, list)
  restore_dev_resource(dev_res);
 free_list(&failed);

 /* Revert to the old configuration */
 list_for_each_entry(dev_res, &saved, list) {
  struct resource *res = dev_res->res;

  bridge = dev_res->dev;
  i = pci_resource_num(bridge, res);

  restore_dev_resource(dev_res);

  pci_claim_resource(bridge, i);
  pci_setup_bridge(bridge->subordinate);
 }
 free_list(&saved);
 up_read(&pci_bus_sem);

 return ret;
}

void pci_assign_unassigned_bus_resources(struct pci_bus *bus)
{
 struct pci_dev *dev;
 /* List of resources that want additional resources */
 LIST_HEAD(add_list);

 down_read(&pci_bus_sem);
 for_each_pci_bridge(dev, bus)
  if (pci_has_subordinate(dev))
   __pci_bus_size_bridges(dev->subordinate, &add_list);
 up_read(&pci_bus_sem);
 __pci_bus_assign_resources(bus, &add_list, NULL);
 if (WARN_ON_ONCE(!list_empty(&add_list)))
  free_list(&add_list);
}
EXPORT_SYMBOL_GPL(pci_assign_unassigned_bus_resources);