mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-29 11:11:45 -04:00
Merge remote-tracking branch 'grant/devicetree/next' into for-next
This commit is contained in:
Rob Herring
commit
b5480950c6
505 changed files with 4141 additions and 2556 deletions
|
|
@ -489,7 +489,7 @@ static u64 __of_translate_address(struct device_node *dev,
|
|||
int na, ns, pna, pns;
|
||||
u64 result = OF_BAD_ADDR;
|
||||
|
||||
pr_debug("OF: ** translation for device %s **\n", dev->full_name);
|
||||
pr_debug("OF: ** translation for device %s **\n", of_node_full_name(dev));
|
||||
|
||||
/* Increase refcount at current level */
|
||||
of_node_get(dev);
|
||||
|
|
@ -504,13 +504,13 @@ static u64 __of_translate_address(struct device_node *dev,
|
|||
bus->count_cells(dev, &na, &ns);
|
||||
if (!OF_CHECK_COUNTS(na, ns)) {
|
||||
printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
|
||||
dev->full_name);
|
||||
of_node_full_name(dev));
|
||||
goto bail;
|
||||
}
|
||||
memcpy(addr, in_addr, na * 4);
|
||||
|
||||
pr_debug("OF: bus is %s (na=%d, ns=%d) on %s\n",
|
||||
bus->name, na, ns, parent->full_name);
|
||||
bus->name, na, ns, of_node_full_name(parent));
|
||||
of_dump_addr("OF: translating address:", addr, na);
|
||||
|
||||
/* Translate */
|
||||
|
|
@ -532,12 +532,12 @@ static u64 __of_translate_address(struct device_node *dev,
|
|||
pbus->count_cells(dev, &pna, &pns);
|
||||
if (!OF_CHECK_COUNTS(pna, pns)) {
|
||||
printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
|
||||
dev->full_name);
|
||||
of_node_full_name(dev));
|
||||
break;
|
||||
}
|
||||
|
||||
pr_debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
|
||||
pbus->name, pna, pns, parent->full_name);
|
||||
pbus->name, pna, pns, of_node_full_name(parent));
|
||||
|
||||
/* Apply bus translation */
|
||||
if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop))
|
||||
|
|
|
|||
|
|
@ -272,9 +272,9 @@ static bool __of_find_n_match_cpu_property(struct device_node *cpun,
|
|||
|
||||
ac = of_n_addr_cells(cpun);
|
||||
cell = of_get_property(cpun, prop_name, &prop_len);
|
||||
if (!cell)
|
||||
if (!cell || !ac)
|
||||
return false;
|
||||
prop_len /= sizeof(*cell);
|
||||
prop_len /= sizeof(*cell) * ac;
|
||||
for (tid = 0; tid < prop_len; tid++) {
|
||||
hwid = of_read_number(cell, ac);
|
||||
if (arch_match_cpu_phys_id(cpu, hwid)) {
|
||||
|
|
@ -287,6 +287,31 @@ static bool __of_find_n_match_cpu_property(struct device_node *cpun,
|
|||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* arch_find_n_match_cpu_physical_id - See if the given device node is
|
||||
* for the cpu corresponding to logical cpu 'cpu'. Return true if so,
|
||||
* else false. If 'thread' is non-NULL, the local thread number within the
|
||||
* core is returned in it.
|
||||
*/
|
||||
bool __weak arch_find_n_match_cpu_physical_id(struct device_node *cpun,
|
||||
int cpu, unsigned int *thread)
|
||||
{
|
||||
/* Check for non-standard "ibm,ppc-interrupt-server#s" property
|
||||
* for thread ids on PowerPC. If it doesn't exist fallback to
|
||||
* standard "reg" property.
|
||||
*/
|
||||
if (IS_ENABLED(CONFIG_PPC) &&
|
||||
__of_find_n_match_cpu_property(cpun,
|
||||
"ibm,ppc-interrupt-server#s",
|
||||
cpu, thread))
|
||||
return true;
|
||||
|
||||
if (__of_find_n_match_cpu_property(cpun, "reg", cpu, thread))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* of_get_cpu_node - Get device node associated with the given logical CPU
|
||||
*
|
||||
|
|
@ -307,26 +332,10 @@ static bool __of_find_n_match_cpu_property(struct device_node *cpun,
|
|||
*/
|
||||
struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
|
||||
{
|
||||
struct device_node *cpun, *cpus;
|
||||
struct device_node *cpun;
|
||||
|
||||
cpus = of_find_node_by_path("/cpus");
|
||||
if (!cpus) {
|
||||
pr_warn("Missing cpus node, bailing out\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for_each_child_of_node(cpus, cpun) {
|
||||
if (of_node_cmp(cpun->type, "cpu"))
|
||||
continue;
|
||||
/* Check for non-standard "ibm,ppc-interrupt-server#s" property
|
||||
* for thread ids on PowerPC. If it doesn't exist fallback to
|
||||
* standard "reg" property.
|
||||
*/
|
||||
if (IS_ENABLED(CONFIG_PPC) &&
|
||||
__of_find_n_match_cpu_property(cpun,
|
||||
"ibm,ppc-interrupt-server#s", cpu, thread))
|
||||
return cpun;
|
||||
if (__of_find_n_match_cpu_property(cpun, "reg", cpu, thread))
|
||||
for_each_node_by_type(cpun, "cpu") {
|
||||
if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread))
|
||||
return cpun;
|
||||
}
|
||||
return NULL;
|
||||
|
|
@ -1183,6 +1192,15 @@ int of_property_count_strings(struct device_node *np, const char *propname)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(of_property_count_strings);
|
||||
|
||||
void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
|
||||
{
|
||||
int i;
|
||||
printk("%s %s", msg, of_node_full_name(args->np));
|
||||
for (i = 0; i < args->args_count; i++)
|
||||
printk(i ? ",%08x" : ":%08x", args->args[i]);
|
||||
printk("\n");
|
||||
}
|
||||
|
||||
static int __of_parse_phandle_with_args(const struct device_node *np,
|
||||
const char *list_name,
|
||||
const char *cells_name,
|
||||
|
|
|
|||
170
drivers/of/irq.c
170
drivers/of/irq.c
|
|
@ -31,18 +31,17 @@
|
|||
* @dev: Device node of the device whose interrupt is to be mapped
|
||||
* @index: Index of the interrupt to map
|
||||
*
|
||||
* This function is a wrapper that chains of_irq_map_one() and
|
||||
* This function is a wrapper that chains of_irq_parse_one() and
|
||||
* irq_create_of_mapping() to make things easier to callers
|
||||
*/
|
||||
unsigned int irq_of_parse_and_map(struct device_node *dev, int index)
|
||||
{
|
||||
struct of_irq oirq;
|
||||
struct of_phandle_args oirq;
|
||||
|
||||
if (of_irq_map_one(dev, index, &oirq))
|
||||
if (of_irq_parse_one(dev, index, &oirq))
|
||||
return 0;
|
||||
|
||||
return irq_create_of_mapping(oirq.controller, oirq.specifier,
|
||||
oirq.size);
|
||||
return irq_create_of_mapping(&oirq);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(irq_of_parse_and_map);
|
||||
|
||||
|
|
@ -79,33 +78,34 @@ struct device_node *of_irq_find_parent(struct device_node *child)
|
|||
}
|
||||
|
||||
/**
|
||||
* of_irq_map_raw - Low level interrupt tree parsing
|
||||
* of_irq_parse_raw - Low level interrupt tree parsing
|
||||
* @parent: the device interrupt parent
|
||||
* @intspec: interrupt specifier ("interrupts" property of the device)
|
||||
* @ointsize: size of the passed in interrupt specifier
|
||||
* @addr: address specifier (start of "reg" property of the device)
|
||||
* @out_irq: structure of_irq filled by this function
|
||||
* @addr: address specifier (start of "reg" property of the device) in be32 format
|
||||
* @out_irq: structure of_irq updated by this function
|
||||
*
|
||||
* Returns 0 on success and a negative number on error
|
||||
*
|
||||
* This function is a low-level interrupt tree walking function. It
|
||||
* can be used to do a partial walk with synthetized reg and interrupts
|
||||
* properties, for example when resolving PCI interrupts when no device
|
||||
* node exist for the parent.
|
||||
* node exist for the parent. It takes an interrupt specifier structure as
|
||||
* input, walks the tree looking for any interrupt-map properties, translates
|
||||
* the specifier for each map, and then returns the translated map.
|
||||
*/
|
||||
int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
|
||||
u32 ointsize, const __be32 *addr, struct of_irq *out_irq)
|
||||
int of_irq_parse_raw(const __be32 *addr, struct of_phandle_args *out_irq)
|
||||
{
|
||||
struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL;
|
||||
const __be32 *tmp, *imap, *imask;
|
||||
__be32 initial_match_array[MAX_PHANDLE_ARGS];
|
||||
const __be32 *match_array = initial_match_array;
|
||||
const __be32 *tmp, *imap, *imask, dummy_imask[] = { [0 ... MAX_PHANDLE_ARGS] = ~0 };
|
||||
u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0;
|
||||
int imaplen, match, i;
|
||||
|
||||
pr_debug("of_irq_map_raw: par=%s,intspec=[0x%08x 0x%08x...],ointsize=%d\n",
|
||||
parent->full_name, be32_to_cpup(intspec),
|
||||
be32_to_cpup(intspec + 1), ointsize);
|
||||
#ifdef DEBUG
|
||||
of_print_phandle_args("of_irq_parse_raw: ", out_irq);
|
||||
#endif
|
||||
|
||||
ipar = of_node_get(parent);
|
||||
ipar = of_node_get(out_irq->np);
|
||||
|
||||
/* First get the #interrupt-cells property of the current cursor
|
||||
* that tells us how to interpret the passed-in intspec. If there
|
||||
|
|
@ -126,9 +126,9 @@ int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
|
|||
goto fail;
|
||||
}
|
||||
|
||||
pr_debug("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize);
|
||||
pr_debug("of_irq_parse_raw: ipar=%s, size=%d\n", of_node_full_name(ipar), intsize);
|
||||
|
||||
if (ointsize != intsize)
|
||||
if (out_irq->args_count != intsize)
|
||||
return -EINVAL;
|
||||
|
||||
/* Look for this #address-cells. We have to implement the old linux
|
||||
|
|
@ -147,6 +147,16 @@ int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
|
|||
|
||||
pr_debug(" -> addrsize=%d\n", addrsize);
|
||||
|
||||
/* Range check so that the temporary buffer doesn't overflow */
|
||||
if (WARN_ON(addrsize + intsize > MAX_PHANDLE_ARGS))
|
||||
goto fail;
|
||||
|
||||
/* Precalculate the match array - this simplifies match loop */
|
||||
for (i = 0; i < addrsize; i++)
|
||||
initial_match_array[i] = addr ? addr[i] : 0;
|
||||
for (i = 0; i < intsize; i++)
|
||||
initial_match_array[addrsize + i] = cpu_to_be32(out_irq->args[i]);
|
||||
|
||||
/* Now start the actual "proper" walk of the interrupt tree */
|
||||
while (ipar != NULL) {
|
||||
/* Now check if cursor is an interrupt-controller and if it is
|
||||
|
|
@ -155,15 +165,19 @@ int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
|
|||
if (of_get_property(ipar, "interrupt-controller", NULL) !=
|
||||
NULL) {
|
||||
pr_debug(" -> got it !\n");
|
||||
for (i = 0; i < intsize; i++)
|
||||
out_irq->specifier[i] =
|
||||
of_read_number(intspec +i, 1);
|
||||
out_irq->size = intsize;
|
||||
out_irq->controller = ipar;
|
||||
of_node_put(old);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* interrupt-map parsing does not work without a reg
|
||||
* property when #address-cells != 0
|
||||
*/
|
||||
if (addrsize && !addr) {
|
||||
pr_debug(" -> no reg passed in when needed !\n");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* Now look for an interrupt-map */
|
||||
imap = of_get_property(ipar, "interrupt-map", &imaplen);
|
||||
/* No interrupt map, check for an interrupt parent */
|
||||
|
|
@ -176,34 +190,16 @@ int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
|
|||
|
||||
/* Look for a mask */
|
||||
imask = of_get_property(ipar, "interrupt-map-mask", NULL);
|
||||
|
||||
/* If we were passed no "reg" property and we attempt to parse
|
||||
* an interrupt-map, then #address-cells must be 0.
|
||||
* Fail if it's not.
|
||||
*/
|
||||
if (addr == NULL && addrsize != 0) {
|
||||
pr_debug(" -> no reg passed in when needed !\n");
|
||||
goto fail;
|
||||
}
|
||||
if (!imask)
|
||||
imask = dummy_imask;
|
||||
|
||||
/* Parse interrupt-map */
|
||||
match = 0;
|
||||
while (imaplen > (addrsize + intsize + 1) && !match) {
|
||||
/* Compare specifiers */
|
||||
match = 1;
|
||||
for (i = 0; i < addrsize && match; ++i) {
|
||||
__be32 mask = imask ? imask[i]
|
||||
: cpu_to_be32(0xffffffffu);
|
||||
match = ((addr[i] ^ imap[i]) & mask) == 0;
|
||||
}
|
||||
for (; i < (addrsize + intsize) && match; ++i) {
|
||||
__be32 mask = imask ? imask[i]
|
||||
: cpu_to_be32(0xffffffffu);
|
||||
match =
|
||||
((intspec[i-addrsize] ^ imap[i]) & mask) == 0;
|
||||
}
|
||||
imap += addrsize + intsize;
|
||||
imaplen -= addrsize + intsize;
|
||||
for (i = 0; i < (addrsize + intsize); i++, imaplen--)
|
||||
match = !((match_array[i] ^ *imap++) & imask[i]);
|
||||
|
||||
pr_debug(" -> match=%d (imaplen=%d)\n", match, imaplen);
|
||||
|
||||
|
|
@ -237,6 +233,8 @@ int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
|
|||
newintsize, newaddrsize);
|
||||
|
||||
/* Check for malformed properties */
|
||||
if (WARN_ON(newaddrsize + newintsize > MAX_PHANDLE_ARGS))
|
||||
goto fail;
|
||||
if (imaplen < (newaddrsize + newintsize))
|
||||
goto fail;
|
||||
|
||||
|
|
@ -248,12 +246,18 @@ int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
|
|||
if (!match)
|
||||
goto fail;
|
||||
|
||||
of_node_put(old);
|
||||
old = of_node_get(newpar);
|
||||
/*
|
||||
* Successfully parsed an interrrupt-map translation; copy new
|
||||
* interrupt specifier into the out_irq structure
|
||||
*/
|
||||
of_node_put(out_irq->np);
|
||||
out_irq->np = of_node_get(newpar);
|
||||
|
||||
match_array = imap - newaddrsize - newintsize;
|
||||
for (i = 0; i < newintsize; i++)
|
||||
out_irq->args[i] = be32_to_cpup(imap - newintsize + i);
|
||||
out_irq->args_count = intsize = newintsize;
|
||||
addrsize = newaddrsize;
|
||||
intsize = newintsize;
|
||||
intspec = imap - intsize;
|
||||
addr = intspec - addrsize;
|
||||
|
||||
skiplevel:
|
||||
/* Iterate again with new parent */
|
||||
|
|
@ -264,46 +268,53 @@ int of_irq_map_raw(struct device_node *parent, const __be32 *intspec,
|
|||
}
|
||||
fail:
|
||||
of_node_put(ipar);
|
||||
of_node_put(old);
|
||||
of_node_put(out_irq->np);
|
||||
of_node_put(newpar);
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(of_irq_map_raw);
|
||||
EXPORT_SYMBOL_GPL(of_irq_parse_raw);
|
||||
|
||||
/**
|
||||
* of_irq_map_one - Resolve an interrupt for a device
|
||||
* of_irq_parse_one - Resolve an interrupt for a device
|
||||
* @device: the device whose interrupt is to be resolved
|
||||
* @index: index of the interrupt to resolve
|
||||
* @out_irq: structure of_irq filled by this function
|
||||
*
|
||||
* This function resolves an interrupt, walking the tree, for a given
|
||||
* device-tree node. It's the high level pendant to of_irq_map_raw().
|
||||
* This function resolves an interrupt for a node by walking the interrupt tree,
|
||||
* finding which interrupt controller node it is attached to, and returning the
|
||||
* interrupt specifier that can be used to retrieve a Linux IRQ number.
|
||||
*/
|
||||
int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq)
|
||||
int of_irq_parse_one(struct device_node *device, int index, struct of_phandle_args *out_irq)
|
||||
{
|
||||
struct device_node *p;
|
||||
const __be32 *intspec, *tmp, *addr;
|
||||
u32 intsize, intlen;
|
||||
int res = -EINVAL;
|
||||
int i, res = -EINVAL;
|
||||
|
||||
pr_debug("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index);
|
||||
pr_debug("of_irq_parse_one: dev=%s, index=%d\n", of_node_full_name(device), index);
|
||||
|
||||
/* OldWorld mac stuff is "special", handle out of line */
|
||||
if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
|
||||
return of_irq_map_oldworld(device, index, out_irq);
|
||||
|
||||
/* Get the interrupts property */
|
||||
intspec = of_get_property(device, "interrupts", &intlen);
|
||||
if (intspec == NULL)
|
||||
return -EINVAL;
|
||||
intlen /= sizeof(*intspec);
|
||||
|
||||
pr_debug(" intspec=%d intlen=%d\n", be32_to_cpup(intspec), intlen);
|
||||
return of_irq_parse_oldworld(device, index, out_irq);
|
||||
|
||||
/* Get the reg property (if any) */
|
||||
addr = of_get_property(device, "reg", NULL);
|
||||
|
||||
/* Get the interrupts property */
|
||||
intspec = of_get_property(device, "interrupts", &intlen);
|
||||
if (intspec == NULL) {
|
||||
/* Try the new-style interrupts-extended */
|
||||
res = of_parse_phandle_with_args(device, "interrupts-extended",
|
||||
"#interrupt-cells", index, out_irq);
|
||||
if (res)
|
||||
return -EINVAL;
|
||||
return of_irq_parse_raw(addr, out_irq);
|
||||
}
|
||||
intlen /= sizeof(*intspec);
|
||||
|
||||
pr_debug(" intspec=%d intlen=%d\n", be32_to_cpup(intspec), intlen);
|
||||
|
||||
/* Look for the interrupt parent. */
|
||||
p = of_irq_find_parent(device);
|
||||
if (p == NULL)
|
||||
|
|
@ -321,14 +332,20 @@ int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq
|
|||
if ((index + 1) * intsize > intlen)
|
||||
goto out;
|
||||
|
||||
/* Get new specifier and map it */
|
||||
res = of_irq_map_raw(p, intspec + index * intsize, intsize,
|
||||
addr, out_irq);
|
||||
/* Copy intspec into irq structure */
|
||||
intspec += index * intsize;
|
||||
out_irq->np = p;
|
||||
out_irq->args_count = intsize;
|
||||
for (i = 0; i < intsize; i++)
|
||||
out_irq->args[i] = be32_to_cpup(intspec++);
|
||||
|
||||
/* Check if there are any interrupt-map translations to process */
|
||||
res = of_irq_parse_raw(addr, out_irq);
|
||||
out:
|
||||
of_node_put(p);
|
||||
return res;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(of_irq_map_one);
|
||||
EXPORT_SYMBOL_GPL(of_irq_parse_one);
|
||||
|
||||
/**
|
||||
* of_irq_to_resource - Decode a node's IRQ and return it as a resource
|
||||
|
|
@ -354,8 +371,8 @@ int of_irq_to_resource(struct device_node *dev, int index, struct resource *r)
|
|||
&name);
|
||||
|
||||
r->start = r->end = irq;
|
||||
r->flags = IORESOURCE_IRQ;
|
||||
r->name = name ? name : dev->full_name;
|
||||
r->flags = IORESOURCE_IRQ | irqd_get_trigger_type(irq_get_irq_data(irq));
|
||||
r->name = name ? name : of_node_full_name(dev);
|
||||
}
|
||||
|
||||
return irq;
|
||||
|
|
@ -368,9 +385,10 @@ EXPORT_SYMBOL_GPL(of_irq_to_resource);
|
|||
*/
|
||||
int of_irq_count(struct device_node *dev)
|
||||
{
|
||||
struct of_phandle_args irq;
|
||||
int nr = 0;
|
||||
|
||||
while (of_irq_to_resource(dev, nr, NULL))
|
||||
while (of_irq_parse_one(dev, nr, &irq) == 0)
|
||||
nr++;
|
||||
|
||||
return nr;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
#include <linux/export.h>
|
||||
|
||||
/**
|
||||
* of_irq_map_pci - Resolve the interrupt for a PCI device
|
||||
* of_irq_parse_pci - Resolve the interrupt for a PCI device
|
||||
* @pdev: the device whose interrupt is to be resolved
|
||||
* @out_irq: structure of_irq filled by this function
|
||||
*
|
||||
|
|
@ -14,7 +14,7 @@
|
|||
* PCI tree until an device-node is found, at which point it will finish
|
||||
* resolving using the OF tree walking.
|
||||
*/
|
||||
int of_irq_map_pci(const struct pci_dev *pdev, struct of_irq *out_irq)
|
||||
int of_irq_parse_pci(const struct pci_dev *pdev, struct of_phandle_args *out_irq)
|
||||
{
|
||||
struct device_node *dn, *ppnode;
|
||||
struct pci_dev *ppdev;
|
||||
|
|
@ -29,7 +29,7 @@ int of_irq_map_pci(const struct pci_dev *pdev, struct of_irq *out_irq)
|
|||
*/
|
||||
dn = pci_device_to_OF_node(pdev);
|
||||
if (dn) {
|
||||
rc = of_irq_map_one(dn, 0, out_irq);
|
||||
rc = of_irq_parse_one(dn, 0, out_irq);
|
||||
if (!rc)
|
||||
return rc;
|
||||
}
|
||||
|
|
@ -84,9 +84,37 @@ int of_irq_map_pci(const struct pci_dev *pdev, struct of_irq *out_irq)
|
|||
pdev = ppdev;
|
||||
}
|
||||
|
||||
out_irq->np = ppnode;
|
||||
out_irq->args_count = 1;
|
||||
out_irq->args[0] = lspec;
|
||||
lspec_be = cpu_to_be32(lspec);
|
||||
laddr[0] = cpu_to_be32((pdev->bus->number << 16) | (pdev->devfn << 8));
|
||||
laddr[1] = laddr[2] = cpu_to_be32(0);
|
||||
return of_irq_map_raw(ppnode, &lspec_be, 1, laddr, out_irq);
|
||||
laddr[1] = laddr[2] = cpu_to_be32(0);
|
||||
return of_irq_parse_raw(laddr, out_irq);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(of_irq_map_pci);
|
||||
EXPORT_SYMBOL_GPL(of_irq_parse_pci);
|
||||
|
||||
/**
|
||||
* of_irq_parse_and_map_pci() - Decode a PCI irq from the device tree and map to a virq
|
||||
* @dev: The pci device needing an irq
|
||||
* @slot: PCI slot number; passed when used as map_irq callback. Unused
|
||||
* @pin: PCI irq pin number; passed when used as map_irq callback. Unused
|
||||
*
|
||||
* @slot and @pin are unused, but included in the function so that this
|
||||
* function can be used directly as the map_irq callback to pci_fixup_irqs().
|
||||
*/
|
||||
int of_irq_parse_and_map_pci(const struct pci_dev *dev, u8 slot, u8 pin)
|
||||
{
|
||||
struct of_phandle_args oirq;
|
||||
int ret;
|
||||
|
||||
ret = of_irq_parse_pci(dev, &oirq);
|
||||
if (ret) {
|
||||
dev_err(&dev->dev, "of_irq_parse_pci() failed with rc=%d\n", ret);
|
||||
return 0; /* Proper return code 0 == NO_IRQ */
|
||||
}
|
||||
|
||||
return irq_create_of_mapping(&oirq);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(of_irq_parse_and_map_pci);
|
||||
|
||||
|
|
|
|||
|
|
@ -9,18 +9,24 @@
|
|||
#include <linux/errno.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_irq.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/device.h>
|
||||
|
||||
static bool selftest_passed = true;
|
||||
static struct selftest_results {
|
||||
int passed;
|
||||
int failed;
|
||||
} selftest_results;
|
||||
|
||||
#define selftest(result, fmt, ...) { \
|
||||
if (!(result)) { \
|
||||
pr_err("FAIL %s:%i " fmt, __FILE__, __LINE__, ##__VA_ARGS__); \
|
||||
selftest_passed = false; \
|
||||
selftest_results.failed++; \
|
||||
pr_err("FAIL %s():%i " fmt, __func__, __LINE__, ##__VA_ARGS__); \
|
||||
} else { \
|
||||
pr_info("pass %s:%i\n", __FILE__, __LINE__); \
|
||||
selftest_results.passed++; \
|
||||
pr_debug("pass %s():%i\n", __func__, __LINE__); \
|
||||
} \
|
||||
}
|
||||
|
||||
|
|
@ -131,7 +137,6 @@ static void __init of_selftest_property_match_string(void)
|
|||
struct device_node *np;
|
||||
int rc;
|
||||
|
||||
pr_info("start\n");
|
||||
np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
|
||||
if (!np) {
|
||||
pr_err("No testcase data in device tree\n");
|
||||
|
|
@ -154,6 +159,147 @@ static void __init of_selftest_property_match_string(void)
|
|||
selftest(rc == -EILSEQ, "unterminated string; rc=%i", rc);
|
||||
}
|
||||
|
||||
static void __init of_selftest_parse_interrupts(void)
|
||||
{
|
||||
struct device_node *np;
|
||||
struct of_phandle_args args;
|
||||
int i, rc;
|
||||
|
||||
np = of_find_node_by_path("/testcase-data/interrupts/interrupts0");
|
||||
if (!np) {
|
||||
pr_err("missing testcase data\n");
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
bool passed = true;
|
||||
args.args_count = 0;
|
||||
rc = of_irq_parse_one(np, i, &args);
|
||||
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 1);
|
||||
passed &= (args.args[0] == (i + 1));
|
||||
|
||||
selftest(passed, "index %i - data error on node %s rc=%i\n",
|
||||
i, args.np->full_name, rc);
|
||||
}
|
||||
of_node_put(np);
|
||||
|
||||
np = of_find_node_by_path("/testcase-data/interrupts/interrupts1");
|
||||
if (!np) {
|
||||
pr_err("missing testcase data\n");
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
bool passed = true;
|
||||
args.args_count = 0;
|
||||
rc = of_irq_parse_one(np, i, &args);
|
||||
|
||||
/* Test the values from tests-phandle.dtsi */
|
||||
switch (i) {
|
||||
case 0:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 1);
|
||||
passed &= (args.args[0] == 9);
|
||||
break;
|
||||
case 1:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 3);
|
||||
passed &= (args.args[0] == 10);
|
||||
passed &= (args.args[1] == 11);
|
||||
passed &= (args.args[2] == 12);
|
||||
break;
|
||||
case 2:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 2);
|
||||
passed &= (args.args[0] == 13);
|
||||
passed &= (args.args[1] == 14);
|
||||
break;
|
||||
case 3:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 2);
|
||||
passed &= (args.args[0] == 15);
|
||||
passed &= (args.args[1] == 16);
|
||||
break;
|
||||
default:
|
||||
passed = false;
|
||||
}
|
||||
selftest(passed, "index %i - data error on node %s rc=%i\n",
|
||||
i, args.np->full_name, rc);
|
||||
}
|
||||
of_node_put(np);
|
||||
}
|
||||
|
||||
static void __init of_selftest_parse_interrupts_extended(void)
|
||||
{
|
||||
struct device_node *np;
|
||||
struct of_phandle_args args;
|
||||
int i, rc;
|
||||
|
||||
np = of_find_node_by_path("/testcase-data/interrupts/interrupts-extended0");
|
||||
if (!np) {
|
||||
pr_err("missing testcase data\n");
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < 7; i++) {
|
||||
bool passed = true;
|
||||
rc = of_irq_parse_one(np, i, &args);
|
||||
|
||||
/* Test the values from tests-phandle.dtsi */
|
||||
switch (i) {
|
||||
case 0:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 1);
|
||||
passed &= (args.args[0] == 1);
|
||||
break;
|
||||
case 1:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 3);
|
||||
passed &= (args.args[0] == 2);
|
||||
passed &= (args.args[1] == 3);
|
||||
passed &= (args.args[2] == 4);
|
||||
break;
|
||||
case 2:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 2);
|
||||
passed &= (args.args[0] == 5);
|
||||
passed &= (args.args[1] == 6);
|
||||
break;
|
||||
case 3:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 1);
|
||||
passed &= (args.args[0] == 9);
|
||||
break;
|
||||
case 4:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 3);
|
||||
passed &= (args.args[0] == 10);
|
||||
passed &= (args.args[1] == 11);
|
||||
passed &= (args.args[2] == 12);
|
||||
break;
|
||||
case 5:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 2);
|
||||
passed &= (args.args[0] == 13);
|
||||
passed &= (args.args[1] == 14);
|
||||
break;
|
||||
case 6:
|
||||
passed &= !rc;
|
||||
passed &= (args.args_count == 1);
|
||||
passed &= (args.args[0] == 15);
|
||||
break;
|
||||
default:
|
||||
passed = false;
|
||||
}
|
||||
|
||||
selftest(passed, "index %i - data error on node %s rc=%i\n",
|
||||
i, args.np->full_name, rc);
|
||||
}
|
||||
of_node_put(np);
|
||||
}
|
||||
|
||||
static int __init of_selftest(void)
|
||||
{
|
||||
struct device_node *np;
|
||||
|
|
@ -168,7 +314,10 @@ static int __init of_selftest(void)
|
|||
pr_info("start of selftest - you will see error messages\n");
|
||||
of_selftest_parse_phandle_with_args();
|
||||
of_selftest_property_match_string();
|
||||
pr_info("end of selftest - %s\n", selftest_passed ? "PASS" : "FAIL");
|
||||
of_selftest_parse_interrupts();
|
||||
of_selftest_parse_interrupts_extended();
|
||||
pr_info("end of selftest - %i passed, %i failed\n",
|
||||
selftest_results.passed, selftest_results.failed);
|
||||
return 0;
|
||||
}
|
||||
late_initcall(of_selftest);
|
||||
|
|
|
|||
Loading…
Reference in a new issue