lkml.org 
[lkml]   [2012]   [Jan]   [21]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH 11/21] PCI: Replace resource_list with generic list
Date
So we can use helper functions for generic list.

-v2: Use list_add_tail instead of adding list_insert_before,
Pointed out by Linus.

Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
---
drivers/pci/setup-bus.c | 372 +++++++++++++++++++++++------------------------
1 files changed, 181 insertions(+), 191 deletions(-)
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index b067a4c..4c5509e 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -27,14 +27,14 @@
#include <linux/slab.h>
#include "pci.h"

-struct resource_list {
- struct resource_list *next;
+struct pci_dev_resource {
+ struct list_head list;
struct resource *res;
struct pci_dev *dev;
};

-struct resource_list_x {
- struct resource_list_x *next;
+struct pci_dev_resource_x {
+ struct list_head list;
struct resource *res;
struct pci_dev *dev;
resource_size_t start;
@@ -44,14 +44,12 @@ struct resource_list_x {
unsigned long flags;
};

-#define free_list(type, head) do { \
- struct type *list, *tmp; \
- for (list = (head)->next; list;) { \
- tmp = list; \
- list = list->next; \
- kfree(tmp); \
- } \
- (head)->next = NULL; \
+#define free_list(type, head) do { \
+ struct type *dev_res, *tmp; \
+ list_for_each_entry_safe(dev_res, tmp, head, list) { \
+ list_del(&dev_res->list); \
+ kfree(dev_res); \
+ } \
} while (0)

int pci_realloc_enable = 0;
@@ -70,21 +68,18 @@ void pci_realloc(void)
* @add_size: additional size to be optionally added
* to the resource
*/
-static int add_to_list(struct resource_list_x *head,
+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 resource_list_x *list = head;
- struct resource_list_x *ln = list->next;
- struct resource_list_x *tmp;
+ struct pci_dev_resource_x *tmp;

- tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
+ tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
if (!tmp) {
pr_warning("add_to_list: kmalloc() failed!\n");
return -ENOMEM;
}

- tmp->next = ln;
tmp->res = res;
tmp->dev = dev;
tmp->start = res->start;
@@ -92,12 +87,13 @@ static int add_to_list(struct resource_list_x *head,
tmp->flags = res->flags;
tmp->add_size = add_size;
tmp->min_align = min_align;
- list->next = tmp;
+
+ list_add(&tmp->list, head);

return 0;
}

-static void add_to_failed_list(struct resource_list_x *head,
+static void add_to_failed_list(struct list_head *head,
struct pci_dev *dev, struct resource *res)
{
add_to_list(head, dev, res,
@@ -105,53 +101,48 @@ static void add_to_failed_list(struct resource_list_x *head,
0 /* dont care */);
}

-static void remove_from_list(struct resource_list_x *realloc_head,
+static void remove_from_list(struct list_head *realloc_head,
struct resource *res)
{
- struct resource_list_x *prev, *tmp, *list;
+ struct pci_dev_resource_x *dev_res_x, *tmp;

- prev = realloc_head;
- for (list = realloc_head->next; list;) {
- if (list->res != res) {
- prev = list;
- list = list->next;
- continue;
+ list_for_each_entry_safe(dev_res_x, tmp, realloc_head, list) {
+ if (dev_res_x->res == res) {
+ list_del(&dev_res_x->list);
+ kfree(dev_res_x);
+ break;
}
- tmp = list;
- prev->next = list = list->next;
- kfree(tmp);
}
}

-static resource_size_t get_res_add_size(struct resource_list_x *realloc_head,
+static resource_size_t get_res_add_size(struct list_head *realloc_head,
struct resource *res)
{
- struct resource_list_x *list;
+ struct pci_dev_resource_x *dev_res_x;

- /* check if it is in realloc_head list */
- for (list = realloc_head->next; list && list->res != res;
- list = list->next)
- ;
-
- if (list) {
- dev_printk(KERN_DEBUG, &list->dev->dev,
- "%pR get_res_add_size add_size %llx\n",
- list->res, (unsigned long long)list->add_size);
- return list->add_size;
+ list_for_each_entry(dev_res_x, realloc_head, list) {
+ if (dev_res_x->res == res) {
+ dev_printk(KERN_DEBUG, &dev_res_x->dev->dev,
+ "%pR get_res_add_size add_size %llx\n",
+ dev_res_x->res,
+ (unsigned long long)dev_res_x->add_size);
+ return dev_res_x->add_size;
+ }
}

return 0;
}

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

for (i = 0; i < PCI_NUM_RESOURCES; i++) {
struct resource *r;
- struct resource_list *list, *tmp;
+ struct pci_dev_resource *dev_res, *tmp;
resource_size_t r_align;
+ struct list_head *n;

r = &dev->resource[i];

@@ -167,30 +158,34 @@ static void pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
i, r);
continue;
}
- for (list = head; ; list = list->next) {
- resource_size_t align = 0;
- struct resource_list *ln = list->next;

- if (ln)
- align = pci_resource_alignment(ln->dev, ln->res);
+ tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
+ if (!tmp)
+ panic("pdev_sort_resources(): "
+ "kmalloc() failed!\n");
+ tmp->res = r;
+ tmp->dev = dev;
+
+ /* 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) {
- tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
- if (!tmp)
- panic("pdev_sort_resources(): "
- "kmalloc() failed!\n");
- tmp->next = ln;
- tmp->res = r;
- tmp->dev = dev;
- list->next = tmp;
+ n = &dev_res->list;
break;
}
}
+ /* Insert it just before n*/
+ list_add_tail(&tmp->list, n);
}
}

static void __dev_sort_resources(struct pci_dev *dev,
- struct resource_list *head)
+ struct list_head *head)
{
u16 class = dev->class >> 8;

@@ -228,49 +223,53 @@ static inline void reset_resource(struct resource *res)
* additional resources for the element, provided the element
* is in the head list.
*/
-static void reassign_resources_sorted(struct resource_list_x *realloc_head,
- struct resource_list *head)
+static void reassign_resources_sorted(struct list_head *realloc_head,
+ struct list_head *head)
{
struct resource *res;
- struct resource_list_x *list, *tmp, *prev;
- struct resource_list *hlist;
+ struct pci_dev_resource_x *dev_res_x, *tmp;
+ struct pci_dev_resource *dev_res;
resource_size_t add_size;
int idx;

- prev = realloc_head;
- for (list = realloc_head->next; list;) {
- res = list->res;
+ list_for_each_entry_safe(dev_res_x, tmp, realloc_head, list) {
+ bool found_match = false;
+
+ res = dev_res_x->res;
/* skip resource that has been reset */
if (!res->flags)
goto out;

/* skip this resource if not found in head list */
- for (hlist = head->next; hlist && hlist->res != res;
- hlist = hlist->next);
- if (!hlist) { /* just skip */
- prev = list;
- list = list->next;
- continue;
+ list_for_each_entry(dev_res, head, list) {
+ if (dev_res->res == res) {
+ found_match = true;
+ break;
+ }
}
+ if (!found_match)/* just skip */
+ continue;

- idx = res - &list->dev->resource[0];
- add_size=list->add_size;
+ idx = res - &dev_res_x->dev->resource[0];
+ add_size = dev_res_x->add_size;
if (!resource_size(res)) {
- res->start = list->start;
+ res->start = dev_res_x->start;
res->end = res->start + add_size - 1;
- if(pci_assign_resource(list->dev, idx))
+ if (pci_assign_resource(dev_res_x->dev, idx))
reset_resource(res);
} else {
- resource_size_t align = list->min_align;
- res->flags |= list->flags & (IORESOURCE_STARTALIGN|IORESOURCE_SIZEALIGN);
- if (pci_reassign_resource(list->dev, idx, add_size, align))
- dev_printk(KERN_DEBUG, &list->dev->dev, "failed to add optional resources res=%pR\n",
+ resource_size_t align = dev_res_x->min_align;
+ res->flags |= dev_res_x->flags &
+ (IORESOURCE_STARTALIGN|IORESOURCE_SIZEALIGN);
+ if (pci_reassign_resource(dev_res_x->dev, idx,
+ add_size, align))
+ dev_printk(KERN_DEBUG, &dev_res_x->dev->dev,
+ "failed to add optional resources res=%pR\n",
res);
}
out:
- tmp = list;
- prev->next = list = list->next;
- kfree(tmp);
+ list_del(&dev_res_x->list);
+ kfree(dev_res_x);
}
}

@@ -284,34 +283,36 @@ out:
* Satisfy resource requests of each element in the list. Add
* requests that could not satisfied to the failed_list.
*/
-static void assign_requested_resources_sorted(struct resource_list *head,
- struct resource_list_x *fail_head)
+static void assign_requested_resources_sorted(struct list_head *head,
+ struct list_head *fail_head)
{
struct resource *res;
- struct resource_list *list;
+ struct pci_dev_resource *dev_res;
int idx;

- for (list = head->next; list; list = list->next) {
- res = list->res;
- idx = res - &list->dev->resource[0];
- if (resource_size(res) && pci_assign_resource(list->dev, idx)) {
- if (fail_head && !pci_is_root_bus(list->dev->bus)) {
+ list_for_each_entry(dev_res, head, list) {
+ res = dev_res->res;
+ idx = res - &dev_res->dev->resource[0];
+ if (resource_size(res) &&
+ pci_assign_resource(dev_res->dev, idx)) {
+ if (fail_head && !pci_is_root_bus(dev_res->dev->bus)) {
/*
* if the failed res is for ROM BAR, and it will
* be enabled later, don't add it to the list
*/
if (!((idx == PCI_ROM_RESOURCE) &&
(!(res->flags & IORESOURCE_ROM_ENABLE))))
- add_to_failed_list(fail_head, list->dev, res);
+ add_to_failed_list(fail_head,
+ dev_res->dev, res);
}
reset_resource(res);
}
}
}

-static void __assign_resources_sorted(struct resource_list *head,
- struct resource_list_x *realloc_head,
- struct resource_list_x *fail_head)
+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.
@@ -322,53 +323,55 @@ static void __assign_resources_sorted(struct resource_list *head,
* if could not do that, we still try to assign requested at first,
* then try to reassign add_size for some resources.
*/
- struct resource_list_x save_head, local_fail_head, *list;
- struct resource_list *l;
+ LIST_HEAD(save_head);
+ LIST_HEAD(local_fail_head);
+ struct pci_dev_resource_x *dev_res_x;
+ struct pci_dev_resource *dev_res;

/* Check if optional add_size is there */
- if (!realloc_head || !realloc_head->next)
+ if (!realloc_head || list_empty(realloc_head))
goto requested_and_reassign;

/* Save original start, end, flags etc at first */
- save_head.next = NULL;
- for (l = head->next; l; l = l->next)
- if (add_to_list(&save_head, l->dev, l->res, 0, 0)) {
- free_list(resource_list_x, &save_head);
+ list_for_each_entry(dev_res, head, list) {
+ if (add_to_list(&save_head, dev_res->dev, dev_res->res, 0, 0)) {
+ free_list(pci_dev_resource_x, &save_head);
goto requested_and_reassign;
}
+ }

/* Update res in head list with add_size in realloc_head list */
- for (l = head->next; l; l = l->next)
- l->res->end += get_res_add_size(realloc_head, l->res);
+ list_for_each_entry(dev_res, head, list)
+ dev_res->res->end += get_res_add_size(realloc_head,
+ dev_res->res);

/* Try updated head list with add_size added */
- local_fail_head.next = NULL;
assign_requested_resources_sorted(head, &local_fail_head);

/* all assigned with add_size ? */
- if (!local_fail_head.next) {
+ if (list_empty(&local_fail_head)) {
/* Remove head list from realloc_head list */
- for (l = head->next; l; l = l->next)
- remove_from_list(realloc_head, l->res);
- free_list(resource_list_x, &save_head);
- free_list(resource_list, head);
+ list_for_each_entry(dev_res, head, list)
+ remove_from_list(realloc_head, dev_res->res);
+ free_list(pci_dev_resource_x, &save_head);
+ free_list(pci_dev_resource, head);
return;
}

- free_list(resource_list_x, &local_fail_head);
+ free_list(pci_dev_resource_x, &local_fail_head);
/* Release assigned resource */
- for (l = head->next; l; l = l->next)
- if (l->res->parent)
- release_resource(l->res);
+ list_for_each_entry(dev_res, head, list)
+ if (dev_res->res->parent)
+ release_resource(dev_res->res);
/* Restore start/end/flags from saved list */
- for (list = save_head.next; list; list = list->next) {
- struct resource *res = list->res;
+ list_for_each_entry(dev_res_x, &save_head, list) {
+ struct resource *res = dev_res_x->res;

- res->start = list->start;
- res->end = list->end;
- res->flags = list->flags;
+ res->start = dev_res_x->start;
+ res->end = dev_res_x->end;
+ res->flags = dev_res_x->flags;
}
- free_list(resource_list_x, &save_head);
+ free_list(pci_dev_resource_x, &save_head);

requested_and_reassign:
/* Satisfy the must-have resource requests */
@@ -378,29 +381,27 @@ requested_and_reassign:
requests */
if (realloc_head)
reassign_resources_sorted(realloc_head, head);
- free_list(resource_list, head);
+ free_list(pci_dev_resource, head);
}

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

- head.next = NULL;
__dev_sort_resources(dev, &head);
__assign_resources_sorted(&head, add_head, fail_head);

}

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

- head.next = NULL;
list_for_each_entry(dev, &bus->devices, bus_list)
__dev_sort_resources(dev, &head);

@@ -713,7 +714,7 @@ static resource_size_t calculate_memsize(resource_size_t size,
* We must be careful with the ISA aliasing though.
*/
static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
- resource_size_t add_size, struct resource_list_x *realloc_head)
+ resource_size_t add_size, struct list_head *realloc_head)
{
struct pci_dev *dev;
struct resource *b_res = find_free_bus_resource(bus, IORESOURCE_IO);
@@ -781,7 +782,7 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
unsigned long type, resource_size_t min_size,
resource_size_t add_size,
- struct resource_list_x *realloc_head)
+ struct list_head *realloc_head)
{
struct pci_dev *dev;
resource_size_t min_align, align, size, size0, size1;
@@ -891,7 +892,7 @@ unsigned long pci_cardbus_resource_alignment(struct resource *res)
}

static void pci_bus_size_cardbus(struct pci_bus *bus,
- struct resource_list_x *realloc_head)
+ struct list_head *realloc_head)
{
struct pci_dev *bridge = bus->self;
struct resource *b_res = &bridge->resource[PCI_BRIDGE_RESOURCES];
@@ -953,7 +954,7 @@ static void pci_bus_size_cardbus(struct pci_bus *bus,
}

void __ref __pci_bus_size_bridges(struct pci_bus *bus,
- struct resource_list_x *realloc_head)
+ struct list_head *realloc_head)
{
struct pci_dev *dev;
unsigned long mask, prefmask;
@@ -1024,8 +1025,8 @@ void __ref pci_bus_size_bridges(struct pci_bus *bus)
EXPORT_SYMBOL(pci_bus_size_bridges);

static void __ref __pci_bus_assign_resources(const struct pci_bus *bus,
- struct resource_list_x *realloc_head,
- struct resource_list_x *fail_head)
+ struct list_head *realloc_head,
+ struct list_head *fail_head)
{
struct pci_bus *b;
struct pci_dev *dev;
@@ -1064,8 +1065,8 @@ void __ref pci_bus_assign_resources(const struct pci_bus *bus)
EXPORT_SYMBOL(pci_bus_assign_resources);

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

@@ -1249,20 +1250,18 @@ void __init
pci_assign_unassigned_resources(void)
{
struct pci_bus *bus;
- struct resource_list_x realloc_list; /* list of resources that
+ LIST_HEAD(realloc_head); /* list of resources that
want additional resources */
- struct resource_list_x *add_list = NULL;
+ struct list_head *add_list = NULL;
int tried_times = 0;
enum release_type rel_type = leaf_only;
- struct resource_list_x head, *list;
+ LIST_HEAD(fail_head);
+ struct pci_dev_resource_x *dev_res_x;
unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM |
IORESOURCE_PREFETCH;
unsigned long failed_type;
int pci_try_num = 1;

- head.next = NULL;
- realloc_list.next = NULL;
-
/* don't realloc if asked to do so */
if (pci_realloc_enabled()) {
int max_depth = pci_get_max_depth();
@@ -1278,7 +1277,7 @@ again:
* must have, so can realloc parent bridge resource
*/
if (tried_times + 1 == pci_try_num)
- add_list = &realloc_list;
+ add_list = &realloc_head;
/* Depth first, calculate sizes and alignments of all
subordinate buses. */
list_for_each_entry(bus, &pci_root_buses, node)
@@ -1286,27 +1285,26 @@ again:

/* Depth last, allocate resources and update the hardware. */
list_for_each_entry(bus, &pci_root_buses, node)
- __pci_bus_assign_resources(bus, add_list, &head);
+ __pci_bus_assign_resources(bus, add_list, &fail_head);
if (add_list)
- BUG_ON(add_list->next);
+ BUG_ON(!list_empty(add_list));
tried_times++;

/* any device complain? */
- if (!head.next)
+ if (list_empty(&fail_head))
goto enable_and_dump;

failed_type = 0;
- for (list = head.next; list;) {
- failed_type |= list->flags;
- list = list->next;
- }
+ list_for_each_entry(dev_res_x, &fail_head, list)
+ failed_type |= dev_res_x->flags;
+
/*
* io port are tight, don't try extra
* or if reach the limit, don't want to try more
*/
failed_type &= type_mask;
if ((failed_type == IORESOURCE_IO) || (tried_times >= pci_try_num)) {
- free_list(resource_list_x, &head);
+ free_list(pci_dev_resource_x, &fail_head);
goto enable_and_dump;
}

@@ -1321,25 +1319,23 @@ again:
* Try to release leaf bridge's resources that doesn't fit resource of
* child device under that bridge
*/
- for (list = head.next; list;) {
- bus = list->dev->bus;
- pci_bus_release_bridge_resources(bus, list->flags & type_mask,
- rel_type);
- list = list->next;
+ list_for_each_entry(dev_res_x, &fail_head, list) {
+ bus = dev_res_x->dev->bus;
+ pci_bus_release_bridge_resources(bus,
+ dev_res_x->flags & type_mask,
+ rel_type);
}
/* restore size and flags */
- for (list = head.next; list;) {
- struct resource *res = list->res;
+ list_for_each_entry(dev_res_x, &fail_head, list) {
+ struct resource *res = dev_res_x->res;

- res->start = list->start;
- res->end = list->end;
- res->flags = list->flags;
- if (list->dev->subordinate)
+ res->start = dev_res_x->start;
+ res->end = dev_res_x->end;
+ res->flags = dev_res_x->flags;
+ if (dev_res_x->dev->subordinate)
res->flags = 0;
-
- list = list->next;
}
- free_list(resource_list_x, &head);
+ free_list(pci_dev_resource_x, &fail_head);

goto again;

@@ -1356,29 +1352,27 @@ enable_and_dump:
void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge)
{
struct pci_bus *parent = bridge->subordinate;
- struct resource_list_x add_list; /* list of resources that
+ LIST_HEAD(add_list); /* list of resources that
want additional resources */
int tried_times = 0;
- struct resource_list_x head, *list;
+ LIST_HEAD(fail_head);
+ struct pci_dev_resource_x *dev_res_x;
int retval;
unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM |
IORESOURCE_PREFETCH;

- head.next = NULL;
- add_list.next = NULL;
-
again:
__pci_bus_size_bridges(parent, &add_list);
- __pci_bridge_assign_resources(bridge, &add_list, &head);
- BUG_ON(add_list.next);
+ __pci_bridge_assign_resources(bridge, &add_list, &fail_head);
+ BUG_ON(!list_empty(&add_list));
tried_times++;

- if (!head.next)
+ if (list_empty(&fail_head))
goto enable_all;

if (tried_times >= 2) {
/* still fail, don't need to try more */
- free_list(resource_list_x, &head);
+ free_list(pci_dev_resource_x, &fail_head);
goto enable_all;
}

@@ -1389,27 +1383,24 @@ again:
* Try to release leaf bridge's resources that doesn't fit resource of
* child device under that bridge
*/
- for (list = head.next; list;) {
- struct pci_bus *bus = list->dev->bus;
- unsigned long flags = list->flags;
+ list_for_each_entry(dev_res_x, &fail_head, list) {
+ struct pci_bus *bus = dev_res_x->dev->bus;
+ unsigned long flags = dev_res_x->flags;

pci_bus_release_bridge_resources(bus, flags & type_mask,
whole_subtree);
- list = list->next;
}
/* restore size and flags */
- for (list = head.next; list;) {
- struct resource *res = list->res;
+ list_for_each_entry(dev_res_x, &fail_head, list) {
+ struct resource *res = dev_res_x->res;

- res->start = list->start;
- res->end = list->end;
- res->flags = list->flags;
- if (list->dev->subordinate)
+ res->start = dev_res_x->start;
+ res->end = dev_res_x->end;
+ res->flags = dev_res_x->flags;
+ if (dev_res_x->dev->subordinate)
res->flags = 0;
-
- list = list->next;
}
- free_list(resource_list_x, &head);
+ free_list(pci_dev_resource_x, &fail_head);

goto again;

@@ -1434,12 +1425,11 @@ unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
{
unsigned int max;
struct pci_dev *dev;
- struct resource_list_x add_list; /* list of resources that
+ LIST_HEAD(add_list); /* list of resources that
want additional resources */

max = pci_scan_child_bus(bus);

- add_list.next = NULL;
down_read(&pci_bus_sem);
list_for_each_entry(dev, &bus->devices, bus_list)
if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
@@ -1449,7 +1439,7 @@ unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
&add_list);
up_read(&pci_bus_sem);
__pci_bus_assign_resources(bus, &add_list, NULL);
- BUG_ON(add_list.next);
+ BUG_ON(!list_empty(&add_list));

pci_enable_bridges(bus);
pci_bus_add_devices(bus);
--
1.7.7


\
 
 \ /
  Last update: 2012-01-21 11:37    [from the cache]
©2003-2014 Jasper Spaans. Advertise on this site