diff options
Diffstat (limited to 'src/device')
| -rw-r--r-- | src/device/resource_allocator_v4.c | 145 |
1 files changed, 135 insertions, 10 deletions
diff --git a/src/device/resource_allocator_v4.c b/src/device/resource_allocator_v4.c index b65fc8bf37..ae3c764c4c 100644 --- a/src/device/resource_allocator_v4.c +++ b/src/device/resource_allocator_v4.c @@ -104,6 +104,19 @@ static void update_bridge_resource(const struct device *bridge, struct resource bridge_res->limit = child_res->limit; /* + * Propagate the downstream resource request to allocate above 4G boundary to + * upstream bridge resource. This ensures that during pass 2, the resource + * allocator at domain level has a global view of all the downstream device + * requirements and thus address space is allocated as per updated flags in the + * bridge resource. + * + * Since the bridge resource is a single window, all the downstream resources of + * this bridge resource will be allocated space above 4G boundary. + */ + if (child_res->flags & IORESOURCE_ABOVE_4G) + bridge_res->flags |= IORESOURCE_ABOVE_4G; + + /* * Alignment value of 0 means that the child resource has no alignment * requirements and so the base value remains unchanged here. */ @@ -207,22 +220,119 @@ static unsigned char get_alignment_by_resource_type(const struct resource *res) die("Unexpected resource type: flags(%d)!\n", res->flags); } -static void initialize_memranges(struct memranges *ranges, const struct resource *res, - unsigned long memrange_type) +/* + * If the resource is NULL or if the resource is not assigned, then it cannot be used for + * allocation for downstream devices. + */ +static bool is_resource_invalid(const struct resource *res) +{ + return (res == NULL) || !(res->flags & IORESOURCE_ASSIGNED); +} + +static void initialize_domain_io_resource_memranges(struct memranges *ranges, + const struct resource *res, + unsigned long memrange_type) +{ + memranges_insert(ranges, res->base, res->limit - res->base + 1, memrange_type); +} + +static void initialize_domain_mem_resource_memranges(struct memranges *ranges, + const struct resource *res, + unsigned long memrange_type) { resource_t res_base; resource_t res_limit; + + const resource_t limit_4g = 0xffffffff; + + res_base = res->base; + res_limit = res->limit; + + /* + * Split the resource into two separate ranges if it crosses the 4G boundary. Memrange + * type is set differently to ensure that memrange does not merge these two ranges. For + * the range above 4G boundary, given memrange type is ORed with IORESOURCE_ABOVE_4G. + */ + if (res_base <= limit_4g) { + + resource_t range_limit; + + /* Clip the resource limit at 4G boundary if necessary. */ + range_limit = MIN(res_limit, limit_4g); + memranges_insert(ranges, res_base, range_limit - res_base + 1, memrange_type); + + /* + * If the resource lies completely below the 4G boundary, nothing more needs to + * be done. + */ + if (res_limit <= limit_4g) + return; + + /* + * If the resource window crosses the 4G boundary, then update res_base to add + * another entry for the range above the boundary. + */ + res_base = limit_4g + 1; + } + + if (res_base > res_limit) + return; + + /* + * If resource lies completely above the 4G boundary or if the resource was clipped to + * add two separate ranges, the range above 4G boundary has the resource flag + * IORESOURCE_ABOVE_4G set. This allows domain to handle any downstream requests for + * resource allocation above 4G differently. + */ + memranges_insert(ranges, res_base, res_limit - res_base + 1, + memrange_type | IORESOURCE_ABOVE_4G); +} + +/* + * This function initializes memranges for domain device. If the resource crosses 4G boundary, + * then this function splits it into two ranges -- one for the window below 4G and the other for + * the window above 4G. The latter range has IORESOURCE_ABOVE_4G flag set to satisfy resource + * requests from downstream devices for allocations above 4G. + */ +static void initialize_domain_memranges(struct memranges *ranges, const struct resource *res, + unsigned long memrange_type) +{ unsigned char align = get_alignment_by_resource_type(res); memranges_init_empty_with_alignment(ranges, NULL, 0, align); - if ((res == NULL) || !(res->flags & IORESOURCE_ASSIGNED)) + if (is_resource_invalid(res)) return; - res_base = res->base; - res_limit = res->limit; + if (res->flags & IORESOURCE_IO) + initialize_domain_io_resource_memranges(ranges, res, memrange_type); + else + initialize_domain_mem_resource_memranges(ranges, res, memrange_type); +} - memranges_insert(ranges, res_base, res_limit - res_base + 1, memrange_type); +/* + * This function initializes memranges for bridge device. Unlike domain, bridge does not need to + * care about resource window crossing 4G boundary. This is handled by the resource allocator at + * domain level to ensure that all downstream bridges are allocated space either above or below + * 4G boundary as per the state of IORESOURCE_ABOVE_4G for the respective bridge resource. + * + * So, this function creates a single range of the entire resource window available for the + * bridge resource. Thus all downstream resources of the bridge for the given resource type get + * allocated space from the same window. If there is any downstream resource of the bridge which + * requests allocation above 4G, then all other downstream resources of the same type under the + * bridge get allocated above 4G. + */ +static void initialize_bridge_memranges(struct memranges *ranges, const struct resource *res, + unsigned long memrange_type) +{ + unsigned char align = get_alignment_by_resource_type(res); + + memranges_init_empty_with_alignment(ranges, NULL, 0, align); + + if (is_resource_invalid(res)) + return; + + memranges_insert(ranges, res->base, res->limit - res->base + 1, memrange_type); } static void print_resource_ranges(const struct memranges *ranges) @@ -360,10 +470,12 @@ static void setup_resource_ranges(const struct device *dev, const struct resourc dev_path(dev), resource2str(res), res->base, res->size, res->align, res->gran, res->limit); - initialize_memranges(ranges, res, type); - - if (dev->path.type == DEVICE_PATH_DOMAIN) + if (dev->path.type == DEVICE_PATH_DOMAIN) { + initialize_domain_memranges(ranges, res, type); constrain_domain_resources(dev, ranges, type); + } else { + initialize_bridge_memranges(ranges, res, type); + } print_resource_ranges(ranges); } @@ -469,12 +581,25 @@ static void allocate_domain_resources(const struct device *domain) * Domain does not distinguish between mem and prefmem resources. Thus, the resource * allocation at domain level considers mem and prefmem together when finding the best * fit based on the biggest resource requirement. + * + * However, resource requests for allocation above 4G boundary need to be handled + * separately if the domain resource window crosses this boundary. There is a single + * window for resource of type IORESOURCE_MEM. When creating memranges, this resource + * is split into two separate ranges -- one for the window below 4G boundary and other + * for the window above 4G boundary (with IORESOURCE_ABOVE_4G flag set). Thus, when + * allocating child resources, requests for below and above the 4G boundary are handled + * separately by setting the type_mask and type_match to allocate_child_resources() + * accordingly. */ res = find_domain_resource(domain, IORESOURCE_MEM); if (res) { setup_resource_ranges(domain, res, IORESOURCE_MEM, &ranges); - allocate_child_resources(domain->link_list, &ranges, IORESOURCE_TYPE_MASK, + allocate_child_resources(domain->link_list, &ranges, + IORESOURCE_TYPE_MASK | IORESOURCE_ABOVE_4G, IORESOURCE_MEM); + allocate_child_resources(domain->link_list, &ranges, + IORESOURCE_TYPE_MASK | IORESOURCE_ABOVE_4G, + IORESOURCE_MEM | IORESOURCE_ABOVE_4G); cleanup_resource_ranges(domain, &ranges, res); } |